@yourfam/yf-vitals 0.1.0 → 0.2.0

package/README.md

@@ -37,12 +37,14 @@ One live dashboard. Refresh every **1.0s** (or `--interval`, or **2.0s** with `-
 | **CPU** | Overall utilization 0–100%, plus physical / logical core counts |
 | **RAM** | Percent used, plus used / total (`GiB` / `MiB`) |
 | **DSK** | Read and write **rates** (KiB/s, MiB/s, GiB/s) |
-| **NET** | Send ↑ and receive ↓ in **Mbps** (1 Mbps = 1e6 bit/s) |
+| **NET** | Send ↑ and receive ↓ in **kbps / Mbps / Gbps** (decimal bits; 1 Mbps = 1e6 bit/s) |
 | **GPU** | Utilization and VRAM when telemetry exists; **the row is omitted** when it does not |
 
 Header: `yf-vitals` · hostname · OS · `NP/NL` cores · RAM total · tick interval.
 
-Each percent row has a 20-cell bar and a sparkline of the last 60 ticks. Disk and net sparklines scale to the **max in that buffer** (rates have no 100% ceiling). CPU / RAM / GPU sparklines are percent 0–100.
+Each percent row has a 20-cell bar and a sparkline of the last 60 ticks. Unused spark slots use the lowest tick (`▁` / `_`), not blank space. Bar fill stays the row color below 50%, turns **yellow at 50%**, **red at 80%**. Sparklines stay the row color.
+
+Disk and net each show **two** sparks (`R`/`W`, `↑`/`↓`) scaled to the **max of that pair** in the buffer (rates have no 100% ceiling). CPU / RAM / GPU sparks are percent 0–100.
 
 First disk/net tick may show `—` while counters settle.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yourfam/yf-vitals",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Live terminal dashboard for CPU, RAM, disk, net, and optional GPU",
   "type": "module",
   "bin": {

package/src/args.js

@@ -98,7 +98,8 @@ Usage:
   --version, -V          Package version
 
 q / Q / Ctrl+C quit. GPU row is omitted when the OS has no GPU telemetry.
-Disk rates are MiB/s; network rates are Mbps.
-Disk / net sparklines scale to the max in the last 60 ticks (no 100% ceiling).
+Disk rates are KiB/s–GiB/s; network rates are kbps/Mbps/Gbps.
+Disk / net sparks are split (R/W, ↑/↓) and scale to the pair max in the last 60 ticks.
+Bar fill turns yellow ≥50% and red ≥80%. Unused spark slots use the lowest tick.
 Needs a terminal (no pipes). Node 20+.`;
 }

package/src/bar.js

@@ -55,8 +55,9 @@ export function sparkline(values, width, opts = {}) {
   if (w === 0) return "";
   const charset = opts.ascii ? ASC_SPARK : UNI_SPARK;
   const list = Array.isArray(values) ? values : [];
+  const floor = charset[0];
   if (list.length === 0) {
-    return " ".repeat(w);
+    return floor.repeat(w);
   }
   const slice = list.slice(-w);
   const pad = w - slice.length;
@@ -64,7 +65,21 @@ export function sparkline(values, width, opts = {}) {
   const dataMax = slice.reduce((m, v) => (v > m ? v : m), 0);
   const max = explicitMax != null ? explicitMax : dataMax;
   const chars = slice.map((v) => sparkChar(v, max, charset));
-  return " ".repeat(pad) + chars.join("");
+  return floor.repeat(pad) + chars.join("");
+}
+
+export const HEAT_WARM = 50;
+export const HEAT_HOT = 80;
+
+/**
+ * @param {number} percent
+ * @returns {"ok" | "warm" | "hot"}
+ */
+export function heatLevel(percent) {
+  const n = Number(percent);
+  if (!Number.isFinite(n) || n < HEAT_WARM) return "ok";
+  if (n < HEAT_HOT) return "warm";
+  return "hot";
 }
 
 /**

package/src/color.js

@@ -12,6 +12,7 @@ export function createColor(opts) {
     magenta: (value) => pc.magenta(String(value)),
     green: (value) => pc.green(String(value)),
     yellow: (value) => pc.yellow(String(value)),
+    red: (value) => pc.red(String(value)),
     dim: (value) => pc.dim(String(value)),
   };
 }

package/src/disk.js

@@ -1,23 +1,43 @@
 import { spawn } from "node:child_process";
 
-const PS_DISK = `
+const PS_COUNTERS = `
 $ErrorActionPreference = 'SilentlyContinue'
 while (($line = [Console]::In.ReadLine()) -ne $null) {
   if ($line -eq 'q') { break }
+  $dr = [int64]0
+  $dw = [int64]0
+  $rx = [int64]0
+  $tx = [int64]0
   $d = Get-CimInstance -ClassName Win32_PerfRawData_PerfDisk_PhysicalDisk -Filter "Name='_Total'"
-  if ($d) { Write-Output ("{0} {1}" -f $d.DiskReadBytesPersec, $d.DiskWriteBytesPersec) }
-  else { Write-Output "n n" }
+  if ($d) {
+    $dr = [int64]$d.DiskReadBytesPersec
+    $dw = [int64]$d.DiskWriteBytesPersec
+  }
+  Get-NetAdapterStatistics | ForEach-Object {
+    $name = [string]$_.Name
+    if ($name -match 'vEthernet|Loopback|Bluetooth|WSL|Hyper-V|Virtual|Pseudo|isatap|Teredo') { return }
+    $rx += [int64]$_.ReceivedBytes
+    $tx += [int64]$_.SentBytes
+  }
+  Write-Output ("{0} {1} {2} {3}" -f $dr, $dw, $rx, $tx)
 }
 `.trim();
 
 /**
  * @param {string} line
- * @returns {{ rx: number, wx: number } | null}
+ * @returns {{ rx: number, wx: number, netRx: number, netTx: number } | null}
  */
 export function parseDiskCounterLine(line) {
-  const m = String(line || "").trim().match(/^(\d+)\s+(\d+)$/);
+  const m = String(line || "")
+    .trim()
+    .match(/^(\d+)\s+(\d+)(?:\s+(\d+)\s+(\d+))?$/);
   if (!m) return null;
-  return { rx: Number(m[1]), wx: Number(m[2]) };
+  return {
+    rx: Number(m[1]),
+    wx: Number(m[2]),
+    netRx: m[3] != null ? Number(m[3]) : 0,
+    netTx: m[4] != null ? Number(m[4]) : 0,
+  };
 }
 
 function encodedCommand(script) {
@@ -26,11 +46,12 @@ function encodedCommand(script) {
 
 /**
  * Long-lived PowerShell so WMI stays warm (~10ms/tick after first query).
+ * One round-trip: disk bytes + physical NIC byte counters.
  */
 export function createWindowsDiskReader() {
   let child = null;
   let buf = "";
-  /** @type {{ resolve: (v: { rx: number, wx: number } | null) => void }[]} */
+  /** @type {{ resolve: (v: ReturnType<typeof parseDiskCounterLine>) => void }[]} */
   let pending = [];
   let closed = false;
 
@@ -43,7 +64,7 @@ export function createWindowsDiskReader() {
     if (child || closed) return;
     child = spawn(
       "powershell.exe",
-      ["-NoProfile", "-NonInteractive", "-EncodedCommand", encodedCommand(PS_DISK)],
+      ["-NoProfile", "-NonInteractive", "-EncodedCommand", encodedCommand(PS_COUNTERS)],
       { windowsHide: true, stdio: ["pipe", "pipe", "ignore"] },
     );
     child.stdout.setEncoding("utf8");
@@ -67,7 +88,7 @@ export function createWindowsDiskReader() {
 
   return {
     /**
-     * @returns {Promise<{ rx: number, wx: number } | null>}
+     * @returns {Promise<ReturnType<typeof parseDiskCounterLine>>}
      */
     read() {
       if (closed) return Promise.resolve(null);

package/src/format.js

@@ -39,15 +39,19 @@ export function formatByteRate(bytesPerSec) {
 }
 
 /**
- * Network throughput in decimal Mbps (1 Mbps = 1e6 bit/s).
+ * Network throughput in decimal bit/s, auto-scaled (kbps / Mbps / Gbps).
+ * 1 kbps = 1e3 bit/s, 1 Mbps = 1e6 bit/s.
  * @param {number | null | undefined} bytesPerSec
  */
 export function formatBitRate(bytesPerSec) {
   if (bytesPerSec == null) return "—";
   const n = Number(bytesPerSec);
   if (!Number.isFinite(n) || n < 0) return "—";
-  const mbps = (n * 8) / 1e6;
-  return `${mbps.toFixed(1)} Mbps`;
+  const bits = n * 8;
+  if (bits >= 1e9) return `${(bits / 1e9).toFixed(2)} Gbps`;
+  if (bits >= 1e6) return `${(bits / 1e6).toFixed(1)} Mbps`;
+  if (bits >= 1e3) return `${(bits / 1e3).toFixed(1)} kbps`;
+  return `${bits.toFixed(0)} bps`;
 }
 
 /**

package/src/history.js

@@ -5,12 +5,14 @@ import { HISTORY_SIZE } from "./bar.js";
  * @property {number[]} cpu
  * @property {number[]} ram
  * @property {number[]} gpu
- * @property {number[]} dsk
- * @property {number[]} net
+ * @property {number[]} dskR
+ * @property {number[]} dskW
+ * @property {number[]} netUp
+ * @property {number[]} netDn
  */
 
 export function createHistory() {
-  return { cpu: [], ram: [], gpu: [], dsk: [], net: [] };
+  return { cpu: [], ram: [], gpu: [], dskR: [], dskW: [], netUp: [], netDn: [] };
 }
 
 /**
@@ -33,26 +35,13 @@ export function pushSample(buf, value, size = HISTORY_SIZE) {
  * @returns {History}
  */
 export function appendHistory(history, snap) {
-  const cpu = snap.cpu?.percent;
-  const ram = snap.ram?.percent;
-  const gpu = snap.gpu?.percent;
-  const read = snap.disk?.readBps;
-  const write = snap.disk?.writeBps;
-  const tx = snap.net?.txBps;
-  const rx = snap.net?.rxBps;
-  let dsk;
-  if (read != null || write != null) {
-    dsk = (read ?? 0) + (write ?? 0);
-  }
-  let net;
-  if (tx != null || rx != null) {
-    net = (tx ?? 0) + (rx ?? 0);
-  }
   return {
-    cpu: pushSample(history.cpu, cpu),
-    ram: pushSample(history.ram, ram),
-    gpu: pushSample(history.gpu, gpu),
-    dsk: pushSample(history.dsk, dsk),
-    net: pushSample(history.net, net),
+    cpu: pushSample(history.cpu, snap.cpu?.percent),
+    ram: pushSample(history.ram, snap.ram?.percent),
+    gpu: pushSample(history.gpu, snap.gpu?.percent),
+    dskR: pushSample(history.dskR, snap.disk?.readBps),
+    dskW: pushSample(history.dskW, snap.disk?.writeBps),
+    netUp: pushSample(history.netUp, snap.net?.txBps),
+    netDn: pushSample(history.netDn, snap.net?.rxBps),
   };
 }

package/src/render.js

@@ -1,5 +1,12 @@
 import { useAscii } from "./ascii.js";
-import { BAR_WIDTH, bar, barCharset, sparkWidth, sparkline } from "./bar.js";
+import {
+  BAR_WIDTH,
+  bar,
+  barCharset,
+  heatLevel,
+  sparkWidth,
+  sparkline,
+} from "./bar.js";
 import { createColor, stripAnsi } from "./color.js";
 import {
   formatBitRate,
@@ -39,6 +46,58 @@ export function fitLine(line, columns) {
   return out;
 }
 
+/**
+ * @param {ReturnType<typeof createColor>} color
+ * @param {number} percent
+ * @param {"cyan" | "magenta" | "green"} row
+ */
+export function heatPaint(color, percent, row) {
+  const level = heatLevel(percent);
+  if (level === "hot") return color.red;
+  if (level === "warm") return color.yellow;
+  return color[row];
+}
+
+/**
+ * Percent bar: fill takes heat color, empty stays dim. Sparkline stays the row color.
+ *
+ * @param {number} percent
+ * @param {ReturnType<typeof createColor>} color
+ * @param {"cyan" | "magenta" | "green"} row
+ * @param {boolean} ascii
+ */
+export function paintPercentBar(percent, color, row, ascii) {
+  const cs = barCharset(ascii);
+  const raw = bar(percent, BAR_WIDTH, cs);
+  const filled = raw.replaceAll(cs.empty, "").length;
+  const fill = raw.slice(0, filled);
+  const empty = raw.slice(filled);
+  const paint = heatPaint(color, percent, row);
+  return `[${paint(fill)}${color.dim(empty)}]`;
+}
+
+/**
+ * Two labeled sparks on one line, sharing a max so the pair is comparable.
+ *
+ * @param {string} leftLabel
+ * @param {number[]} leftVals
+ * @param {string} rightLabel
+ * @param {number[]} rightVals
+ * @param {number} sparkW
+ * @param {boolean} ascii
+ */
+export function splitSparkLine(leftLabel, leftVals, rightLabel, rightVals, sparkW, ascii) {
+  const leftTag = `${leftLabel} `;
+  const mid = `  ${rightLabel} `;
+  const overhead = leftTag.length + mid.length;
+  const inner = Math.max(overhead + 8, Number(sparkW) || 16);
+  const each = Math.max(4, Math.floor((inner - overhead) / 2));
+  const pairMax = Math.max(0, ...leftVals, ...rightVals);
+  const left = sparkline(leftVals, each, { ascii, max: pairMax || undefined });
+  const right = sparkline(rightVals, each, { ascii, max: pairMax || undefined });
+  return `${leftTag}${left}${mid}${right}`;
+}
+
 /**
  * @param {import("./sample.js").GpuSample | null | undefined} gpu
  * @param {{ history: number[], ascii: boolean, color: ReturnType<typeof createColor>, sparkW: number }} opts
@@ -47,18 +106,15 @@ export function fitLine(line, columns) {
 export function buildGpuRow(gpu, opts) {
   if (gpu == null) return null;
   const { ascii, color, sparkW, history } = opts;
-  const cs = barCharset(ascii);
   const pct = gpu.percent;
-  const barStr =
-    pct == null ? null : bar(pct, BAR_WIDTH, cs);
   const pctStr = pct == null ? "n/a" : formatPercent(pct);
   const mem =
     gpu.used != null && gpu.total != null ? formatBytePair(gpu.used, gpu.total) : "";
   const label = color.green("GPU");
   const head =
-    barStr == null
+    pct == null
       ? `${label}  ${pctStr}${mem ? `   ${mem}` : ""}`
-      : `${label}  [${color.green(barStr)}]  ${pctStr}${mem ? `   ${mem}` : ""}`;
+      : `${label}  ${paintPercentBar(pct, color, "green", ascii)}  ${pctStr}${mem ? `   ${mem}` : ""}`;
   const spark = color.green(sparkline(history, sparkW, { ascii, max: 100 }));
   return [head, `     ${spark}`];
 }
@@ -74,7 +130,6 @@ export function renderFrame(snap, history, opts = {}) {
   const ascii = useAscii(env);
   const color = createColor({ isTTY: Boolean(opts.isTTY), env });
   const sparkW = sparkWidth(columns);
-  const cs = barCharset(ascii);
   const interval = formatInterval(opts.intervalSec ?? 1);
   const cores = formatCores(snap.physical, snap.logical);
   const ramTot = formatBytes(snap.ramTotal);
@@ -91,10 +146,9 @@ export function renderFrame(snap, history, opts = {}) {
   const lines = [header, ""];
 
   if (snap.cpu) {
-    const b = color.cyan(bar(snap.cpu.percent, BAR_WIDTH, cs));
     const detail = formatCoresDetail(snap.physical, snap.logical);
     lines.push(
-      `${color.cyan("CPU")}  [${b}]  ${formatPercent(snap.cpu.percent)}   ${detail}`,
+      `${color.cyan("CPU")}  ${paintPercentBar(snap.cpu.percent, color, "cyan", ascii)}  ${formatPercent(snap.cpu.percent)}   ${detail}`,
     );
     lines.push(`     ${color.cyan(sparkline(history.cpu, sparkW, { ascii, max: 100 }))}`);
   } else {
@@ -104,9 +158,8 @@ export function renderFrame(snap, history, opts = {}) {
   lines.push("");
 
   if (snap.ram) {
-    const b = color.magenta(bar(snap.ram.percent, BAR_WIDTH, cs));
     lines.push(
-      `${color.magenta("RAM")}  [${b}]  ${formatPercent(snap.ram.percent)}   ${formatBytePair(snap.ram.used, snap.ram.total)}`,
+      `${color.magenta("RAM")}  ${paintPercentBar(snap.ram.percent, color, "magenta", ascii)}  ${formatPercent(snap.ram.percent)}   ${formatBytePair(snap.ram.used, snap.ram.total)}`,
     );
     lines.push(`     ${color.magenta(sparkline(history.ram, sparkW, { ascii, max: 100 }))}`);
   } else {
@@ -130,21 +183,29 @@ export function renderFrame(snap, history, opts = {}) {
     const r = formatByteRate(snap.disk.readBps);
     const w = formatByteRate(snap.disk.writeBps);
     lines.push(`${color.green("DSK")}  R  ${r.padStart(11)}   W  ${w.padStart(11)}`);
-    lines.push(`     ${color.green(sparkline(history.dsk, sparkW, { ascii }))}`);
+    lines.push(
+      `     ${color.green(splitSparkLine("R", history.dskR, "W", history.dskW, sparkW, ascii))}`,
+    );
   } else {
     lines.push(`${color.green("DSK")}  n/a`);
-    lines.push(`     ${color.green(sparkline(history.dsk, sparkW, { ascii }))}`);
+    lines.push(
+      `     ${color.green(splitSparkLine("R", history.dskR, "W", history.dskW, sparkW, ascii))}`,
+    );
   }
   lines.push("");
 
   if (snap.net) {
     const up = formatBitRate(snap.net.txBps);
     const down = formatBitRate(snap.net.rxBps);
-    lines.push(`${color.yellow("NET")}  ↑  ${up.padStart(10)}    ↓  ${down.padStart(10)}`);
-    lines.push(`     ${color.yellow(sparkline(history.net, sparkW, { ascii }))}`);
+    lines.push(`${color.yellow("NET")}  ↑  ${up.padStart(12)}    ↓  ${down.padStart(12)}`);
+    lines.push(
+      `     ${color.yellow(splitSparkLine("↑", history.netUp, "↓", history.netDn, sparkW, ascii))}`,
+    );
   } else {
     lines.push(`${color.yellow("NET")}  n/a`);
-    lines.push(`     ${color.yellow(sparkline(history.net, sparkW, { ascii }))}`);
+    lines.push(
+      `     ${color.yellow(splitSparkLine("↑", history.netUp, "↓", history.netDn, sparkW, ascii))}`,
+    );
   }
   lines.push("");
   lines.push("q quit");

package/src/sample.js

@@ -100,23 +100,22 @@ export function gpuBytes(n, vramMb) {
  */
 export function pickGpu(controllers) {
   if (!Array.isArray(controllers) || controllers.length === 0) return null;
-  const usable = controllers.filter((c) => {
+  /** @type {GpuSample[]} */
+  const usable = [];
+  for (const c of controllers) {
     const util = num(c.utilizationGpu);
-    const total = gpuBytes(num(c.memoryTotal), num(c.vram));
     const used = gpuBytes(num(c.memoryUsed), null);
-    return util != null || (total != null && total > 0) || used != null;
-  });
+    const total = gpuBytes(num(c.memoryTotal), null);
+    if (util == null && (used == null || total == null)) continue;
+    usable.push({
+      percent: util ?? 0,
+      used,
+      total,
+    });
+  }
   if (usable.length === 0) return null;
-  const c =
-    usable.find((x) => num(x.utilizationGpu) != null) || usable[0];
-  const percent = num(c.utilizationGpu);
-  const total = gpuBytes(num(c.memoryTotal), num(c.vram));
-  const used = gpuBytes(num(c.memoryUsed), null);
-  return {
-    percent,
-    used,
-    total,
-  };
+  usable.sort((a, b) => (b.total ?? 0) - (a.total ?? 0));
+  return usable[0];
 }
 
 /**
@@ -174,15 +173,16 @@ function mergePair(next, last, a, b) {
 /**
  * @param {os.CpuInfo[]} cpus
  */
-export function cpuIdleTotal(cpus) {
+export function cpuIdleTotal(cpus, windows = process.platform === "win32") {
   let idle = 0;
   let total = 0;
   for (const c of cpus) {
     const t = c.times;
+    const irq = t.irq || 0;
+    const sys = windows ? Math.max(0, (t.sys || 0) - irq) : t.sys || 0;
     const i = t.idle || 0;
-    const sum = (t.user || 0) + (t.nice || 0) + (t.sys || 0) + (t.irq || 0) + i;
     idle += i;
-    total += sum;
+    total += (t.user || 0) + (t.nice || 0) + sys + irq + i;
   }
   return { idle, total };
 }
@@ -204,6 +204,16 @@ export function cpuPercentFromDelta(prev, curr) {
 /**
  * @param {Array<{ iface?: string, rx_bytes?: number, tx_bytes?: number, operstate?: string, internal?: boolean }>} stats
  */
+const VIRTUAL_IFACE =
+  /^(lo|lo0)$|Loopback|vEthernet|Hyper-V|WSL|Bluetooth|Virtual|VPN|TAP|TUN|Tailscale|Pseudo|isatap|Teredo/i;
+
+/**
+ * @param {string} name
+ */
+export function isVirtualIface(name) {
+  return VIRTUAL_IFACE.test(String(name || ""));
+}
+
 export function sumNetBytes(stats) {
   let rx = 0;
   let tx = 0;
@@ -211,12 +221,8 @@ export function sumNetBytes(stats) {
   if (!Array.isArray(stats)) return { rx: null, tx: null };
   for (const n of stats) {
     const name = String(n.iface || "");
-    if (n.internal || name === "lo" || name === "lo0" || /^Loopback/i.test(name)) {
-      continue;
-    }
-    if (n.operstate && n.operstate !== "up" && n.operstate !== "unknown") {
-      continue;
-    }
+    if (n.internal || isVirtualIface(name)) continue;
+    if (n.operstate && n.operstate !== "up") continue;
     const r = num(n.rx_bytes);
     const t = num(n.tx_bytes);
     if (r == null && t == null) continue;
@@ -282,34 +288,28 @@ export function createSampler(si) {
   }
 
   async function sampleCpu(lib) {
-    const curr = cpuIdleTotal(os.cpus());
-    if (!prevCpu) {
-      prevCpu = curr;
-      await new Promise((r) => setTimeout(r, 50));
-      const curr2 = cpuIdleTotal(os.cpus());
-      const pctFast = cpuPercentFromDelta(prevCpu, curr2);
-      prevCpu = curr2;
-      if (pctFast != null) return { percent: pctFast };
-    } else {
-      const pct = cpuPercentFromDelta(prevCpu, curr);
-      prevCpu = curr;
-      if (pct != null) return { percent: pct };
-    }
     try {
       const load = await lib.currentLoad();
       const pct = num(load?.currentLoad);
       if (pct != null) return { percent: Math.min(100, Math.max(0, pct)) };
     } catch {
-      // keep n/a
+      // fall through to os.cpus() idle-delta
     }
-    return null;
+    const curr = cpuIdleTotal(os.cpus());
+    const pct = cpuPercentFromDelta(prevCpu, curr);
+    prevCpu = curr;
+    if (pct == null) return null;
+    return { percent: pct };
   }
 
   async function sampleRam(lib, ramTotal) {
     try {
       const mem = await lib.mem();
       const total = num(mem?.total) ?? ramTotal;
-      const used = num(mem?.used) ?? num(mem?.active);
+      const available = num(mem?.available) ?? num(mem?.free);
+      let used = null;
+      if (total != null && available != null) used = Math.max(0, total - available);
+      else used = num(mem?.used) ?? num(mem?.active);
       if (used == null || total == null || total <= 0) return null;
       return {
         percent: Math.min(100, Math.max(0, (used / total) * 100)),
@@ -329,21 +329,20 @@ export function createSampler(si) {
     }
   }
 
-  async function sampleDisk(lib, ts) {
-    let rx = null;
-    let wx = null;
-    try {
-      const fs = await lib.fsStats();
-      rx = num(fs?.rx);
-      wx = num(fs?.wx);
-    } catch {
-      // Windows fsStats is always null; fall through
-    }
-    if (rx == null && wx == null && winDisk) {
-      const w = await winDisk.read();
-      if (w) {
-        rx = w.rx;
-        wx = w.wx;
+  /**
+   * @param {number} ts
+   * @param {{ rx: number, wx: number } | null} win
+   */
+  async function sampleDisk(lib, ts, win) {
+    let rx = win ? num(win.rx) : null;
+    let wx = win ? num(win.wx) : null;
+    if (rx == null && wx == null) {
+      try {
+        const fs = await lib.fsStats();
+        rx = num(fs?.rx);
+        wx = num(fs?.wx);
+      } catch {
+        // Windows fsStats is always null
       }
     }
     if (rx == null && wx == null) return { readBps: null, writeBps: null };
@@ -353,17 +352,27 @@ export function createSampler(si) {
     return { readBps, writeBps };
   }
 
-  async function sampleNet(lib, ts) {
-    try {
-      const stats = await lib.networkStats("*");
-      const { rx, tx } = sumNetBytes(Array.isArray(stats) ? stats : stats ? [stats] : []);
-      const rxBps = rateFromCounters(prevNet?.rx, rx, prevTs, ts);
-      const txBps = rateFromCounters(prevNet?.tx, tx, prevTs, ts);
-      if (rx != null && tx != null) prevNet = { rx, tx };
-      return { txBps, rxBps };
-    } catch {
-      return { txBps: null, rxBps: null };
+  /**
+   * @param {number} ts
+   * @param {{ netRx?: number, netTx?: number } | null} win
+   */
+  async function sampleNet(lib, ts, win) {
+    let rx = win ? num(win.netRx) : null;
+    let tx = win ? num(win.netTx) : null;
+    if (rx == null && tx == null) {
+      try {
+        const stats = await lib.networkStats("*");
+        const summed = sumNetBytes(Array.isArray(stats) ? stats : stats ? [stats] : []);
+        rx = summed.rx;
+        tx = summed.tx;
+      } catch {
+        return { txBps: null, rxBps: null };
+      }
     }
+    const rxBps = rateFromCounters(prevNet?.rx, rx, prevTs, ts);
+    const txBps = rateFromCounters(prevNet?.tx, tx, prevTs, ts);
+    if (rx != null && tx != null) prevNet = { rx, tx };
+    return { txBps, rxBps };
   }
 
   async function sampleGpu(lib) {
@@ -383,12 +392,13 @@ export function createSampler(si) {
       const lib = await loadSi();
       if (!staticP) staticP = loadStatic();
       const meta = await staticP;
+      const win = winDisk ? await winDisk.read().catch(() => null) : null;
       const ts = Date.now();
       const [cpu, ram, disk, net, gpu] = await Promise.all([
         sampleCpu(lib).catch(() => last?.cpu ?? null),
         sampleRam(lib, meta.ramTotal).catch(() => last?.ram ?? null),
-        sampleDisk(lib, ts).catch(() => last?.disk ?? { readBps: null, writeBps: null }),
-        sampleNet(lib, ts).catch(() => last?.net ?? { txBps: null, rxBps: null }),
+        sampleDisk(lib, ts, win).catch(() => last?.disk ?? { readBps: null, writeBps: null }),
+        sampleNet(lib, ts, win).catch(() => last?.net ?? { txBps: null, rxBps: null }),
         sampleGpu(lib).catch(() => last?.gpu ?? null),
       ]);
       prevTs = ts;