@trap_stevo/filetide 0.0.84 → 0.0.86

package/dist/cjs/HUDManagers/FileTransferManager.js

@@ -4,18 +4,43 @@ function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a
 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 fs = require("fs");
+const {
+  FileTideNetworkTrafficManager
+} = require("./FileTideNetworkTrafficManager.js");
 var _FileTransferManager_brand = /*#__PURE__*/new WeakSet();
 class FileTransferManager {
   constructor({
-    chunkSize = 512 * 1024,
-    parallelChunks = 5,
-    maxRetries = 3
+    chunkSize: _chunkSize = 512 * 1024,
+    parallelChunks = 3,
+    maxRetries = 3,
+    networkTraffic = {}
   } = {}) {
     _classPrivateMethodInitSpec(this, _FileTransferManager_brand);
-    this.parallelChunks = parallelChunks;
+    this.parallelChunks = Math.max(1, parallelChunks);
     this.activeTransfers = new Map();
     this.maxRetries = maxRetries;
-    this.chunkSize = chunkSize;
+    this.chunkSize = _chunkSize;
+    this.networkTraffic = new FileTideNetworkTrafficManager({
+      defaultBandwidthBps: 32 * 1024 * 1024,
+      minimumBandwidthBps: 512 * 1024,
+      targetUtilization: 0.90,
+      congestedUtilizationFactor: 0.60,
+      targetChunkDurationMs: 250,
+      minChunkSize: _chunkSize,
+      maxChunkSize: _chunkSize,
+      burstSeconds: 0.20,
+      congestedLatencyMs: 250,
+      unstableLatencyMs: 1000,
+      congestedFailureRate: 0.10,
+      unstableFailureRate: 0.30,
+      sampleWindowSize: 20,
+      smoothingFactor: 0.25,
+      throughputProbeIntervalMs: 750,
+      throughputProbeGrowthFactor: 1.18,
+      healthyThroughputRatio: 0.90,
+      degradedThroughputRatio: 0.72,
+      ...networkTraffic
+    });
   }
   async sendFile(file, {
     fileDetails,
@@ -35,6 +60,7 @@ class FileTransferManager {
     recipientID,
     onSendChunk,
     onComplete,
+    onFailure,
     onProgress,
     onStart,
     onTiding
@@ -50,8 +76,8 @@ class FileTransferManager {
       currentChunk: 0,
       size: fileDetails.size
     });
+    const transferState = this.activeTransfers.get(transferId);
     const updateProgress = () => {
-      const transferState = this.activeTransfers.get(transferId);
       if (onProgress) {
         onProgress(transferState.completedChunks / transferState.totalChunks * 100, this.chunkSize);
       }
@@ -62,31 +88,34 @@ class FileTransferManager {
     const sendChunk = async chunkIndex => {
       const start = chunkIndex * this.chunkSize;
       const end = Math.min(start + this.chunkSize, fileDetails.size);
+      const actualChunkSize = end - start;
+      await _assertClassBrand(_FileTransferManager_brand, this, _waitForChunkAdmission).call(this, actualChunkSize);
       const {
         buffer
-      } = await fileHandle.read(Buffer.alloc(end - start), 0, end - start, start);
-      const transferState = this.activeTransfers.get(transferId);
+      } = await fileHandle.read(Buffer.alloc(actualChunkSize), 0, actualChunkSize, start);
+      transferState.activeChunks++;
       chunkBuffer.set(chunkIndex, buffer);
       try {
         while (chunkBuffer.has(nextExpectedChunk)) {
           const nextChunkBuffer = chunkBuffer.get(nextExpectedChunk);
-          await onSendChunk(transferId, nextExpectedChunk, this.chunkSize, nextChunkBuffer, totalChunks, this.activeTransfers.get(transferId).completedChunks + 1);
+          const nextChunkSize = nextChunkBuffer.length;
+          await onSendChunk(transferId, nextExpectedChunk, nextChunkSize, nextChunkBuffer, totalChunks, transferState.completedChunks + 1);
           chunkBuffer.delete(nextExpectedChunk);
           nextExpectedChunk++;
-          transferState.transferredSize += this.chunkSize;
+          transferState.transferredSize += nextChunkSize;
           transferState.completedChunks++;
           updateProgress();
         }
         if (transferState.completedChunks === transferState.totalChunks) {
-          return onComplete(transferId).then(() => {
-            this.activeTransfers.delete(transferId);
-          });
+          if (onComplete) {
+            await onComplete(transferId);
+          }
         }
       } catch (error) {
         console.error(`[FileTide ~ Transporter] ~ Did not send chunk ${chunkIndex} ~ ${error.message}`);
-        return onComplete(transferId).then(() => {
-          this.activeTransfers.delete(transferId);
-        });
+        throw error;
+      } finally {
+        transferState.activeChunks--;
       }
     };
     const sendChunkBatch = async (startChunkIndex, batchSize = 100, miniBatchSize = 10) => {
@@ -97,41 +126,51 @@ class FileTransferManager {
           miniBatchPromises.push(sendChunk(chunkIndex));
         }
         await Promise.all(miniBatchPromises);
-        await new Promise(resolve => setTimeout(resolve, 5));
+        await new Promise(resolve => setImmediate(resolve));
       }
     };
-    const transferState = this.activeTransfers.get(transferId);
     let currentBatchStart = transferState.currentChunk;
     const keepAliveInterval = setInterval(() => {
-      if (onTiding) onTiding();
+      if (onTiding) {
+        onTiding();
+      }
     }, 5000);
-    return new Promise(async (resolve, reject) => {
-      try {
-        let adaptiveBatchSize = 100;
-        while (currentBatchStart < totalChunks) {
-          if (transferState.activeChunks < this.parallelChunks) {
-            adaptiveBatchSize = Math.min(adaptiveBatchSize + 10, 100);
-          } else {
-            adaptiveBatchSize = Math.max(adaptiveBatchSize - 10, 10);
-          }
-          await sendChunkBatch(currentBatchStart, adaptiveBatchSize);
-          currentBatchStart += adaptiveBatchSize;
-          await new Promise(resolve => setTimeout(resolve, 30));
-        }
-      } finally {
-        clearInterval(keepAliveInterval);
-        fileHandle.on("close", resolve);
-        fileHandle.on("error", error => {
-          this.activeTransfers.delete(transferId);
-          reject(error);
-        });
-        try {
-          await fileHandle.close();
-        } catch (error) {
-          console.error(`[FileTide ~ Transporter] ~ Error closing file handle ~ ${error.message}`);
+    try {
+      let adaptiveBatchSize = 100;
+      while (currentBatchStart < totalChunks) {
+        if (transferState.activeChunks < this.parallelChunks) {
+          adaptiveBatchSize = Math.min(adaptiveBatchSize + 10, 100);
+        } else {
+          adaptiveBatchSize = Math.max(adaptiveBatchSize - 10, 10);
         }
+        await sendChunkBatch(currentBatchStart, adaptiveBatchSize);
+        currentBatchStart += adaptiveBatchSize;
+        await new Promise(resolve => setImmediate(resolve));
       }
-    });
+    } catch (error) {
+      if (onFailure) {
+        await onFailure(transferId, error);
+      }
+      throw error;
+    } finally {
+      clearInterval(keepAliveInterval);
+      this.activeTransfers.delete(transferId);
+    }
+  }
+  getNetworkTrafficStatus() {
+    return this.networkTraffic.getStatus();
+  }
+  updateNetworkTraffic(sample = {}) {
+    return this.networkTraffic.updateNetworkSample(sample);
+  }
+  recordNetworkThroughput(throughputBps) {
+    return this.networkTraffic.recordDeliveredThroughput(throughputBps);
+  }
+  pauseTransfers(reason = "requested") {
+    return this.networkTraffic.pause(reason);
+  }
+  resumeTransfers(reason = "requested") {
+    return this.networkTraffic.resume(reason);
   }
 }
 async function _startTransfer(file, transferId, fileDetails, originDetails, onSendChunk, onComplete, onProgress, onStart, onTiding, clientTide) {
@@ -158,9 +197,11 @@ async function _startTransfer(file, transferId, fileDetails, originDetails, onSe
     const start = chunkIndex * this.chunkSize;
     const end = Math.min(start + this.chunkSize, file.length);
     const chunk = file.slice(start, end);
+    const actualChunkSize = chunk.length;
+    await _assertClassBrand(_FileTransferManager_brand, this, _waitForChunkAdmission).call(this, actualChunkSize);
     transferState.activeChunks++;
     try {
-      await onSendChunk(transferId, chunkIndex, this.chunkSize, chunk, totalChunks, transferState.completedChunks + 1);
+      await onSendChunk(transferId, chunkIndex, actualChunkSize, chunk, totalChunks, transferState.completedChunks + 1);
       chunkBuffer.set(chunkIndex, chunk);
       while (chunkBuffer.has(nextExpectedChunk)) {
         chunkBuffer.delete(nextExpectedChunk);
@@ -214,121 +255,13 @@ async function _startTransfer(file, transferId, fileDetails, originDetails, onSe
     clearInterval(keepAliveInterval);
   }
 }
-/*async #startTransfer(file, transferId, fileDetails, originDetails, onSendChunk, onComplete, onProgress, onStart, onTiding, clientTide)
-{
-    const totalChunks = Math.ceil(file.length / this.chunkSize);
-    
-    this.activeTransfers.set(transferId, {
-        totalChunks,
-        transferredSize : 0,
-        completedChunks : 0,
-        activeChunks : 0,
-        failedChunks : new Map(),
-        currentChunk : 0,
-        size : fileDetails.size
-    });
-      const updateProgress = () => {
-        const transferState = this.activeTransfers.get(transferId);
-        
-        if (onProgress)
-        {
-            onProgress((transferState.completedChunks / transferState.totalChunks) * 100, this.chunkSize);
-        }
-    };
-    
-    const keepAliveInterval = setInterval(() => {
-        if (onTiding) onTiding();
-    }, 5000);
-    
-    const exponentialBackoff = (retryCount) => Math.min(1000 * (2 ** retryCount), 10000);
-    
-    return new Promise((resolve, reject) => {
-        const sendChunk = async (chunkIndex) => {
-            const transferState = this.activeTransfers.get(transferId);
-            
-            if (chunkIndex >= transferState.totalChunks) { return; }
-              const start = chunkIndex * this.chunkSize;
-            
-            const end = Math.min(start + this.chunkSize, file.length);
-            
-            const chunk = file.slice(start, end);
-            
-            if (onStart && chunkIndex === 0)
-            {
-                onStart({
-                    name : fileDetails.name,
-                    path : fileDetails.path,
-                    size : fileDetails.size,
-                    totalChunks : transferState.totalChunks
-                });
-            }
-            
-            transferState.activeChunks++;
-            
-            try
-            {
-                await onSendChunk(transferId, chunkIndex, this.chunkSize, chunk, transferState.totalChunks, transferState.completedChunks + 1);
-                
-                transferState.transferredSize += this.chunkSize;
-                
-                transferState.completedChunks++;
-                
-                transferState.activeChunks--;
-                
-                updateProgress();
-                
-                if (transferState.activeChunks < this.parallelChunks && transferState.currentChunk < transferState.totalChunks)
-                {
-                    sendChunk(transferState.currentChunk++);
-                }
-                
-                if (transferState.completedChunks === transferState.totalChunks)
-                {
-                    await onComplete(transferId);
-                    
-                    this.activeTransfers.delete(transferId);
-                    
-                    clearInterval(keepAliveInterval);
-                    
-                    resolve();
-                }
-            }
-            catch (error)
-            {
-                console.error(`[FileTide ~ File Messager] ~ Did not send chunk ${chunkIndex} ~ ${error.message}`);
-                
-                transferState.activeChunks--;
-                
-                const retryCount = (transferState.failedChunks.get(chunkIndex) || 0) + 1;
-                
-                if (retryCount > this.maxRetries)
-                {
-                    this.activeTransfers.delete(transferId);
-                    
-                    clearInterval(keepAliveInterval);
-                    
-                    reject(new Error(`Did not send chunk ${chunkIndex} after ${this.maxRetries} retries.`));
-                }
-                else
-                {
-                    transferState.failedChunks.set(chunkIndex, retryCount);
-                    
-                    setTimeout(() => sendChunk(chunkIndex), exponentialBackoff(retryCount));
-                }
-            }
-        };
-        
-        const transferState = this.activeTransfers.get(transferId);
-        
-        for (let i = 0; i < Math.min(this.parallelChunks, transferState.totalChunks); i++)
-        {
-            sendChunk(transferState.currentChunk++);
-        }
-    });
-}*/
 function _generateTransferId(file) {
   return `${file.name}-${Date.now()}`;
 }
+function _waitForChunkAdmission(chunkSize) {
+  return this.networkTraffic.waitForChunkAdmission(chunkSize);
+}
+;
 module.exports = {
   FileTransferManager
 };

package/dist/cjs/HUDManagers/FileTransferReceiverManager.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 path = require("path");
 const fs = require("fs");
 const {
@@ -11,14 +14,18 @@ const {
 const {
   FileUtilityManager
 } = require("./FileUtilityManager.js");
+var _FileTransferReceiverManager_brand = /*#__PURE__*/new WeakSet();
 class FileTransferReceiverManager {
-  constructor() {}
+  constructor() {
+    _classPrivateMethodInitSpec(this, _FileTransferReceiverManager_brand);
+    this.tideQueues = new Map();
+  }
   async initializeTransfer(data, onError) {
     const savePath = FileUtilityManager.getTidePath(path.join(data.path || data.filePath, data.fileName));
     FileTideDebugUtilityManager.log("notice", true, `Initializing transfer ~ ${data.fileName} | ${savePath}...`);
     if (FileTransferTrackingManager.containsTransfer(data.fileName)) {
       FileTideDebugUtilityManager.log("notice", true, `Transfer ~ ${data.fileName} | ${savePath} already initialized.`);
-      return;
+      return FileTransferTrackingManager.getTransfer(data.fileName);
     }
     try {
       const dir = path.dirname(savePath);
@@ -31,29 +38,70 @@ class FileTransferReceiverManager {
         flags: "w"
       });
       FileTransferTrackingManager.trackTransfer(data, fileStream);
+      const transferState = FileTransferTrackingManager.getTransfer(data.fileName);
+      if (transferState && transferState.highestContiguousChunk === undefined) {
+        transferState.highestContiguousChunk = -1;
+      }
       FileTideDebugUtilityManager.log("notice", true, `Initialized transfer ~ ${data.fileName} | ${savePath}!`);
+      return transferState;
     } catch (error) {
       FileTideDebugUtilityManager.log("error", true, `Did not initialize transfer ~ ${data.fileName} | ${savePath}.\n\t\t${error}`);
       if (onError) {
         onError(`[${data.fileName}] Did not initialize transfer ~ ${error.message}`);
       }
+      throw error;
     }
   }
   async handleTransferProgress(data, onError) {
     let transferState = FileTransferTrackingManager.getTransfer(data.fileName);
     if (!transferState) {
-      await this.initializeTransfer(data);
-      transferState = tFileTransferTrackingManager.getTransfer(data.fileName);
+      transferState = await this.initializeTransfer(data, onError);
+    }
+    if (transferState.highestContiguousChunk === undefined) {
+      transferState.highestContiguousChunk = -1;
     }
-    const chunkBuffer = Buffer.from(data.fileChunk);
     try {
-      transferState.fileStream.write(chunkBuffer);
-      transferState.receivedChunks.add(data.chunkIndex);
+      const expectedChunkIndex = transferState.highestContiguousChunk + 1;
+      if (data.chunkIndex !== expectedChunkIndex) {
+        throw new Error(`[${data.fileName}] Out-of-order chunk. Expected ${expectedChunkIndex}, received ${data.chunkIndex}.`);
+      }
+      await _assertClassBrand(_FileTransferReceiverManager_brand, this, _writeChunk).call(this, transferState, data);
+      return {
+        highestContiguousChunk: transferState.highestContiguousChunk,
+        receivedChunks: transferState.receivedChunks.size,
+        totalChunks: transferState.totalChunks
+      };
     } catch (error) {
       FileTideDebugUtilityManager.log("error", true, `Did not write chunk ${data.chunkIndex} ~ ${data.fileName}.\n\t\t${error}`);
       if (onError) {
         onError(`[${data.fileName}] Did not write chunk ${data.chunkIndex} ~ ${error.message}`);
       }
+      throw error;
+    }
+  }
+  async handleTransferTide(tide, onError) {
+    const transferKey = tide?.transferId || tide?.fileName;
+    if (!transferKey) {
+      throw new Error("Received Tide without a transfer identifier.");
+    }
+    const previousTide = this.tideQueues.get(transferKey) || Promise.resolve();
+
+    /*
+     * Serialize Tides for the same transfer, but do not allow one
+     * rejected Tide promise to poison the queue chain itself. The
+     * next Tide still runs its own validation against the authoritative
+     * contiguous receiver state and will fail explicitly if a gap remains.
+     */
+    const currentTide = previousTide.catch(() => undefined).then(() => {
+      return _assertClassBrand(_FileTransferReceiverManager_brand, this, _processTransferTide).call(this, tide, onError);
+    });
+    this.tideQueues.set(transferKey, currentTide);
+    try {
+      return await currentTide;
+    } finally {
+      if (this.tideQueues.get(transferKey) === currentTide) {
+        this.tideQueues.delete(transferKey);
+      }
     }
   }
   async completeTransfer(data, onComplete) {
@@ -67,8 +115,18 @@ class FileTransferReceiverManager {
     try {
       FileTideDebugUtilityManager.log("notice", true, `Verifying transfer state ~ ${data.fileName} completion (${transferState.receivedChunks.size}/${transferState.totalChunks})...`);
       FileTideDebugUtilityManager.log("notice", true, `Transfer state ~ ${data.fileName} completed ~ (${transferState.receivedChunks.size === transferState.totalChunks}).`);
-      if (transferState.receivedChunks.size === transferState.totalChunks) {
-        transferState.fileStream.end();
+      if (transferState.receivedChunks.size === transferState.totalChunks && transferState.highestContiguousChunk === transferState.totalChunks - 1) {
+        await new Promise((resolve, reject) => {
+          const onError = error => {
+            transferState.fileStream.removeListener("error", onError);
+            reject(error);
+          };
+          transferState.fileStream.once("error", onError);
+          transferState.fileStream.end(() => {
+            transferState.fileStream.removeListener("error", onError);
+            resolve();
+          });
+        });
         console.log(`[${data.fileName}] Transfer complete. All chunks received and file written.`);
         FileTransferTrackingManager.untrackTransfer(data.fileName);
         FileTideDebugUtilityManager.log("notice", true, `Cleared transfer state ~ ${data.fileName}.`);
@@ -86,6 +144,108 @@ class FileTransferReceiverManager {
     }
   }
 }
+async function _waitForDrain(fileStream) {
+  return await new Promise((resolve, reject) => {
+    const onDrain = () => {
+      cleanup();
+      resolve();
+    };
+    const onError = error => {
+      cleanup();
+      reject(error);
+    };
+    const cleanup = () => {
+      fileStream.removeListener("drain", onDrain);
+      fileStream.removeListener("error", onError);
+    };
+    fileStream.once("drain", onDrain);
+    fileStream.once("error", onError);
+  });
+}
+async function _writeChunk(transferState, data) {
+  const chunkBuffer = Buffer.isBuffer(data.fileChunk) ? data.fileChunk : Buffer.from(data.fileChunk);
+  const canContinue = transferState.fileStream.write(chunkBuffer);
+  if (!canContinue) {
+    await _assertClassBrand(_FileTransferReceiverManager_brand, this, _waitForDrain).call(this, transferState.fileStream);
+  }
+  transferState.receivedChunks.add(data.chunkIndex);
+  while (transferState.receivedChunks.has(transferState.highestContiguousChunk + 1)) {
+    transferState.highestContiguousChunk++;
+  }
+}
+async function _processTransferTide(tide, onError) {
+  const {
+    transferId,
+    senderID,
+    recipientId,
+    fileName,
+    filePath,
+    fileSize,
+    totalChunks,
+    firstChunkIndex,
+    lastChunkIndex,
+    chunks = [],
+    metadata = {}
+  } = tide;
+  if (!Array.isArray(chunks) || chunks.length <= 0) {
+    throw new Error(`[${fileName}] Received an empty Tide.`);
+  }
+  if (firstChunkIndex !== chunks[0].chunkIndex || lastChunkIndex !== chunks[chunks.length - 1].chunkIndex) {
+    throw new Error(`[${fileName}] Tide boundary metadata does not match its chunks.`);
+  }
+  let expectedChunkIndex = firstChunkIndex;
+  for (const chunk of chunks) {
+    if (chunk.chunkIndex !== expectedChunkIndex) {
+      throw new Error(`[${fileName}] Tide ordering violation. Expected chunk ${expectedChunkIndex}, received ${chunk.chunkIndex}.`);
+    }
+    expectedChunkIndex++;
+  }
+  let transferState = FileTransferTrackingManager.getTransfer(fileName);
+  if (!transferState) {
+    transferState = await this.initializeTransfer({
+      transferId,
+      senderID,
+      recipientId,
+      fileName,
+      filePath,
+      path: filePath,
+      fileSize,
+      totalChunks,
+      chunkSize: chunks[0].chunkSize,
+      metadata
+    }, onError);
+  }
+  const expectedTideStart = transferState.highestContiguousChunk + 1;
+  if (firstChunkIndex !== expectedTideStart) {
+    throw new Error(`[${fileName}] Tide ordering violation. Expected Tide to begin at chunk ${expectedTideStart}, received ${firstChunkIndex}.`);
+  }
+  let tideBytes = 0;
+  for (const chunk of chunks) {
+    await _assertClassBrand(_FileTransferReceiverManager_brand, this, _writeChunk).call(this, transferState, {
+      fileName,
+      fileChunk: chunk.fileChunk,
+      chunkIndex: chunk.chunkIndex
+    });
+    tideBytes += chunk.chunkSize;
+  }
+  const missingChunks = [];
+  for (let index = firstChunkIndex; index <= lastChunkIndex; index++) {
+    if (!transferState.receivedChunks.has(index)) {
+      missingChunks.push(index);
+    }
+  }
+  return {
+    transferId,
+    firstChunkIndex,
+    lastChunkIndex,
+    highestContiguousChunk: transferState.highestContiguousChunk,
+    tideChunkCount: chunks.length,
+    tideBytes,
+    completedChunks: transferState.highestContiguousChunk + 1,
+    totalChunks: transferState.totalChunks,
+    missingChunks
+  };
+}
 module.exports = {
   FileTransferReceiverManager
 };