耗尽预测改为实时速率：近3小时实际消耗优先 (v1.12.1)

旧算法对 48h 窗口做等权最小二乘，速率突变时被安静时段稀释——
合成回测（40h 慢烧后提速到 $48/天）显示旧算法只估出 $5.4/天，
ETA 偏差 10 倍；近窗实际速率精确命中，真实数据上两者误差相当。

- predict 分层估计：近 3 小时实际消耗速率（余额下降求和÷跨度，
  充值上升天然忽略）→ 不足退近 12 小时 → 冷启动兜底原回归
- 返回 basis 口径字段，卡片与弹窗显示「≈¥X/天（近3小时）」
- ETA 告警走同一函数，同步获得实时性
- 真实数据验证：zz1cc 近 3 小时实际 $747/天 → ETA 2.3 天
 （旧回归被夜间安静时段稀释，完全暴露不出该风险）

Author: lettimepassby

lib/history.js

@@ -96,56 +96,79 @@ export class History {
     return arr.filter((p) => p[0] >= cutoff);
   }
 
+  // 某窗口内的实际消耗速率（$/天）：余额下降求和 ÷ 实际跨度。
+  // 上升视为充值自动忽略；跨度不足 minSpanH 或点太少返回 null
+  burnRate(stationId, windowHours, minSpanH = 1, minPoints = 5) {
+    const arr = this.data[stationId] || [];
+    const cutoff = Date.now() - windowHours * 3600 * 1000;
+    const seg = arr.filter((p) => p[0] >= cutoff);
+    if (seg.length < minPoints) return null;
+    const spanH = (seg[seg.length - 1][0] - seg[0][0]) / 3600000;
+    if (spanH < minSpanH) return null;
+    let drop = 0;
+    for (let i = 1; i < seg.length; i++) {
+      const d = seg[i - 1][1] - seg[i][1];
+      if (d > 0) drop += d;
+    }
+    return { burnPerDay: (drop / spanH) * 24, samples: seg.length, spanHours: spanH };
+  }
+
   /**
-   * 耗尽预测。
-   * 只回归最近一次「充值」之后的数据段（余额显著上升视为充值），
-   * 窗口默认取最近 48 小时，至少需要 3 个点且时间跨度 ≥ 10 分钟。
-   * 返回 { burnPerDay, etaDays, etaAt, samples, spanHours } 或 null（数据不足/无消耗）。
+   * 耗尽预测——按「实时速率」分层估计：
+   *   1. 近 3 小时实际消耗速率（提速/降速 3 小时内即反映到 ETA）
+   *   2. 数据不足退近 12 小时
+   *   3. 再不足退回充值截断后的 48 小时最小二乘回归（冷启动兜底）
+   * 回测依据：合成提速场景下旧 48h 等权回归把 ¥48/天 稀释成 ¥5.4/天
+   *（ETA 偏差 10 倍），近窗实际速率精确命中；真实数据上两者误差相当。
+   * 返回 { burnPerDay, etaDays, etaAt, basis, samples, spanHours } 或 null。
    */
   predict(stationId, windowHours = 48) {
     const all = this.data[stationId] || [];
-    const cutoff = Date.now() - windowHours * 3600 * 1000;
-    let pts = all.filter((p) => p[0] >= cutoff);
-    if (pts.length < 3) pts = all.slice(-50); // 窗口内不足则退回最近 50 个点
-    if (pts.length < 3) return null;
+    if (all.length < 3) return null;
+    const latest = all[all.length - 1];
 
-    // 截断到最近一次充值之后
-    let start = 0;
-    for (let i = 1; i < pts.length; i++) {
-      if (pts[i][1] > pts[i - 1][1] + TOPUP_EPSILON) start = i;
+    let est = this.burnRate(stationId, 3, 1, 5);
+    let basis = "近3小时";
+    if (!est) { est = this.burnRate(stationId, 12, 2, 5); basis = "近12小时"; }
+    if (!est) {
+      // 冷启动兜底：充值截断后的窗口回归
+      const cutoff = Date.now() - windowHours * 3600 * 1000;
+      let pts = all.filter((p) => p[0] >= cutoff);
+      if (pts.length < 3) pts = all.slice(-50);
+      let start = 0;
+      for (let i = 1; i < pts.length; i++) {
+        if (pts[i][1] > pts[i - 1][1] + TOPUP_EPSILON) start = i;
+      }
+      pts = pts.slice(start);
+      if (pts.length < 3) return null;
+      const spanMs = pts[pts.length - 1][0] - pts[0][0];
+      if (spanMs < 10 * 60 * 1000) return null;
+      const t0 = pts[0][0];
+      let sx = 0, sy = 0, sxx = 0, sxy = 0;
+      const n = pts.length;
+      for (const [t, r] of pts) {
+        const x = (t - t0) / 3600000;
+        sx += x; sy += r; sxx += x * x; sxy += x * r;
+      }
+      const denom = n * sxx - sx * sx;
+      if (Math.abs(denom) < 1e-9) return null;
+      const slope = (n * sxy - sx * sy) / denom;
+      est = { burnPerDay: slope < 0 ? -slope * 24 : 0, samples: n, spanHours: spanMs / 3600000 };
+      basis = "回归";
     }
-    pts = pts.slice(start);
-    if (pts.length < 3) return null;
-
-    const spanMs = pts[pts.length - 1][0] - pts[0][0];
-    if (spanMs < 10 * 60 * 1000) return null; // 跨度太短，预测无意义
-
-    // 最小二乘：remaining = a + b * t
-    const t0 = pts[0][0];
-    let sx = 0, sy = 0, sxx = 0, sxy = 0;
-    const n = pts.length;
-    for (const [t, r] of pts) {
-      const x = (t - t0) / 3600000; // 小时
-      sx += x; sy += r; sxx += x * x; sxy += x * r;
-    }
-    const denom = n * sxx - sx * sx;
-    if (Math.abs(denom) < 1e-9) return null;
-    const slope = (n * sxy - sx * sy) / denom; // $/小时
-
-    const burnPerDay = slope < 0 ? -slope * 24 : 0;
-    const latest = pts[pts.length - 1];
-    const remaining = latest[1];
 
+    const burnPerDay = est.burnPerDay;
     if (burnPerDay < 0.0001) {
-      return { burnPerDay: 0, etaDays: null, etaAt: null, samples: n, spanHours: spanMs / 3600000 };
+      return { burnPerDay: 0, etaDays: null, etaAt: null, basis, samples: est.samples, spanHours: Math.round(est.spanHours * 10) / 10 };
     }
-    const etaDays = remaining / burnPerDay;
+    const etaDays = latest[1] / burnPerDay;
     return {
       burnPerDay: Math.round(burnPerDay * 100) / 100,
       etaDays: Math.round(etaDays * 10) / 10,
       etaAt: new Date(latest[0] + etaDays * 86400000).toISOString(),
-      samples: n,
-      spanHours: Math.round((spanMs / 3600000) * 10) / 10,
+      basis,
+      samples: est.samples,
+      spanHours: Math.round(est.spanHours * 10) / 10,
     };
   }
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-monitor",
-  "version": "1.12.0",
+  "version": "1.12.1",
   "private": true,
   "description": "监控 sub2api / new-api 中转站余额的网页面板",
   "type": "module",

public/app.js

@@ -130,10 +130,10 @@ function fmtEtaText(days) {
 }
 function etaText(p, rate = 1) {
   if (!p) return null;
-  if (p.burnPerDay === 0) return { text: "近期无消耗", cls: "" };
+  if (p.burnPerDay === 0) return { text: `${p.basis || "近期"}无消耗`, cls: "" };
   if (p.etaDays == null) return null;
   const cls = p.etaDays <= (state.rules.etaDays ?? 3) ? "danger" : p.etaDays <= 7 ? "warn" : "";
-  return { text: `≈ ${cny(p.burnPerDay * rate)}/天 · 预计 ${fmtEtaText(p.etaDays)}后耗尽`, cls };
+  return { text: `≈ ${cny(p.burnPerDay * rate)}/天（${p.basis || "估算"}）· 预计 ${fmtEtaText(p.etaDays)}后耗尽`, cls };
 }
 
 // ---- 登录 -------------------------------------------------------------------