@yourfam/yf-vitals 0.1.1 → 0.3.0

package/README.md

@@ -36,13 +36,16 @@ 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`) |
+| **USE** | Local hard-disk fill (system volume first). Skips Google Drive, iCloud, network, FAT/USB. Extra local disks as extra lines |
 | **DSK** | Read and write **rates** (KiB/s, MiB/s, GiB/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.1",
+  "version": "0.3.0",
   "description": "Live terminal dashboard for CPU, RAM, disk, net, and optional GPU",
   "type": "module",
   "bin": {

package/src/args.js

@@ -98,7 +98,9 @@ Usage:
   --version, -V          Package version
 
 q / Q / Ctrl+C quit. GPU row is omitted when the OS has no GPU telemetry.
+USE is local NTFS/APFS/HFS fill (no Google Drive, iCloud, or network shares).
 Disk rates are KiB/s–GiB/s; network rates are kbps/Mbps/Gbps.
-Disk / net sparklines scale to the max in the last 60 ticks (no 100% ceiling).
+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/dashboard.js

@@ -1,6 +1,6 @@
 import { appendHistory, createHistory } from "./history.js";
 import { renderFrame } from "./render.js";
-import { createSampler, mergeLastGood } from "./sample.js";
+import { createSampler, instantSnapshot, mergeLastGood } from "./sample.js";
 import { CLEAR_HOME, enterTerminal, restoreTerminal } from "./tty.js";
 
 const CTRL_C = 0x03;
@@ -61,6 +61,16 @@ export async function runDashboard(args, deps) {
   };
 
   enterTerminal(write, stdin);
+  const first = instantSnapshot();
+  write(
+    CLEAR_HOME +
+      renderFrame(first, createHistory(), {
+        columns: deps.columns(),
+        env: deps.env,
+        isTTY: true,
+        intervalSec: args.interval,
+      }),
+  );
 
   const onData = (chunk) => {
     if (isQuitKey(chunk)) quit = true;
@@ -82,7 +92,7 @@ export async function runDashboard(args, deps) {
     sampler = deps.sampler || createSampler();
     let history = createHistory();
     /** @type {import("./sample.js").Snapshot | null} */
-    let last = null;
+    let last = first;
 
     while (!shouldStop()) {
       let snap;

package/src/disk.js

@@ -87,10 +87,14 @@ export function createWindowsDiskReader() {
   }
 
   return {
+    start() {
+      ensure();
+    },
     /**
+     * @param {number} [timeoutMs]
      * @returns {Promise<ReturnType<typeof parseDiskCounterLine>>}
      */
-    read() {
+    read(timeoutMs = 400) {
       if (closed) return Promise.resolve(null);
       ensure();
       if (!child || !child.stdin.writable) return Promise.resolve(null);
@@ -99,7 +103,7 @@ export function createWindowsDiskReader() {
           const i = pending.findIndex((p) => p.resolve === done);
           if (i >= 0) pending.splice(i, 1);
           resolve(null);
-        }, 2500);
+        }, timeoutMs);
         const done = (v) => {
           clearTimeout(t);
           resolve(v);

package/src/diskuse.js

@@ -0,0 +1,103 @@
+const MIN_BYTES = 8 * 1024 * 1024 * 1024;
+
+const SKIP_FS =
+  /^(fat|fat12|fat16|fat32|msdos|nfs|smbfs|cifs|afp|webdav|fuse|sshfs|osxfuse|macfuse|tmpfs|devfs|autofs|iso9660|udf|overlay|9p)$/i;
+
+const SKIP_NAME =
+  /google\s*drive|gdrive|icloud|onedrive|dropbox|cloudstorage|cloudmounter|box\.com/i;
+
+const SKIP_MOUNT =
+  /^\/(System\/Volumes\/(Preboot|VM|Update|Recovery|iOS|hardware|xarts|cryptex)|\.MobileBackups|Volumes\/\.timemachine)/i;
+
+const LOCAL_FS = /^(ntfs|refs|apfs|hfs|hfs\+|ext[234]|xfs|btrfs|zfs)$/i;
+
+/**
+ * @param {{ fs?: string, type?: string, mount?: string, size?: number, used?: number }} row
+ */
+export function isLocalCapacityVolume(row) {
+  if (!row) return false;
+  const type = String(row.type || "");
+  const mount = String(row.mount || "");
+  const fs = String(row.fs || "");
+  const blob = `${type} ${mount} ${fs}`;
+  if (SKIP_NAME.test(blob)) return false;
+  if (SKIP_FS.test(type)) return false;
+  if (SKIP_MOUNT.test(mount)) return false;
+  const size = Number(row.size) || 0;
+  if (size < MIN_BYTES) return false;
+  if (LOCAL_FS.test(type)) return true;
+  if (/^[A-Z]:\\?$/i.test(mount || fs) && LOCAL_FS.test(type)) return true;
+  if (mount === "/" || mount === "/System/Volumes/Data") return true;
+  return false;
+}
+
+/**
+ * @param {string} mount
+ */
+export function shortMount(mount) {
+  const m = String(mount || "");
+  const drive = m.match(/^([A-Z]:)\\?$/i);
+  if (drive) return drive[1].toUpperCase();
+  if (m === "/System/Volumes/Data") return "Data";
+  if (m === "/") return "/";
+  const parts = m.split(/[/\\]/).filter(Boolean);
+  return parts[parts.length - 1] || m || "?";
+}
+
+/**
+ * @param {{ fs?: string, type?: string, mount?: string, size?: number, used?: number, use?: number }} row
+ */
+function systemScore(row) {
+  const m = String(row.mount || "");
+  if (/^C:\\?$/i.test(m)) return 3;
+  if (m === "/System/Volumes/Data") return 2;
+  if (m === "/") return 1;
+  return 0;
+}
+
+/**
+ * @param {Array<{ fs?: string, type?: string, mount?: string, size?: number, used?: number, use?: number }>} rows
+ * @returns {{ percent: number, used: number, total: number, mount: string, others: { percent: number, used: number, total: number, mount: string }[] } | null}
+ */
+export function summarizeLocalDisks(rows) {
+  const local = (Array.isArray(rows) ? rows : []).filter(isLocalCapacityVolume);
+  /** @type {typeof local} */
+  const uniq = [];
+  for (const r of local.slice().sort((a, b) => systemScore(b) - systemScore(a) || (b.size || 0) - (a.size || 0))) {
+    const dupIdx = uniq.findIndex(
+      (u) =>
+        Math.abs((u.size || 0) - (r.size || 0)) < 1024 * 1024 &&
+        Math.abs((u.used || 0) - (r.used || 0)) < 0.01 * (r.size || 1),
+    );
+    if (dupIdx >= 0) continue;
+    uniq.push(r);
+  }
+  if (!uniq.length) return null;
+  const primary = uniq[0];
+  const total = Number(primary.size) || 0;
+  const used = Number(primary.used) || 0;
+  const percent =
+    typeof primary.use === "number" && Number.isFinite(primary.use)
+      ? primary.use
+      : total > 0
+        ? (used / total) * 100
+        : 0;
+  return {
+    percent: Math.min(100, Math.max(0, percent)),
+    used,
+    total,
+    mount: shortMount(primary.mount || primary.fs || ""),
+    others: uniq.slice(1).map((r) => {
+      const t = Number(r.size) || 0;
+      const u = Number(r.used) || 0;
+      const p =
+        typeof r.use === "number" && Number.isFinite(r.use) ? r.use : t > 0 ? (u / t) * 100 : 0;
+      return {
+        percent: Math.min(100, Math.max(0, p)),
+        used: u,
+        total: t,
+        mount: shortMount(r.mount || r.fs || ""),
+      };
+    }),
+  };
+}

package/src/format.js

@@ -1,6 +1,7 @@
 const KIB = 1024;
 const MIB = 1024 * 1024;
 const GIB = 1024 * 1024 * 1024;
+const TIB = 1024 * 1024 * 1024 * 1024;
 
 /**
  * @param {number} bytes
@@ -8,6 +9,7 @@ const GIB = 1024 * 1024 * 1024;
 export function formatBytes(bytes) {
   const n = Number(bytes);
   if (!Number.isFinite(n) || n < 0) return "n/a";
+  if (n >= TIB) return `${(n / TIB).toFixed(1)} TiB`;
   if (n >= GIB) return `${(n / GIB).toFixed(1)} GiB`;
   return `${(n / MIB).toFixed(1)} MiB`;
 }
@@ -20,8 +22,8 @@ export function formatBytePair(used, total) {
   const t = Number(total);
   const u = Number(used);
   if (!Number.isFinite(t) || t < 0 || !Number.isFinite(u) || u < 0) return "n/a";
-  const unit = t >= GIB ? "GiB" : "MiB";
-  const div = unit === "GiB" ? GIB : MIB;
+  const unit = t >= TIB ? "TiB" : t >= GIB ? "GiB" : "MiB";
+  const div = unit === "TiB" ? TIB : unit === "GiB" ? GIB : MIB;
   return `${(u / div).toFixed(1)} / ${(t / div).toFixed(1)} ${unit}`;
 }
 

package/src/history.js

@@ -5,12 +5,15 @@ 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
+ * @property {number[]} diskUse
  */
 
 export function createHistory() {
-  return { cpu: [], ram: [], gpu: [], dsk: [], net: [] };
+  return { cpu: [], ram: [], gpu: [], dskR: [], dskW: [], netUp: [], netDn: [], diskUse: [] };
 }
 
 /**
@@ -33,26 +36,14 @@ 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),
+    diskUse: pushSample(history.diskUse, snap.diskUse?.percent),
   };
 }

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 {
@@ -115,6 +168,19 @@ export function renderFrame(snap, history, opts = {}) {
   }
   lines.push("");
 
+  if (snap.diskUse) {
+    lines.push(
+      `${color.green("USE")}  ${paintPercentBar(snap.diskUse.percent, color, "green", ascii)}  ${formatPercent(snap.diskUse.percent)}   ${formatBytePair(snap.diskUse.used, snap.diskUse.total)}  ${snap.diskUse.mount}`,
+    );
+    lines.push(`     ${color.green(sparkline(history.diskUse, sparkW, { ascii, max: 100 }))}`);
+    for (const extra of snap.diskUse.others || []) {
+      lines.push(
+        `     ${extra.mount}  ${formatPercent(extra.percent).trim()}   ${formatBytePair(extra.used, extra.total)}`,
+      );
+    }
+  }
+  if (snap.diskUse) lines.push("");
+
   const gpuLines = buildGpuRow(snap.gpu, {
     history: history.gpu,
     ascii,
@@ -130,10 +196,14 @@ 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("");
 
@@ -141,10 +211,14 @@ export function renderFrame(snap, history, opts = {}) {
     const up = formatBitRate(snap.net.txBps);
     const down = formatBitRate(snap.net.rxBps);
     lines.push(`${color.yellow("NET")}  ↑  ${up.padStart(12)}    ↓  ${down.padStart(12)}`);
-    lines.push(`     ${color.yellow(sparkline(history.net, sparkW, { ascii }))}`);
+    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

@@ -1,5 +1,6 @@
 import os from "node:os";
 import { createWindowsDiskReader } from "./disk.js";
+import { summarizeLocalDisks } from "./diskuse.js";
 import { rateFromCounters } from "./rates.js";
 
 /**
@@ -36,6 +37,7 @@ import { rateFromCounters } from "./rates.js";
  * @property {DiskSample | null} disk
  * @property {NetSample | null} net
  * @property {GpuSample | null} gpu
+ * @property {{ percent: number, used: number, total: number, mount: string, others: { percent: number, used: number, total: number, mount: string }[] } | null} diskUse
  */
 
 /**
@@ -82,6 +84,43 @@ function windowsLabel(release) {
   return "Windows";
 }
 
+/**
+ * Sync snapshot from `os` only — first paint must not wait on PowerShell / nvidia-smi.
+ * @returns {Snapshot}
+ */
+export function instantSnapshot() {
+  const logical = Math.max(os.cpus().length, 1);
+  const total = os.totalmem();
+  const free = os.freemem();
+  const used = Math.max(0, total - free);
+  return {
+    ts: Date.now(),
+    hostname: os.hostname(),
+    osName: shortOsName(null),
+    physical: logical,
+    logical,
+    ramTotal: total,
+    cpu: null,
+    ram: total > 0 ? { percent: Math.min(100, (used / total) * 100), used, total } : null,
+    disk: { readBps: null, writeBps: null },
+    net: { txBps: null, rxBps: null },
+    gpu: null,
+    diskUse: null,
+  };
+}
+
+function ramFromOs(ramTotal) {
+  const total = ramTotal || os.totalmem();
+  const free = os.freemem();
+  const used = Math.max(0, total - free);
+  if (total <= 0) return null;
+  return {
+    percent: Math.min(100, Math.max(0, (used / total) * 100)),
+    used,
+    total,
+  };
+}
+
 /**
  * GPU memory fields in systeminformation are sometimes MiB, sometimes bytes.
  * @param {number | null} n
@@ -139,6 +178,7 @@ export function mergeLastGood(last, next) {
     disk: null,
     net: null,
     gpu: null,
+    diskUse: null,
   };
   return {
     ts: next.ts,
@@ -152,6 +192,7 @@ export function mergeLastGood(last, next) {
     disk: mergePair(next.disk, base.disk, "readBps", "writeBps"),
     net: mergePair(next.net, base.net, "txBps", "rxBps"),
     gpu: next.gpu ?? base.gpu,
+    diskUse: next.diskUse ?? base.diskUse,
   };
 }
 
@@ -248,9 +289,29 @@ export function createSampler(si) {
   let prevTs = null;
   /** @type {Snapshot | null} */
   let last = null;
-  /** @type {Promise<{ hostname: string, osName: string, physical: number, logical: number, ramTotal: number }> | null} */
-  let staticP = null;
-  const winDisk = process.platform === "win32" ? createWindowsDiskReader() : null;
+  /** @type {{ hostname: string, osName: string, physical: number, logical: number, ramTotal: number }} */
+  let meta = (() => {
+    const s = instantSnapshot();
+    return {
+      hostname: s.hostname,
+      osName: s.osName,
+      physical: s.physical,
+      logical: s.logical,
+      ramTotal: s.ramTotal,
+    };
+  })();
+  let staticStarted = false;
+  /** @type {GpuSample | null} */
+  let gpuCache = null;
+  let gpuStarted = false;
+  /** @type {Snapshot["diskUse"]} */
+  let diskUseCache = null;
+  let diskUseStarted = false;
+  const win32 = process.platform === "win32";
+  const winDisk = win32 ? createWindowsDiskReader() : null;
+  winDisk?.start();
+  let winReady = false;
+  prevCpu = cpuIdleTotal(os.cpus());
 
   async function loadSi() {
     if (si) return si;
@@ -258,43 +319,27 @@ export function createSampler(si) {
     return mod.default ?? mod;
   }
 
-  async function loadStatic() {
-    const lib = await loadSi();
-    const hostname = os.hostname();
-    let osName = shortOsName(null);
-    let logical = Math.max(os.cpus().length, 1);
-    let physical = logical;
-    let ramTotal = os.totalmem();
-    try {
-      const info = await lib.osInfo();
-      osName = shortOsName(info);
-    } catch {
-      // keep fallback
-    }
-    try {
-      const cpu = await lib.cpu();
-      if (cpu?.physicalCores) physical = cpu.physicalCores;
-      if (cpu?.cores) logical = cpu.cores;
-    } catch {
-      // keep os.cpus() counts
-    }
-    try {
-      const mem = await lib.mem();
-      if (mem?.total) ramTotal = mem.total;
-    } catch {
-      // keep os.totalmem
-    }
-    return { hostname, osName, physical, logical, ramTotal };
+  function kickStatic(lib) {
+    if (staticStarted) return;
+    staticStarted = true;
+    (async () => {
+      try {
+        const info = await lib.osInfo();
+        meta = { ...meta, osName: shortOsName(info) };
+      } catch {
+        // keep fallback
+      }
+      try {
+        const cpu = await lib.cpu();
+        if (cpu?.physicalCores) meta = { ...meta, physical: cpu.physicalCores };
+        if (cpu?.cores) meta = { ...meta, logical: cpu.cores };
+      } catch {
+        // keep os.cpus() counts
+      }
+    })();
   }
 
-  async function sampleCpu(lib) {
-    try {
-      const load = await lib.currentLoad();
-      const pct = num(load?.currentLoad);
-      if (pct != null) return { percent: Math.min(100, Math.max(0, pct)) };
-    } catch {
-      // fall through to os.cpus() idle-delta
-    }
+  async function sampleCpu() {
     const curr = cpuIdleTotal(os.cpus());
     const pct = cpuPercentFromDelta(prevCpu, curr);
     prevCpu = curr;
@@ -303,6 +348,7 @@ export function createSampler(si) {
   }
 
   async function sampleRam(lib, ramTotal) {
+    if (win32) return ramFromOs(ramTotal);
     try {
       const mem = await lib.mem();
       const total = num(mem?.total) ?? ramTotal;
@@ -310,22 +356,14 @@ export function createSampler(si) {
       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;
+      if (used == null || total == null || total <= 0) return ramFromOs(ramTotal);
       return {
         percent: Math.min(100, Math.max(0, (used / total) * 100)),
         used,
         total,
       };
     } catch {
-      const total = ramTotal || os.totalmem();
-      const free = os.freemem();
-      const used = total - free;
-      if (total <= 0) return null;
-      return {
-        percent: Math.min(100, Math.max(0, (used / total) * 100)),
-        used,
-        total,
-      };
+      return ramFromOs(ramTotal);
     }
   }
 
@@ -336,13 +374,13 @@ export function createSampler(si) {
   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) {
+    if (rx == null && wx == null && !win32) {
       try {
         const fs = await lib.fsStats();
         rx = num(fs?.rx);
         wx = num(fs?.wx);
       } catch {
-        // Windows fsStats is always null
+        // ignore
       }
     }
     if (rx == null && wx == null) return { readBps: null, writeBps: null };
@@ -359,7 +397,7 @@ export function createSampler(si) {
   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) {
+    if (rx == null && tx == null && !win32) {
       try {
         const stats = await lib.networkStats("*");
         const summed = sumNetBytes(Array.isArray(stats) ? stats : stats ? [stats] : []);
@@ -375,13 +413,36 @@ export function createSampler(si) {
     return { txBps, rxBps };
   }
 
-  async function sampleGpu(lib) {
-    try {
-      const g = await lib.graphics();
-      return pickGpu(g?.controllers || []);
-    } catch {
-      return null;
-    }
+  function kickGpu(lib) {
+    if (gpuStarted) return;
+    gpuStarted = true;
+    lib
+      .graphics()
+      .then((g) => {
+        gpuCache = pickGpu(g?.controllers || []);
+      })
+      .catch(() => {
+        gpuCache = null;
+      })
+      .finally(() => {
+        gpuStarted = false;
+      });
+  }
+
+  function kickDiskUse(lib) {
+    if (diskUseStarted) return;
+    diskUseStarted = true;
+    lib
+      .fsSize()
+      .then((rows) => {
+        diskUseCache = summarizeLocalDisks(rows);
+      })
+      .catch(() => {})
+      .finally(() => {
+        setTimeout(() => {
+          diskUseStarted = false;
+        }, 15000);
+      });
   }
 
   return {
@@ -390,16 +451,17 @@ export function createSampler(si) {
      */
     async sample() {
       const lib = await loadSi();
-      if (!staticP) staticP = loadStatic();
-      const meta = await staticP;
-      const win = winDisk ? await winDisk.read().catch(() => null) : null;
+      kickStatic(lib);
+      kickGpu(lib);
+      kickDiskUse(lib);
+      const win = winDisk ? await winDisk.read(winReady ? 400 : 50).catch(() => null) : null;
+      if (win) winReady = true;
       const ts = Date.now();
-      const [cpu, ram, disk, net, gpu] = await Promise.all([
-        sampleCpu(lib).catch(() => last?.cpu ?? null),
+      const [cpu, ram, disk, net] = await Promise.all([
+        sampleCpu().catch(() => last?.cpu ?? null),
         sampleRam(lib, meta.ramTotal).catch(() => last?.ram ?? 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;
       const snap = mergeLastGood(last, {
@@ -409,7 +471,8 @@ export function createSampler(si) {
         ram,
         disk,
         net,
-        gpu,
+        gpu: gpuCache,
+        diskUse: diskUseCache,
       });
       last = snap;
       return snap;