@trap_stevo/filetide 0.0.85 → 0.0.86

package/dist/cjs/HUDManagers/EndpointManager.js

@@ -0,0 +1,157 @@
+"use strict";
+
+const crypto = require("crypto");
+const os = require("os");
+class EndpointManager {
+  constructor(options = {}) {
+    this.baseUrl = this.cleanBaseUrl(options.baseUrl || process.env.FILETIDE_BACKEND_URL);
+    this.licenseKey = options.licenseKey || process.env.FILETIDE_LICENSE_KEY;
+    this.endpointId = options.endpointId || process.env.FILETIDE_ENDPOINT_ID || os.hostname();
+    this.endpointSecret = options.endpointSecret || process.env.FILETIDE_ENDPOINT_SECRET;
+    this.routesPath = options.routesPath || process.env.FILETIDE_ROUTES_PATH || '/api/filetide/routes';
+    this.timeoutMs = Number(options.timeoutMs || 15000);
+    this.routes = {
+      health: '/status',
+      registerEndpoint: '/api/endpoints/register',
+      heartbeat: '/api/endpoints/heartbeat',
+      resolveTransferPolicy: '/api/transfers/policy',
+      recordTransfer: '/api/transfers/usage',
+      quoteMonthToDate: '/api/billing/quote',
+      finalizeInvoice: '/api/billing/finalize'
+    };
+    if (!this.baseUrl) {
+      throw new Error('Missing FILETIDE_BACKEND_URL');
+    }
+    if (!this.licenseKey) {
+      throw new Error('Missing FILETIDE_LICENSE_KEY');
+    }
+  }
+  cleanBaseUrl(url) {
+    if (!url) return '';
+    return String(url).replace(/\/+$/, '');
+  }
+  buildUrl(path) {
+    if (!path.startsWith('/')) path = `/${path}`;
+    return `${this.baseUrl}${path}`;
+  }
+  makeAuthHeaders(body = '') {
+    const timestamp = new Date().toISOString();
+    const signature = this.endpointSecret ? crypto.createHmac('sha256', this.endpointSecret).update(`${timestamp}.${body}`).digest('hex') : '';
+    return {
+      'content-type': 'application/json',
+      'x-filetide-license-key': this.licenseKey,
+      'x-filetide-endpoint-id': this.endpointId,
+      'x-filetide-timestamp': timestamp,
+      ...(signature ? {
+        'x-filetide-signature': signature
+      } : {})
+    };
+  }
+  async request(method, path, payload = undefined) {
+    const body = payload === undefined ? '' : JSON.stringify(payload);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await fetch(this.buildUrl(path), {
+        method,
+        headers: this.makeAuthHeaders(body),
+        body: method === 'GET' ? undefined : body,
+        signal: controller.signal
+      });
+      const text = await response.text();
+      let data = null;
+      try {
+        data = text ? JSON.parse(text) : null;
+      } catch {
+        data = text;
+      }
+      if (!response.ok) {
+        const error = new Error(`FileTide backend request failed: ${method} ${path} ${response.status}`);
+        error.status = response.status;
+        error.data = data;
+        throw error;
+      }
+      return data;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async discoverRoutes() {
+    try {
+      const data = await this.request('GET', this.routesPath);
+      if (data && typeof data === 'object') {
+        const discoveredRoutes = data.routes || data;
+        this.routes = {
+          ...this.routes,
+          ...discoveredRoutes
+        };
+      }
+      return this.routes;
+    } catch (error) {
+      if (error.status === 404) {
+        return this.routes;
+      }
+      throw error;
+    }
+  }
+  async health() {
+    return this.request('GET', this.routes.health);
+  }
+  async registerEndpoint(extra = {}) {
+    return this.request('POST', this.routes.registerEndpoint, {
+      licenseKey: this.licenseKey,
+      endpointId: this.endpointId,
+      hostname: os.hostname(),
+      platform: os.platform(),
+      arch: os.arch(),
+      uptimeSeconds: os.uptime(),
+      networkInterfaces: os.networkInterfaces(),
+      ...extra
+    });
+  }
+  async heartbeat(extra = {}) {
+    return this.request('POST', this.routes.heartbeat, {
+      licenseKey: this.licenseKey,
+      endpointId: this.endpointId,
+      hostname: os.hostname(),
+      uptimeSeconds: os.uptime(),
+      memory: {
+        total: os.totalmem(),
+        free: os.freemem()
+      },
+      loadAverage: os.loadavg(),
+      timestamp: new Date().toISOString(),
+      ...extra
+    });
+  }
+  async resolveTransferPolicy(input = {}) {
+    return this.request('POST', this.routes.resolveTransferPolicy, {
+      licenseKey: this.licenseKey,
+      endpointId: this.endpointId,
+      ...input
+    });
+  }
+  async recordTransfer(input = {}) {
+    return this.request('POST', this.routes.recordTransfer, {
+      licenseKey: this.licenseKey,
+      endpointId: this.endpointId,
+      ...input
+    });
+  }
+  async quoteMonthToDate(input = {}) {
+    return this.request('POST', this.routes.quoteMonthToDate, {
+      licenseKey: this.licenseKey,
+      endpointId: this.endpointId,
+      ...input
+    });
+  }
+  async finalizeInvoice(input = {}) {
+    return this.request('POST', this.routes.finalizeInvoice, {
+      licenseKey: this.licenseKey,
+      endpointId: this.endpointId,
+      ...input
+    });
+  }
+}
+;
+module.exports = EndpointManager;

package/dist/cjs/HUDManagers/{FileNetClientManager.js → FileTideAnchorClientManager.js}

@@ -1,7 +1,7 @@
 "use strict";
 
 const currentOnlineClients = new Map();
-class FileNetClientManager {
+class FileTideAnchorClientManager {
   static addOnlineClient(clientID, pClientID, tideID, id, details = {}) {
     if (currentOnlineClients.get(pClientID)) {
       currentOnlineClients.delete(pClientID);
@@ -48,6 +48,7 @@ class FileNetClientManager {
     return currentOnlineClients;
   }
 }
+;
 module.exports = {
-  FileNetClientManager
+  FileTideAnchorClientManager
 };

package/dist/cjs/HUDManagers/{FileNetUtilityManager.js → FileTideAnchorUtilityManager.js}

@@ -3,7 +3,7 @@
 const {
   HUDUtilityManager
 } = require("@trap_stevo/legendarybuilderpronodejs-utilities");
-class FileNetUtilityManager {
+class FileTideAnchorUtilityManager {
   static convertSeconds(seconds) {
     if (seconds === 0) return "0 s";
     const units = [{
@@ -67,5 +67,5 @@ class FileNetUtilityManager {
   }
 }
 module.exports = {
-  FileNetUtilityManager
+  FileTideAnchorUtilityManager
 };

package/dist/cjs/HUDManagers/FileTideDebugUtilityManager.js

@@ -8,6 +8,7 @@ const significantMessageColors = ["#00C897", "#00E0FF"];
 const noticeMessageColors = ["#4A90E2", "#A3D8F4"];
 const infoAccentMessageColors = ["#6B768F", "#8D99AB"];
 const errorMessageColors = ["#F94144", "#F3722C"];
+const debugMessageColors = ["#8B5CF6", "#C084FC"];
 const infoMessageColors = ["#028090", "#56cfe1"];
 const logHandler = {
   "significant": function (includeDate = false, ...message) {
@@ -25,6 +26,10 @@ const logHandler = {
   "info": function (includeDate = false, ...message) {
     const log = includeDate ? `[${new Date().toLocaleString()}] ~ ` : "";
     outputGradient(log + message.join(" "), infoMessageColors);
+  },
+  "debug": function (includeDate = false, ...message) {
+    const log = includeDate ? `[${new Date().toLocaleString()}] ~ ` : "";
+    outputGradient(log + message.join(" "), debugMessageColors);
   }
 };
 function gradientText(text, colors, options = {
@@ -107,6 +112,7 @@ module.exports = {
   significantMessageColors,
   noticeMessageColors,
   errorMessageColors,
+  debugMessageColors,
   infoAccentMessageColors,
   infoMessageColors
 };

package/dist/cjs/HUDManagers/FileTideNetworkTrafficManager.js

@@ -0,0 +1,419 @@
+"use strict";
+
+var EventEmitter = require('events').EventEmitter;
+var EVENTS = Object.freeze({
+  NETWORK_AVAILABLE: 'network:available',
+  NETWORK_CONGESTED: 'network:congested',
+  NETWORK_UNSTABLE: 'network:unstable',
+  TRANSFER_PAUSE: 'transfer:pause',
+  TRANSFER_RESUME: 'transfer:resume',
+  CHUNK_SEND: 'chunk:send',
+  CHUNK_DELAY: 'chunk:delay',
+  CHUNK_RESIZE: 'chunk:resize',
+  BANDWIDTH_UPDATED: 'bandwidth:updated'
+});
+var STATES = Object.freeze({
+  UNKNOWN: 'unknown',
+  AVAILABLE: 'available',
+  CONGESTED: 'congested',
+  UNSTABLE: 'unstable',
+  OFFLINE: 'offline'
+});
+var DEFAULTS = Object.freeze({
+  defaultBandwidthBps: 1024 * 1024,
+  minimumBandwidthBps: 32 * 1024,
+  maximumBandwidthBps: 1024 * 1024 * 1024,
+  targetUtilization: 0.9,
+  congestedUtilizationFactor: 0.65,
+  targetChunkDurationMs: 250,
+  minChunkSize: 16 * 1024,
+  maxChunkSize: 1024 * 1024,
+  burstSeconds: 0.25,
+  congestedLatencyMs: 250,
+  unstableLatencyMs: 1000,
+  congestedFailureRate: 0.1,
+  unstableFailureRate: 0.3,
+  sampleWindowSize: 20,
+  smoothingFactor: 0.25,
+  throughputProbeIntervalMs: 2000,
+  throughputProbeGrowthFactor: 1.10,
+  healthyThroughputRatio: 0.90,
+  degradedThroughputRatio: 0.65
+});
+function clamp(value, minimum, maximum) {
+  return Math.min(Math.max(value, minimum), maximum);
+}
+function assertPositiveNumber(value, name) {
+  if (typeof value !== 'number' || !isFinite(value) || value <= 0) {
+    throw new TypeError(name + " expects a positive number");
+  }
+}
+function mergeOptions(options) {
+  var merged = {};
+  var key;
+  for (key in DEFAULTS) {
+    if (Object.prototype.hasOwnProperty.call(DEFAULTS, key)) {
+      merged[key] = DEFAULTS[key];
+    }
+  }
+  options = options || {};
+  for (key in options) {
+    if (key !== 'clock' && Object.prototype.hasOwnProperty.call(options, key)) {
+      merged[key] = options[key];
+    }
+  }
+  return merged;
+}
+function FileTideNetworkTrafficManager(options) {
+  EventEmitter.call(this);
+  options = options || {};
+  this._config = mergeOptions(options);
+  this._clock = typeof options.clock === 'function' ? options.clock : Date.now;
+  this._state = STATES.UNKNOWN;
+  this._paused = false;
+  this._manualPause = false;
+  this._autoPaused = false;
+  this._pauseReason = null;
+  this._bandwidthBps = null;
+  this._deliveredThroughputBps = null;
+  this._latencyMs = null;
+  this._samples = [];
+  this._lastThroughputProbeAt = 0;
+  this._tokens = this._getBucketCapacity();
+  this._lastRefillAt = this._clock();
+  this._validateConfiguration();
+}
+FileTideNetworkTrafficManager.prototype = Object.create(EventEmitter.prototype);
+FileTideNetworkTrafficManager.prototype.constructor = FileTideNetworkTrafficManager;
+FileTideNetworkTrafficManager.prototype._validateConfiguration = function () {
+  assertPositiveNumber(this._config.defaultBandwidthBps, "defaultBandwidthBps");
+  assertPositiveNumber(this._config.minimumBandwidthBps, "minimumBandwidthBps");
+  assertPositiveNumber(this._config.targetChunkDurationMs, "targetChunkDurationMs");
+  assertPositiveNumber(this._config.minChunkSize, 'minChunkSize');
+  assertPositiveNumber(this._config.maxChunkSize, 'maxChunkSize');
+  assertPositiveNumber(this._config.burstSeconds, 'burstSeconds');
+  assertPositiveNumber(this._config.sampleWindowSize, 'sampleWindowSize');
+  if (this._config.targetUtilization <= 0 || this._config.targetUtilization > 1) {
+    throw new RangeError("targetUtilization expects greater than 0 and at most 1");
+  }
+  if (this._config.congestedUtilizationFactor <= 0 || this._config.congestedUtilizationFactor > 1) {
+    throw new RangeError("congestedUtilizationFactor expects greater than 0 and at most 1");
+  }
+  if (this._config.smoothingFactor <= 0 || this._config.smoothingFactor > 1) {
+    throw new RangeError("smoothingFactor expects greater than 0 and at most 1");
+  }
+  if (this._config.minChunkSize > this._config.maxChunkSize) {
+    throw new RangeError("minChunkSize cannot exceed maxChunkSize");
+  }
+  assertPositiveNumber(this._config.maximumBandwidthBps, "maximumBandwidthBps");
+  assertPositiveNumber(this._config.throughputProbeIntervalMs, "throughputProbeIntervalMs");
+  if (this._config.throughputProbeGrowthFactor <= 1) {
+    throw new RangeError("throughputProbeGrowthFactor expects greater than 1");
+  }
+  if (this._config.healthyThroughputRatio <= 0 || this._config.healthyThroughputRatio > 1) {
+    throw new RangeError("healthyThroughputRatio expects greater than 0 and at most 1");
+  }
+  if (this._config.degradedThroughputRatio <= 0 || this._config.degradedThroughputRatio >= this._config.healthyThroughputRatio) {
+    throw new RangeError("degradedThroughputRatio expects greater than 0 and less than healthyThroughputRatio");
+  }
+};
+FileTideNetworkTrafficManager.prototype._smooth = function (current, sample) {
+  if (current === null) {
+    return sample;
+  }
+  return this._config.smoothingFactor * sample + (1 - this._config.smoothingFactor) * current;
+};
+FileTideNetworkTrafficManager.prototype._getFailureRate = function () {
+  if (this._samples.length === 0) {
+    return 0;
+  }
+  var failures = this._samples.reduce(function (total, sample) {
+    return total + (sample.success ? 0 : 1);
+  }, 0);
+  return failures / this._samples.length;
+};
+FileTideNetworkTrafficManager.prototype._getRetryRate = function () {
+  if (this._samples.length === 0) {
+    return 0;
+  }
+  var retries = this._samples.reduce(function (total, sample) {
+    return total + (sample.retried ? 1 : 0);
+  }, 0);
+  return retries / this._samples.length;
+};
+FileTideNetworkTrafficManager.prototype._evaluateState = function (online) {
+  var failureRate = this._getFailureRate();
+  var retryRate = this._getRetryRate();
+  if (online === false) {
+    return STATES.OFFLINE;
+  }
+  if (this._latencyMs !== null && this._latencyMs >= this._config.unstableLatencyMs) {
+    return STATES.UNSTABLE;
+  }
+  if (failureRate >= this._config.unstableFailureRate) {
+    return STATES.UNSTABLE;
+  }
+  if (this._latencyMs !== null && this._latencyMs >= this._config.congestedLatencyMs) {
+    return STATES.CONGESTED;
+  }
+  if (failureRate >= this._config.congestedFailureRate || retryRate >= this._config.congestedFailureRate) {
+    return STATES.CONGESTED;
+  }
+  return STATES.AVAILABLE;
+};
+FileTideNetworkTrafficManager.prototype._setState = function (nextState) {
+  if (nextState === this._state) {
+    return;
+  }
+  var previousState = this._state;
+  this._state = nextState;
+  var eventPayload = {
+    state: nextState,
+    previousState: previousState,
+    status: this.getStatus()
+  };
+  if (nextState === STATES.AVAILABLE) {
+    this.emit(EVENTS.NETWORK_AVAILABLE, eventPayload);
+    if (this._autoPaused && !this._manualPause) {
+      this.resume('network-recovered', true);
+    }
+    return;
+  }
+  if (nextState === STATES.CONGESTED) {
+    this.emit(EVENTS.NETWORK_CONGESTED, eventPayload);
+    return;
+  }
+  this.emit(EVENTS.NETWORK_UNSTABLE, eventPayload);
+  this.pause(nextState === STATES.OFFLINE ? 'network-offline' : 'network-unstable', true);
+};
+FileTideNetworkTrafficManager.prototype.updateNetworkSample = function (sample) {
+  sample = sample || {};
+  if (sample.bandwidthBps !== undefined) {
+    assertPositiveNumber(sample.bandwidthBps, 'bandwidthBps');
+    this._refillTokens();
+    var previousCapacity = this._getBucketCapacity();
+    var fillRatio = clamp(this._tokens / previousCapacity, 0, 1);
+    this._bandwidthBps = this._smooth(this._bandwidthBps, sample.bandwidthBps);
+    this._tokens = fillRatio * this._getBucketCapacity();
+    this.emit(EVENTS.BANDWIDTH_UPDATED, {
+      bandwidthBps: this._bandwidthBps,
+      status: this.getStatus()
+    });
+  }
+  if (sample.latencyMs !== undefined) {
+    if (typeof sample.latencyMs !== 'number' || !isFinite(sample.latencyMs) || sample.latencyMs < 0) {
+      throw new TypeError("latencyMs expects a non-negative number");
+    }
+    this._latencyMs = this._smooth(this._latencyMs, sample.latencyMs);
+  }
+  if (sample.success !== undefined || sample.retried !== undefined) {
+    this._samples.push({
+      success: sample.success !== false,
+      retried: sample.retried === true,
+      timestamp: this._clock()
+    });
+    if (this._samples.length > this._config.sampleWindowSize) {
+      this._samples.shift();
+    }
+  }
+  this._setState(this._evaluateState(sample.online));
+  return this.getStatus();
+};
+FileTideNetworkTrafficManager.prototype.recordTransfer = function (result) {
+  result = result || {};
+  assertPositiveNumber(result.bytes, 'bytes');
+  assertPositiveNumber(result.durationMs, 'durationMs');
+  return this.updateNetworkSample({
+    bandwidthBps: result.bytes / (result.durationMs / 1000),
+    latencyMs: result.latencyMs,
+    online: result.online,
+    success: result.success,
+    retried: result.retried
+  });
+};
+FileTideNetworkTrafficManager.prototype.recordDeliveredThroughput = function (throughputBps) {
+  assertPositiveNumber(throughputBps, "throughputBps");
+  var now = this._clock();
+  this._deliveredThroughputBps = this._smooth(this._deliveredThroughputBps, throughputBps);
+  this._setState(this._evaluateState(true));
+  var currentBandwidth = this._bandwidthBps || this._config.defaultBandwidthBps;
+  var currentSendRate = this._getSendRate();
+  var throughputRatio = currentSendRate > 0 ? this._deliveredThroughputBps / currentSendRate : 0;
+  if (now - this._lastThroughputProbeAt < this._config.throughputProbeIntervalMs) {
+    return this.getStatus();
+  }
+  this._lastThroughputProbeAt = now;
+  var nextBandwidth = currentBandwidth;
+  if (this._state === STATES.AVAILABLE && throughputRatio >= this._config.healthyThroughputRatio) {
+    nextBandwidth = Math.min(currentBandwidth * this._config.throughputProbeGrowthFactor, this._config.maximumBandwidthBps);
+  } else if (throughputRatio < this._config.degradedThroughputRatio) {
+    var observedCapacity = this._deliveredThroughputBps / this._config.targetUtilization;
+    nextBandwidth = this._smooth(currentBandwidth, observedCapacity);
+    nextBandwidth = Math.max(nextBandwidth, this._config.minimumBandwidthBps);
+  }
+  nextBandwidth = Math.min(nextBandwidth, this._config.maximumBandwidthBps);
+  if (nextBandwidth !== currentBandwidth) {
+    this._refillTokens();
+    var previousCapacity = this._getBucketCapacity();
+    var fillRatio = clamp(this._tokens / previousCapacity, 0, 1);
+    this._bandwidthBps = nextBandwidth;
+    this._tokens = fillRatio * this._getBucketCapacity();
+    this.emit(EVENTS.BANDWIDTH_UPDATED, {
+      bandwidthBps: this._bandwidthBps,
+      deliveredThroughputBps: this._deliveredThroughputBps,
+      throughputRatio,
+      status: this.getStatus()
+    });
+  }
+  return this.getStatus();
+};
+FileTideNetworkTrafficManager.prototype.waitForChunkAdmission = function (requestedBytes) {
+  var self = this;
+  assertPositiveNumber(requestedBytes, "requestedBytes");
+  return new Promise(function (resolve) {
+    function evaluate() {
+      var decision = self.getChunkDecision(requestedBytes);
+      if (decision.action === "send") {
+        resolve(decision);
+        return;
+      }
+      if (decision.action === "pause") {
+        self.once(EVENTS.TRANSFER_RESUME, evaluate);
+        return;
+      }
+      setTimeout(evaluate, Math.max(decision.delayMs || 1, 1));
+    }
+    evaluate();
+  });
+};
+FileTideNetworkTrafficManager.prototype.pause = function (reason, automatic) {
+  if (automatic !== true) {
+    this._manualPause = true;
+  } else {
+    this._autoPaused = true;
+  }
+  this._pauseReason = reason || 'requested';
+  if (this._paused) {
+    return this.getStatus();
+  }
+  this._paused = true;
+  this.emit(EVENTS.TRANSFER_PAUSE, {
+    reason: this._pauseReason,
+    automatic: automatic === true,
+    status: this.getStatus()
+  });
+  return this.getStatus();
+};
+FileTideNetworkTrafficManager.prototype.resume = function (reason, automatic) {
+  if (automatic === true && this._manualPause) {
+    return this.getStatus();
+  }
+  if (automatic !== true) {
+    this._manualPause = false;
+  }
+  this._autoPaused = false;
+  this._pauseReason = null;
+  if (!this._paused) {
+    return this.getStatus();
+  }
+  this._paused = false;
+  this._lastRefillAt = this._clock();
+  this.emit(EVENTS.TRANSFER_RESUME, {
+    reason: reason || 'requested',
+    automatic: automatic === true,
+    status: this.getStatus()
+  });
+  return this.getStatus();
+};
+FileTideNetworkTrafficManager.prototype._getSendRate = function () {
+  var bandwidth = this._bandwidthBps || this._config.defaultBandwidthBps;
+  var rate = Math.max(bandwidth * this._config.targetUtilization, this._config.minimumBandwidthBps);
+  if (this._state === STATES.CONGESTED) {
+    rate *= this._config.congestedUtilizationFactor;
+  }
+  return rate;
+};
+FileTideNetworkTrafficManager.prototype._getBucketCapacity = function () {
+  var bandwidth = this._bandwidthBps || this._config.defaultBandwidthBps;
+  return Math.max(bandwidth * this._config.burstSeconds, this._config.maxChunkSize);
+};
+FileTideNetworkTrafficManager.prototype._refillTokens = function () {
+  var now = this._clock();
+  var elapsedMs = Math.max(now - this._lastRefillAt, 0);
+  var addedTokens = this._getSendRate() * (elapsedMs / 1000);
+  this._tokens = Math.min(this._tokens + addedTokens, this._getBucketCapacity());
+  this._lastRefillAt = now;
+};
+FileTideNetworkTrafficManager.prototype.getRecommendedChunkSize = function () {
+  var targetSize = this._getSendRate() * (this._config.targetChunkDurationMs / 1000);
+  return Math.round(clamp(targetSize, this._config.minChunkSize, this._config.maxChunkSize));
+};
+FileTideNetworkTrafficManager.prototype.getChunkDecision = function (requestedBytes) {
+  assertPositiveNumber(requestedBytes, 'requestedBytes');
+  if (this._paused) {
+    return {
+      action: 'pause',
+      allowed: false,
+      reason: this._pauseReason,
+      delayMs: null,
+      chunkSize: 0
+    };
+  }
+  this._refillTokens();
+  var recommendedSize = this.getRecommendedChunkSize();
+  var chunkSize = Math.min(requestedBytes, recommendedSize);
+  if (chunkSize !== requestedBytes) {
+    this.emit(EVENTS.CHUNK_RESIZE, {
+      requestedBytes: requestedBytes,
+      chunkSize: chunkSize,
+      status: this.getStatus()
+    });
+  }
+  if (this._tokens >= chunkSize) {
+    this._tokens -= chunkSize;
+    var sendDecision = {
+      action: 'send',
+      allowed: true,
+      reason: 'capacity-available',
+      delayMs: 0,
+      chunkSize: chunkSize
+    };
+    this.emit(EVENTS.CHUNK_SEND, sendDecision);
+    return sendDecision;
+  }
+  var delayMs = Math.ceil((chunkSize - this._tokens) / this._getSendRate() * 1000);
+  var delayDecision = {
+    action: 'delay',
+    allowed: false,
+    reason: 'bandwidth-throttled',
+    delayMs: Math.max(delayMs, 1),
+    chunkSize: chunkSize
+  };
+  this.emit(EVENTS.CHUNK_DELAY, delayDecision);
+  return delayDecision;
+};
+FileTideNetworkTrafficManager.prototype.canSendChunk = function (requestedBytes) {
+  return this.getChunkDecision(requestedBytes).allowed;
+};
+FileTideNetworkTrafficManager.prototype.getStatus = function () {
+  var sendRateBps = this._getSendRate();
+  return {
+    state: this._state,
+    paused: this._paused,
+    pauseReason: this._pauseReason,
+    bandwidthBps: this._bandwidthBps,
+    deliveredThroughputBps: this._deliveredThroughputBps,
+    latencyMs: this._latencyMs,
+    failureRate: this._getFailureRate(),
+    retryRate: this._getRetryRate(),
+    recommendedChunkSize: this.getRecommendedChunkSize(),
+    sendRateBps,
+    throughputRatio: this._deliveredThroughputBps !== null && sendRateBps > 0 ? this._deliveredThroughputBps / sendRateBps : null,
+    sampleCount: this._samples.length
+  };
+};
+var singleton = new FileTideNetworkTrafficManager();
+module.exports = singleton;
+module.exports.FileTideNetworkTrafficManager = FileTideNetworkTrafficManager;
+module.exports.EVENTS = EVENTS;
+module.exports.STATES = STATES;