agentgui 1.0.931 → 1.0.933

package/static/js/ui-components.js

@@ -1,88 +0,0 @@
-class UIComponents {
-  static createModal(config = {}) {
-    const { title = 'Dialog', content = '', buttons = [], onClose = null, size = 'medium' } = config;
-    const modal = document.createElement('div');
-    modal.className = 'modal-overlay';
-    modal.dataset.modal = 'true';
-    const sizeClasses = { 'small': 'max-w-sm', 'medium': 'max-w-md', 'large': 'max-w-2xl' };
-    modal.innerHTML = `<div class="modal-content card ${sizeClasses[size] || sizeClasses['medium']}"><div class="card-header flex justify-between items-center"><h2 class="text-xl font-bold">${UIComponents.escapeHtml(title)}</h2><button class="btn btn-ghost btn-sm modal-close">&times;</button></div><div class="card-body modal-body">${typeof content === 'string' ? UIComponents.escapeHtml(content) : ''}</div><div class="card-footer flex gap-2 justify-end">${buttons.map(btn => `<button class="btn btn-${btn.variant || 'secondary'}" data-action="${btn.action || 'close'}">${UIComponents.escapeHtml(btn.label)}</button>`).join('')}</div></div>`;
-    const closeBtn = modal.querySelector('.modal-close');
-    closeBtn.addEventListener('click', () => { modal.remove(); if (onClose) onClose(); });
-    modal.querySelectorAll('[data-action]').forEach(btn => {
-      btn.addEventListener('click', (e) => { const action = e.target.dataset.action; if (action === 'close') { modal.remove(); if (onClose) onClose(); } });
-    });
-    modal.addEventListener('click', (e) => { if (e.target === modal) { modal.remove(); if (onClose) onClose(); } });
-    return modal;
-  }
-
-  static createTabs(config = {}) {
-    const { tabs = [], activeTab = 0, onChange = null } = config;
-    const container = document.createElement('div');
-    container.className = 'tabs';
-    const tabButtons = document.createElement('div');
-    tabButtons.className = 'tab-buttons flex border-b';
-    const tabContent = document.createElement('div');
-    tabContent.className = 'tab-content mt-4';
-    tabs.forEach((tab, index) => {
-      const btn = document.createElement('button');
-      btn.className = `tab tab-underline tab-button ${index === activeTab ? 'tab-active' : ''}`;
-      btn.textContent = tab.label;
-      btn.dataset.tabIndex = index;
-      btn.addEventListener('click', () => {
-        tabButtons.querySelectorAll('.tab-button').forEach((b, i) => b.classList.toggle('tab-active', i === index));
-        tabContent.querySelectorAll('.tab-pane').forEach((pane, i) => { pane.style.display = i === index ? 'block' : 'none'; });
-        if (onChange) onChange(index);
-      });
-      tabButtons.appendChild(btn);
-      const pane = document.createElement('div');
-      pane.className = 'tab-pane';
-      pane.style.display = index === activeTab ? 'block' : 'none';
-      pane.innerHTML = typeof tab.content === 'string' ? tab.content : '';
-      tabContent.appendChild(pane);
-    });
-    container.appendChild(tabButtons);
-    container.appendChild(tabContent);
-    return container;
-  }
-
-  static createAlert(config = {}) {
-    const { message = '', type = 'info', duration = 5000, dismissible = true } = config;
-    const alert = document.createElement('div');
-    const typeClasses = { 'info': 'alert-info', 'success': 'alert-success', 'warning': 'alert-warning', 'error': 'alert-error' };
-    alert.className = `alert ${typeClasses[type] || typeClasses['info']}`;
-    alert.innerHTML = `<div class="flex justify-between items-center"><span>${UIComponents.escapeHtml(message)}</span>${dismissible ? '<button class="text-current hover:opacity-75">&times;</button>' : ''}</div>`;
-    if (dismissible) alert.querySelector('button').addEventListener('click', () => alert.remove());
-    if (duration > 0) setTimeout(() => alert.remove(), duration);
-    return alert;
-  }
-
-  static createSpinner(config = {}) {
-    const { size = 'medium', text = 'Loading...' } = config;
-    const sizeClasses = { 'small': 'spinner-xs', 'medium': 'spinner-sm', 'large': 'spinner-md' };
-    const container = document.createElement('div');
-    container.className = 'flex items-center gap-3 justify-center p-4';
-    container.innerHTML = `<div class="spinner-simple spinner-primary ${sizeClasses[size] || sizeClasses['medium']}"></div><span class="text-base-content">${UIComponents.escapeHtml(text)}</span>`;
-    return container;
-  }
-
-  static createProgressBar(config = {}) {
-    const { percentage = 0, label = '', showLabel = true } = config;
-    const container = document.createElement('div');
-    container.className = 'progress-container';
-    let html = '';
-    if (label && showLabel) html += `<div class="flex justify-between mb-2 text-sm"><span>${UIComponents.escapeHtml(label)}</span><span>${Math.round(percentage)}%</span></div>`;
-    html += `<progress class="progress progress-primary progress-xs w-full" value="${Math.min(100, Math.max(0, percentage))}" max="100"></progress>`;
-    container.innerHTML = html;
-    return container;
-  }
-
-  static createCollapsible(config = {}) {
-    const { title = 'Details', content = '', isOpen = false } = config;
-    const container = document.createElement('div');
-    container.className = 'collapsible';
-    container.innerHTML = `<details ${isOpen ? 'open' : ''}><summary class="cursor-pointer font-semibold hover:bg-base-200 px-2 py-1 rounded transition-colors">${UIComponents.escapeHtml(title)}</summary><div class="content mt-2 ml-4">${typeof content === 'string' ? content : ''}</div></details>`;
-    return container;
-  }
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = UIComponents;

package/static/js/websocket-manager.js

@@ -1,107 +0,0 @@
-Object.assign(WebSocketManager.prototype, {
-  sendMessage(data) {
-    if (!data || typeof data !== 'object') throw new Error('Invalid message data');
-    if (data.type === 'subscribe') {
-      const key = data.sessionId ? 'session:' + data.sessionId : 'conv:' + data.conversationId;
-      this.activeSubscriptions.add(key);
-    } else if (data.type === 'unsubscribe') {
-      const key = data.sessionId ? 'session:' + data.sessionId : 'conv:' + data.conversationId;
-      this.activeSubscriptions.delete(key);
-    }
-    if (!this.isConnected) { this.bufferMessage(data); return false; }
-    try {
-      this.ws.send(window._codec ? window._codec.encode(data) : msgpackr.pack(data));
-      this.stats.totalMessagesSent++;
-      return true;
-    } catch (error) { this.stats.totalErrors++; this.bufferMessage(data); return false; }
-  },
-
-  bufferMessage(data) {
-    if (this.messageBuffer.length >= this.config.maxBufferedMessages) this.messageBuffer.shift();
-    this.messageBuffer.push(data);
-    this.emit('message_buffered', { bufferLength: this.messageBuffer.length });
-  },
-
-  flushMessageBuffer() {
-    if (this.messageBuffer.length === 0) return;
-    const messages = [...this.messageBuffer];
-    this.messageBuffer = [];
-    for (const message of messages) {
-      try {
-        this.ws.send(window._codec ? window._codec.encode(message) : msgpackr.pack(message));
-        this.stats.totalMessagesSent++;
-      } catch (error) { this.bufferMessage(message); }
-    }
-    this.emit('buffer_flushed', { count: messages.length });
-  },
-
-  subscribeToSession(sessionId) { return this.sendMessage({ type: 'subscribe', sessionId, timestamp: Date.now() }); },
-  subscribeToConversation(conversationId) { return this.sendMessage({ type: 'subscribe', conversationId, timestamp: Date.now() }); },
-
-  resubscribeAll() {
-    for (const key of this.activeSubscriptions) {
-      const colonIdx = key.indexOf(':');
-      const type = key.substring(0, colonIdx);
-      const id = key.substring(colonIdx + 1);
-      const msg = { type: 'subscribe', timestamp: Date.now() };
-      if (type === 'session') msg.sessionId = id; else msg.conversationId = id;
-      try { this.ws.send(window._codec ? window._codec.encode(msg) : msgpackr.pack(msg)); this.stats.totalMessagesSent++; } catch (_) {}
-    }
-  },
-
-  unsubscribeFromSession(sessionId) { return this.sendMessage({ type: 'unsubscribe', sessionId, timestamp: Date.now() }); },
-
-  requestSessionHistory(sessionId, limit = 1000, offset = 0) {
-    return new Promise((resolve, reject) => {
-      const requestId = 'history-' + Date.now() + '-' + Math.random();
-      const timeout = setTimeout(() => { this.requestMap.delete(requestId); this.stats.totalTimeouts++; reject(new Error('History request timeout')); }, this.config.messageTimeout);
-      this.requestMap.set(requestId, { type: 'history', resolve: (d) => { clearTimeout(timeout); resolve(d); }, reject });
-      this.sendMessage({ type: 'request_history', requestId, sessionId, limit, offset, timestamp: Date.now() });
-    });
-  },
-
-  getLastSeq(sessionId) { return this.lastSeqBySession[sessionId] || -1; },
-
-  setConnectionState(state) {
-    this.connectionState = state;
-    this.emit('state_change', { state, timestamp: Date.now() });
-  },
-
-  disconnect() {
-    this.isManuallyDisconnected = true;
-    this.reconnectCount = 0;
-    this.stopHeartbeat();
-    if (this.reconnectTimer) { clearTimeout(this.reconnectTimer); this.reconnectTimer = null; }
-    if (this.ws) this.ws.close();
-    this.messageBuffer = [];
-    this.requestMap.clear();
-    this.setConnectionState('disconnected');
-  },
-
-  getStatus() {
-    return { isConnected: this.isConnected, isConnecting: this.isConnecting, connectionState: this.connectionState, reconnectCount: this.reconnectCount, bufferLength: this.messageBuffer.length, latency: { ...this.latency, samples: undefined }, stats: { ...this.stats } };
-  },
-
-  on(event, callback) { if (!this.listeners[event]) this.listeners[event] = []; this.listeners[event].push(callback); },
-  off(event, callback) { if (!this.listeners[event]) return; const index = this.listeners[event].indexOf(callback); if (index > -1) this.listeners[event].splice(index, 1); },
-  emit(event, data) { if (!this.listeners[event]) return; this.listeners[event].forEach((cb) => { try { cb(data); } catch (error) {} }); },
-
-  destroy() {
-    if (typeof document !== 'undefined') document.removeEventListener('visibilitychange', this._onVisibilityChange);
-    if (typeof window !== 'undefined') window.removeEventListener('online', this._onOnline);
-    this.disconnect();
-    this.listeners = {};
-  },
-
-  subscribeToVoiceList(callback) {
-    if (!this.voiceListListeners.includes(callback)) this.voiceListListeners.push(callback);
-    if (this.cachedVoiceList !== null) callback(this.cachedVoiceList);
-  },
-
-  unsubscribeFromVoiceList(callback) {
-    const idx = this.voiceListListeners.indexOf(callback);
-    if (idx > -1) this.voiceListListeners.splice(idx, 1);
-  }
-});
-
-if (typeof module !== 'undefined' && module.exports) module.exports = WebSocketManager;

package/static/js/ws-client.js

@@ -1,87 +0,0 @@
-class WsClient {
-  constructor(wsManager) {
-    this._ws = wsManager;
-    this._pending = new Map();
-    this._installed = false;
-    this._connectPromise = null;
-    this._install();
-  }
-
-  _install() {
-    if (this._installed) return;
-    this._installed = true;
-    this._ws.on('message', (data) => {
-      if (data.r && this._pending.has(data.r)) {
-        const p = this._pending.get(data.r);
-        this._pending.delete(data.r);
-        clearTimeout(p.timer);
-        if (data.e) {
-          p.reject(Object.assign(new Error(data.e.m || 'RPC error'), { code: data.e.c }));
-        } else {
-          p.resolve(data.d);
-        }
-        return; // consumed — don't re-emit
-      }
-    });
-    this._ws.on('disconnected', () => this.cancelAll());
-  }
-
-  _ensureConnected() {
-    if (this._ws.isConnected) return Promise.resolve();
-    if (this._connectPromise) return this._connectPromise;
-    this._connectPromise = this._ws.connect().then(() => {
-      this._connectPromise = null;
-    }).catch(() => {
-      this._connectPromise = null;
-    });
-    return this._connectPromise;
-  }
-
-  _id() {
-    let id = '';
-    for (let i = 0; i < 8; i++) id += ((Math.random() * 16) | 0).toString(16);
-    return id;
-  }
-
-  request(method, params = {}, timeout = 30000) {
-    return this._ensureConnected().then(() => {
-      return new Promise((resolve, reject) => {
-        const r = this._id();
-        const timer = setTimeout(() => {
-          this._pending.delete(r);
-          reject(new Error(`RPC timeout: ${method}`));
-        }, timeout);
-        this._pending.set(r, { resolve, reject, timer });
-        this._ws.sendMessage({ r, m: method, p: params });
-      });
-    });
-  }
-
-  rpc(method, params) {
-    return this.request(method, params);
-  }
-
-  cancelAll() {
-    for (const [, p] of this._pending) {
-      clearTimeout(p.timer);
-      p.reject(new Error('Connection lost'));
-    }
-    this._pending.clear();
-  }
-
-  get pendingCount() {
-    return this._pending.size;
-  }
-}
-
-window.WsClient = WsClient;
-
-window.wsManager = new WebSocketManager();
-window.wsClient = new WsClient(window.wsManager);
-window.wsManager.connect().catch(function() {});
-
-import('./codec.js').then(codec => {
-  window._codec = codec;
-}).catch(e => {
-  console.error('[ws-client] Failed to load codec, using msgpackr fallback:', e);
-});

package/static/js/ws-core.js

@@ -1,162 +0,0 @@
-class WebSocketManager {
-  constructor(config = {}) {
-    this.config = {
-      url: config.url || this.getWebSocketURL(),
-      reconnectDelays: config.reconnectDelays || [500, 1000, 2000, 4000, 8000, 15000, 30000],
-      maxReconnectDelay: config.maxReconnectDelay || 30000,
-      heartbeatInterval: config.heartbeatInterval || 15000,
-      messageTimeout: config.messageTimeout || 60000,
-      maxBufferedMessages: config.maxBufferedMessages || 1000,
-      pongTimeout: config.pongTimeout || 5000,
-      latencyWindowSize: config.latencyWindowSize || 10,
-      ...config
-    };
-    this.ws = null;
-    this._isConnected = false;
-    this._isConnecting = false;
-    this._isManuallyDisconnected = false;
-    this._reconnectCount = 0;
-    this.isManuallyDisconnected = false;
-    this.reconnectCount = 0;
-    this.reconnectTimer = null;
-    this.messageBuffer = [];
-    this.requestMap = new Map();
-    this.heartbeatTimer = null;
-    this._connectionState = 'disconnected';
-    this.activeSubscriptions = new Set();
-    this._wsActor = typeof createWsActor === 'function' ? createWsActor() : null;
-    this.connectionEstablishedAt = 0;
-    this.cachedVoiceList = null;
-    this.voiceListListeners = [];
-    this.latency = { samples: [], current: 0, avg: 0, jitter: 0, quality: 'unknown', predicted: 0, predictedNext: 0, trend: 'stable', missedPongs: 0, pingCounter: 0 };
-    this._latencyEma = null;
-    this._trendHistory = [];
-    this._trendCount = 0;
-    this._reconnectedAt = 0;
-    this.stats = { totalConnections: 0, totalReconnects: 0, totalMessagesSent: 0, totalMessagesReceived: 0, totalErrors: 0, totalTimeouts: 0, avgLatency: 0, lastConnectedTime: null, connectionDuration: 0 };
-    this.lastSeqBySession = {};
-    this.listeners = {};
-    this._onVisibilityChange = this._handleVisibilityChange.bind(this);
-    this._onOnline = this._handleOnline.bind(this);
-    if (typeof document !== 'undefined') document.addEventListener('visibilitychange', this._onVisibilityChange);
-    if (typeof window !== 'undefined') window.addEventListener('online', this._onOnline);
-  }
-
-  get isConnected() { return this._wsActor ? this._wsActor.getSnapshot().value === 'connected' : this._isConnected; }
-  set isConnected(v) { this._isConnected = v; }
-  get isConnecting() { return this._wsActor ? this._wsActor.getSnapshot().value === 'connecting' : this._isConnecting; }
-  set isConnecting(v) { this._isConnecting = v; }
-  get connectionState() { return this._wsActor ? this._wsActor.getSnapshot().value : this._connectionState; }
-  set connectionState(v) { this._connectionState = v; }
-  get isManuallyDisconnected() { return this._wsActor ? !!this._wsActor.getSnapshot().context.manualDisconnect : this._isManuallyDisconnected; }
-  set isManuallyDisconnected(v) { this._isManuallyDisconnected = v; if (this._wsActor && v) this._wsActor.send({ type: 'MANUAL_DISCONNECT' }); }
-  get reconnectCount() { return this._wsActor ? this._wsActor.getSnapshot().context.reconnectCount : this._reconnectCount; }
-  set reconnectCount(v) { this._reconnectCount = v; }
-
-  getWebSocketURL() {
-    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-    const baseURL = window.__BASE_URL || '/gm';
-    let url = `${protocol}//${window.location.host}${baseURL}/sync`;
-    if (window.__WS_TOKEN) url += `?token=${encodeURIComponent(window.__WS_TOKEN)}`;
-    return url;
-  }
-
-  async connect() {
-    if (this.isConnected || this.isConnecting) return this.ws;
-    this.isManuallyDisconnected = false;
-    this._isConnecting = true;
-    if (this._wsActor) this._wsActor.send({ type: 'CONNECT' });
-    this.setConnectionState('connecting');
-    try {
-      this.ws = new WebSocket(this.config.url);
-      this.ws.binaryType = 'arraybuffer';
-      this.ws.onopen = () => this.onOpen();
-      this.ws.onmessage = (event) => this.onMessage(event);
-      this.ws.onerror = (error) => this.onError(error);
-      this.ws.onclose = () => this.onClose();
-      return await this.waitForConnection(this.config.messageTimeout);
-    } catch (error) {
-      this.isConnecting = false;
-      this.stats.totalErrors++;
-      this.scheduleReconnect();
-      throw error;
-    }
-  }
-
-  waitForConnection(timeout = 5000) {
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error('WebSocket connection timeout')), timeout);
-      const check = () => {
-        if (this.isConnected || this.ws?.readyState === WebSocket.OPEN) { clearTimeout(timer); resolve(this.ws); }
-        else setTimeout(check, 50);
-      };
-      check();
-    });
-  }
-
-  onOpen() {
-    this._isConnected = true;
-    this._isConnecting = false;
-    if (this._wsActor) this._wsActor.send({ type: 'OPEN' });
-    this.connectionEstablishedAt = Date.now();
-    this._reconnectedAt = this.stats.totalConnections > 0 ? Date.now() : 0;
-    this.stats.totalConnections++;
-    this.stats.lastConnectedTime = Date.now();
-    this.latency.missedPongs = 0;
-    this.setConnectionState('connected');
-    this.flushMessageBuffer();
-    this.resubscribeAll();
-    this.startHeartbeat();
-    this.emit('connected', { timestamp: Date.now() });
-  }
-
-  async onMessage(event) {
-    try {
-      const buf = event.data instanceof Blob ? await event.data.arrayBuffer() : event.data;
-      const parsed = window._codec ? window._codec.decode(buf) : msgpackr.unpack(new Uint8Array(buf));
-      const messages = Array.isArray(parsed) ? parsed : [parsed];
-      this.stats.totalMessagesReceived += messages.length;
-      for (const data of messages) {
-        if (data.type === 'pong') { this._handlePong(data); continue; }
-        if (data.type === 'voice_list') {
-          this.cachedVoiceList = data.voices || [];
-          for (const listener of this.voiceListListeners) { try { listener(this.cachedVoiceList); } catch (_) {} }
-        }
-        if (data.seq !== undefined && data.sessionId) {
-          this.lastSeqBySession[data.sessionId] = Math.max(this.lastSeqBySession[data.sessionId] || -1, data.seq);
-        }
-        this.emit('message', data);
-        if (data.type) this.emit('message:' + data.type, data);
-      }
-    } catch (error) { this.stats.totalErrors++; }
-  }
-
-  onError(error) {
-    this.stats.totalErrors++;
-    if (this._wsActor) this._wsActor.send({ type: 'ERROR' });
-    this.emit('error', { error, timestamp: Date.now() });
-  }
-
-  onClose() {
-    this._isConnected = false;
-    this._isConnecting = false;
-    if (this._wsActor) this._wsActor.send({ type: 'CLOSE' });
-    this.setConnectionState('disconnected');
-    this.stopHeartbeat();
-    if (this.stats.lastConnectedTime) this.stats.connectionDuration = Date.now() - this.stats.lastConnectedTime;
-    this.emit('disconnected', { timestamp: Date.now() });
-    if (!this.isManuallyDisconnected) this.scheduleReconnect();
-  }
-
-  scheduleReconnect() {
-    if (this.isManuallyDisconnected || this.reconnectTimer) return;
-    const delays = this.config.reconnectDelays;
-    const baseDelay = this.reconnectCount < delays.length ? delays[this.reconnectCount] : this.config.maxReconnectDelay;
-    const delay = Math.round(baseDelay + Math.random() * 0.3 * baseDelay);
-    this.reconnectCount++;
-    this.stats.totalReconnects++;
-    this.setConnectionState('reconnecting');
-    this.emit('reconnecting', { delay, attempt: this.reconnectCount, nextAttemptAt: Date.now() + delay });
-    this.reconnectTimer = setTimeout(() => { this.reconnectTimer = null; this.connect().catch(() => {}); }, delay);
-  }
-}

package/static/js/ws-latency.js

@@ -1,88 +0,0 @@
-Object.assign(WebSocketManager.prototype, {
-  startHeartbeat() {
-    this.stopHeartbeat();
-    this.heartbeatTimer = setInterval(() => { this.ping(); }, this.config.heartbeatInterval);
-  },
-
-  stopHeartbeat() {
-    if (this.heartbeatTimer) { clearInterval(this.heartbeatTimer); this.heartbeatTimer = null; }
-  },
-
-  _reportLatency() {
-    this.emit('latency', { current: this.latency.current, avg: this.latency.avg, jitter: this.latency.jitter, quality: this.latency.quality, trend: this.latency.trend });
-  },
-
-  _handleVisibilityChange() {
-    if (document.visibilityState === 'visible' && !this.isConnected && !this.isManuallyDisconnected) this.connect().catch(() => {});
-  },
-
-  _handleOnline() {
-    if (!this.isConnected && !this.isManuallyDisconnected) this.connect().catch(() => {});
-  },
-
-  ping() {
-    if (!this.isConnected) return;
-    this.latency.pingCounter++;
-    const id = this.latency.pingCounter;
-    const pongTimer = setTimeout(() => {
-      this.latency.missedPongs++;
-      this.emit('latency', { current: null, avg: this.latency.avg, jitter: this.latency.jitter, quality: 'poor', missed: true });
-      if (this.latency.missedPongs >= 3) { this.onClose(); }
-    }, this.config.pongTimeout);
-    this.requestMap.set('ping:' + id, { type: 'ping', sentAt: Date.now(), pongTimer });
-    try {
-      this.ws.send(window._codec ? window._codec.encode({ type: 'ping', id }) : msgpackr.pack({ type: 'ping', id }));
-    } catch (_) { clearTimeout(pongTimer); this.requestMap.delete('ping:' + id); }
-  },
-
-  _handlePong(data) {
-    const key = 'ping:' + data.id;
-    const pending = this.requestMap.get(key);
-    if (!pending) return;
-    clearTimeout(pending.pongTimer);
-    this.requestMap.delete(key);
-    this.latency.missedPongs = 0;
-    const rtt = Date.now() - pending.sentAt;
-    this._recordLatency(rtt);
-    this._checkDegradation();
-    this._reportLatency();
-  },
-
-  _recordLatency(rtt) {
-    const samples = this.latency.samples;
-    samples.push(rtt);
-    if (samples.length > this.config.latencyWindowSize) samples.shift();
-    this.latency.current = rtt;
-    this.latency.avg = Math.round(samples.reduce((a, b) => a + b, 0) / samples.length);
-    const jitterSamples = samples.slice(1).map((v, i) => Math.abs(v - samples[i]));
-    this.latency.jitter = jitterSamples.length ? Math.round(jitterSamples.reduce((a, b) => a + b, 0) / jitterSamples.length) : 0;
-    this.latency.quality = this._qualityTier(this.latency.avg);
-    if (this._latencyEma === null) this._latencyEma = rtt;
-    else this._latencyEma = 0.3 * rtt + 0.7 * this._latencyEma;
-    this.latency.predicted = Math.round(this._latencyEma);
-    this.stats.avgLatency = this.latency.avg;
-    this._trendHistory.push(rtt);
-    if (this._trendHistory.length > 5) this._trendHistory.shift();
-    if (this._trendHistory.length >= 3) {
-      const h = this._trendHistory;
-      const slope = (h[h.length - 1] - h[0]) / h.length;
-      this.latency.trend = slope > 5 ? 'rising' : slope < -5 ? 'falling' : 'stable';
-    }
-  },
-
-  _qualityTier(avg) {
-    if (avg < 50) return 'excellent';
-    if (avg < 150) return 'good';
-    if (avg < 300) return 'fair';
-    return 'poor';
-  },
-
-  _checkDegradation() {
-    const tier = this.latency.quality;
-    const prev = this._lastQualityTier;
-    if (tier !== prev) {
-      this._lastQualityTier = tier;
-      this.emit('quality_change', { quality: tier, latency: this.latency.avg });
-    }
-  }
-});

package/static/js/ws-machine.js

@@ -1,68 +0,0 @@
-
-const { createMachine, createActor, assign } = XState;
-
-const wsMachine = createMachine({
-  id: 'websocket',
-  initial: 'disconnected',
-  context: {
-    reconnectCount: 0,
-    lastConnectedAt: null,
-    lastDisconnectedAt: null,
-    manualDisconnect: false,
-  },
-  states: {
-    disconnected: {
-      entry: assign({ lastDisconnectedAt: () => Date.now() }),
-      on: {
-        CONNECT: { target: 'connecting', guard: ({ context }) => !context.manualDisconnect },
-        MANUAL_DISCONNECT: { actions: assign({ manualDisconnect: true }) },
-      },
-    },
-    connecting: {
-      on: {
-        OPEN: {
-          target: 'connected',
-          actions: assign({ reconnectCount: 0, lastConnectedAt: () => Date.now() }),
-        },
-        ERROR: 'reconnecting',
-        CLOSE: 'reconnecting',
-        MANUAL_DISCONNECT: {
-          target: 'disconnected',
-          actions: assign({ manualDisconnect: true }),
-        },
-      },
-    },
-    connected: {
-      entry: assign({ lastConnectedAt: () => Date.now() }),
-      on: {
-        CLOSE: 'reconnecting',
-        ERROR: 'reconnecting',
-        MANUAL_DISCONNECT: {
-          target: 'disconnected',
-          actions: assign({ manualDisconnect: true, reconnectCount: 0 }),
-        },
-      },
-    },
-    reconnecting: {
-      entry: assign(({ context }) => ({ reconnectCount: context.reconnectCount + 1 })),
-      on: {
-        CONNECT: 'connecting',
-        MANUAL_DISCONNECT: {
-          target: 'disconnected',
-          actions: assign({ manualDisconnect: true, reconnectCount: 0 }),
-        },
-      },
-    },
-  },
-});
-
-function createWsActor() {
-  const actor = createActor(wsMachine);
-  actor.start();
-  return actor;
-}
-
-if (typeof window !== 'undefined') {
-  window.createWsActor = createWsActor;
-  window.wsMachine = wsMachine;
-}