@hienlh/ppm 0.23.5 → 0.23.7

package/src/services/system-metrics/net-devices-linux.ts

@@ -0,0 +1,114 @@
+/**
+ * Per-interface figures for the Performance page's network entries, from
+ * `/sys/class/net/<if>/`. Throughput is the same counter Mission Center reads
+ * (`statistics/rx_bytes`, `tx_bytes`); the link state comes from the kernel's
+ * own `operstate`/`carrier` rather than from NetworkManager, so it is right on a
+ * host that does not run NetworkManager at all.
+ */
+import type { NicMetrics, NicState } from "../../types/system-metrics.ts";
+import { readAttr, readNumber, realLinuxFs, type LinuxFs } from "./linux-fs.ts";
+
+export const SYS_NET = "/sys/class/net";
+/** ARPHRD_LOOPBACK. Mission Center drops interfaces named `lo*`; the type is exact. */
+const ARPHRD_LOOPBACK = 772;
+const IFF_UP = 0x1;
+
+export interface NicSample {
+  atSec: number;
+  rx: number;
+  tx: number;
+}
+
+/** Previous sample per interface name. */
+export type NicSampleState = Map<string, NicSample>;
+
+/** Live wireless facts for one interface; the collector takes them as data so it
+ *  never spawns anything itself. */
+export interface WirelessStatus {
+  ssid?: string;
+  signalPercent?: number;
+  frequencyMHz?: number;
+}
+
+export function listNetInterfaces(fs: Pick<LinuxFs, "list" | "read"> = realLinuxFs): string[] {
+  const names = fs.list(SYS_NET);
+  if (!names) return [];
+  return names.filter((n) => readNumber(fs, `${SYS_NET}/${n}/type`) !== ARPHRD_LOOPBACK).sort();
+}
+
+/** `operstate` is RFC 2863's, verbatim. `unknown` is what tun, wireguard and
+ *  other virtual interfaces report for their whole life, so those are decided by
+ *  carrier plus the admin flag instead. */
+export function nicState(
+  operstate: string | undefined,
+  carrier: string | undefined,
+  flags: string | undefined,
+): NicState {
+  switch (operstate) {
+    case "up": return "connected";
+    case "dormant":
+    case "testing": return "connecting";
+    case "down": return "disconnected";
+    case "notpresent":
+    case "lowerlayerdown": return "unavailable";
+    case "unknown": {
+      const up = (Number.parseInt(flags ?? "0", 16) & IFF_UP) !== 0;
+      return carrier === "1" && up ? "connected" : "unknown";
+    }
+    default: return "unknown";
+  }
+}
+
+export interface NicDeviceCollection {
+  nics: NicMetrics[];
+  next: NicSampleState;
+}
+
+export function collectLinuxNicDevices(
+  prev: NicSampleState,
+  fs: Pick<LinuxFs, "list" | "read"> = realLinuxFs,
+  now: () => number = Date.now,
+  wireless: ReadonlyMap<string, WirelessStatus> = new Map(),
+): NicDeviceCollection {
+  const atSec = now() / 1000;
+  const next: NicSampleState = new Map();
+  const nics: NicMetrics[] = [];
+
+  for (const id of listNetInterfaces(fs)) {
+    const rx = readNumber(fs, `${SYS_NET}/${id}/statistics/rx_bytes`);
+    const tx = readNumber(fs, `${SYS_NET}/${id}/statistics/tx_bytes`);
+    if (rx === undefined || tx === undefined) continue;
+    const sample: NicSample = { atSec, rx, tx };
+    next.set(id, sample);
+
+    // `speed` is -1 with no link, and reading it EINVALs on a virtual interface.
+    const speed = readNumber(fs, `${SYS_NET}/${id}/speed`);
+    nics.push({
+      ...toNicMetrics(id, prev.get(id) ?? null, sample),
+      state: nicState(
+        readAttr(fs, `${SYS_NET}/${id}/operstate`),
+        readAttr(fs, `${SYS_NET}/${id}/carrier`),
+        readAttr(fs, `${SYS_NET}/${id}/flags`),
+      ),
+      ...(speed !== undefined && speed > 0 ? { linkMbps: speed } : {}),
+      ...(wireless.get(id) ?? {}),
+    });
+  }
+  return { nics, next };
+}
+
+/** Rates only — the caller adds state and link facts. */
+export function toNicMetrics(id: string, prev: NicSample | null, next: NicSample): NicMetrics {
+  const base: NicMetrics = {
+    id, available: false, rxBps: 0, txBps: 0, rxTotal: next.rx, txTotal: next.tx, state: "unknown",
+  };
+  const dt = prev ? next.atSec - prev.atSec : 0;
+  // The kernel zeroes these when an interface is recreated under the same name.
+  if (!prev || !Number.isFinite(dt) || dt <= 0 || next.rx < prev.rx || next.tx < prev.tx) return base;
+  return {
+    ...base,
+    available: true,
+    rxBps: Math.round((next.rx - prev.rx) / dt),
+    txBps: Math.round((next.tx - prev.tx) / dt),
+  };
+}

package/src/services/system-metrics/net-inventory-linux.ts

@@ -0,0 +1,100 @@
+/**
+ * Static facts about each network interface: what kind it is, the adapter's
+ * marketing name, its driver, MAC and addresses.
+ *
+ * Mission Center classifies by NetworkManager's device type and falls back to a
+ * table of name prefixes — and its type read always fails (it asks for a u64
+ * where NM publishes a u32), so in practice the prefix table is all that ever
+ * runs. PPM asks sysfs and udev first, which are exact, and keeps that same
+ * prefix table only as the last resort.
+ */
+import { networkInterfaces } from "node:os";
+import type { NicInfo, NicKind } from "../../types/system-hardware.ts";
+import { readAttr, readNumber, realLinuxFs, type LinuxFs } from "./linux-fs.ts";
+import { readUdevProperties, udevValue } from "./udev-db.ts";
+import { listNetInterfaces, SYS_NET } from "./net-devices-linux.ts";
+
+const ARPHRD_INFINIBAND = 32;
+/** `tun_flags` bit 0: a TUN (layer 3) device, i.e. a tunnel rather than a tap. */
+const IFF_TUN = 0x1;
+
+export function readNicInventory(
+  fs: LinuxFs = realLinuxFs,
+  addresses: () => AddressMap = readAddresses,
+): NicInfo[] {
+  const addrs = addresses();
+  return listNetInterfaces(fs).map((id) => readNicInfo(id, fs, addrs[id]));
+}
+
+export function readNicInfo(id: string, fs: LinuxFs, addr: Addresses | undefined): NicInfo {
+  const udev = readUdevProperties(`n${readAttr(fs, `${SYS_NET}/${id}/ifindex`) ?? ""}`, fs.read);
+  const driver = udevValue(udev, "ID_NET_DRIVER")
+    ?? basename(fs.readlink(`${SYS_NET}/${id}/device/driver`) ?? "");
+
+  return {
+    id,
+    kind: nicKind(id, fs),
+    ...optional("deviceName", udevValue(udev, "ID_MODEL_FROM_DATABASE")),
+    ...optional("driver", driver || undefined),
+    ...optional("mac", readAttr(fs, `${SYS_NET}/${id}/address`)),
+    ipv4: addr?.ipv4 ?? [],
+    ipv6: addr?.ipv6 ?? [],
+  };
+}
+
+/** sysfs facts first, Mission Center's prefix table only when none of them apply. */
+export function nicKind(id: string, fs: Pick<LinuxFs, "read" | "exists">): NicKind {
+  const devtype = uevent(fs, id).get("DEVTYPE");
+  if (devtype === "wireguard") return "vpn";
+  if (devtype === "wlan" || fs.exists(`${SYS_NET}/${id}/wireless`)) return "wireless";
+  if (readNumber(fs, `${SYS_NET}/${id}/type`) === ARPHRD_INFINIBAND) return "infiniband";
+  if (devtype === "bridge") return id.startsWith("docker") ? "docker" : "bridge";
+  // A TUN device is a tunnel by construction — Mission Center has no rule for
+  // these and files every one of them (tailscale0, tun0, nordlynx) under "other".
+  const tunFlags = readAttr(fs, `${SYS_NET}/${id}/tun_flags`);
+  if (tunFlags && (Number.parseInt(tunFlags, 16) & IFF_TUN) !== 0) return "vpn";
+  return kindFromName(id);
+}
+
+/** Mission Center's `connection_kind_from_name`, order included. */
+export function kindFromName(id: string): NicKind {
+  if (id.startsWith("bn")) return "bluetooth";
+  if (id.startsWith("br") || id.startsWith("virbr")) return "bridge";
+  if (id.startsWith("docker")) return "docker";
+  if (id.startsWith("eth") || id.startsWith("en")) return "wired";
+  if (id.startsWith("ib")) return "infiniband";
+  if (id.startsWith("mp")) return "multipass";
+  if (id.startsWith("veth")) return "virtual";
+  if (id.startsWith("vpn") || id.startsWith("wg")) return "vpn";
+  if (id.startsWith("wl") || id.startsWith("ww")) return "wireless";
+  return "other";
+}
+
+function uevent(fs: Pick<LinuxFs, "read">, id: string): Map<string, string> {
+  const props = new Map<string, string>();
+  for (const line of (fs.read(`${SYS_NET}/${id}/uevent`) ?? "").split("\n")) {
+    const eq = line.indexOf("=");
+    if (eq > 0) props.set(line.slice(0, eq), line.slice(eq + 1).trim());
+  }
+  return props;
+}
+
+export interface Addresses { ipv4: string[]; ipv6: string[] }
+export type AddressMap = Record<string, Addresses>;
+
+export function readAddresses(): AddressMap {
+  const map: AddressMap = {};
+  for (const [name, addrs] of Object.entries(networkInterfaces())) {
+    for (const a of addrs ?? []) {
+      const entry = (map[name] ??= { ipv4: [], ipv6: [] });
+      (a.family === "IPv4" ? entry.ipv4 : entry.ipv6).push(a.address);
+    }
+  }
+  return map;
+}
+
+const basename = (p: string) => p.slice(p.lastIndexOf("/") + 1);
+
+function optional<K extends string>(key: K, value: string | undefined): Partial<Record<K, string>> {
+  return value === undefined ? {} : ({ [key]: value } as Record<K, string>);
+}

package/src/services/system-metrics/partitions-linux.ts

@@ -0,0 +1,158 @@
+/**
+ * Partitions of a whole disk, with what is mounted on them and how full it is —
+ * Mission Center's Partitions section on the drive page.
+ *
+ * Mission Center asks udisks2 over D-Bus. This reads sysfs for the partition
+ * list, `/proc/self/mountinfo` for the mounts and `statfs` for the usage, so it
+ * needs neither a system bus nor root.
+ *
+ * The usage figures are read with the ASYNC `statfs`, deliberately: PPM serves
+ * every request and every chat session from one event loop, and `statfsSync` on
+ * a mount whose device is spinning up (or an autofs mount that is cold) blocks
+ * that loop for as long as the kernel takes. It is also why this is not on the
+ * 2 s tick — it belongs to the inventory, which is fetched on demand.
+ */
+import type { DiskInfo, PartitionInfo, PartitionMount } from "../../types/system-hardware.ts";
+import { readAttr, readNumber, realLinuxFs, type LinuxFs } from "./linux-fs.ts";
+import { readUdevProperties, udevValue } from "./udev-db.ts";
+import { SYS_BLOCK } from "./disk-devices-linux.ts";
+
+const SECTOR_BYTES = 512;
+const MOUNTINFO = "/proc/self/mountinfo";
+
+/** One mount as `/proc/self/mountinfo` describes it. */
+export interface MountEntry {
+  /** mountinfo's major:minor. For ext4 this is the block device's own, but a
+   *  filesystem that can span devices registers an ANONYMOUS one instead — every
+   *  btrfs mount on this host reports `0:35` rather than `259:2` — so this alone
+   *  finds no mount at all on a btrfs root, which is most Arch installs. */
+  deviceId: string;
+  /** The device as the kernel records it, "/dev/nvme0n1p2". This is what matches
+   *  a btrfs partition; `deviceId` is what still matches when the source is a
+   *  label or a stacked device. Both are needed. */
+  source: string;
+  /** Which part of the filesystem is mounted: "/" for the whole thing, "/@home"
+   *  for a btrfs subvolume, a directory for a bind mount. */
+  root: string;
+  mountPoint: string;
+  filesystem: string;
+}
+
+/**
+ * mountinfo's variable-length optional-fields group ends at a literal `-`, so the
+ * tail cannot be indexed from the start of the line. Splitting on the separator
+ * first is what makes `fstype` findable at all.
+ *
+ * Paths are escaped by the kernel — a mount under `/mnt/my drive` arrives as
+ * `/mnt/my\040drive`, and leaving it that way means the statfs below fails on
+ * exactly the mounts whose names have spaces.
+ */
+export function parseMountInfo(text: string): MountEntry[] {
+  const out: MountEntry[] = [];
+  for (const line of text.split("\n")) {
+    const sep = line.indexOf(" - ");
+    if (sep < 0) continue;
+    const head = line.slice(0, sep).split(" ");
+    const tail = line.slice(sep + 3).split(" ");
+    const deviceId = head[2];
+    const root = head[3];
+    const mountPoint = head[4];
+    const filesystem = tail[0];
+    if (!deviceId || !root || !mountPoint || !filesystem) continue;
+    out.push({
+      deviceId,
+      source: unescapeMountPath(tail[1] ?? ""),
+      root: unescapeMountPath(root),
+      mountPoint: unescapeMountPath(mountPoint),
+      filesystem,
+    });
+  }
+  return out;
+}
+
+/** The four sequences the kernel escapes: space, tab, newline, backslash. */
+export function unescapeMountPath(path: string): string {
+  return path.replace(/\\(040|011|012|134)/g, (_, code) =>
+    ({ "040": " ", "011": "\t", "012": "\n", "134": "\\" })[code as string] ?? _);
+}
+
+/** Partition directories of a whole disk: sysfs nests them under the disk and
+ *  marks each with a `partition` attribute, which is what tells `sda1` apart from
+ *  `queue` or `holders`. */
+export function listPartitions(diskId: string, fs: LinuxFs = realLinuxFs): string[] {
+  return (fs.list(`${SYS_BLOCK}/${diskId}`) ?? [])
+    .filter((name) => fs.exists(`${SYS_BLOCK}/${diskId}/${name}/partition`))
+    .sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+}
+
+/** The static half: everything but the usage, which needs a syscall per mount. */
+export function readPartitions(
+  diskId: string,
+  fs: LinuxFs = realLinuxFs,
+  mounts: MountEntry[] = parseMountInfo(fs.read(MOUNTINFO) ?? ""),
+): PartitionInfo[] {
+  return listPartitions(diskId, fs).map((id) => {
+    const base = `${SYS_BLOCK}/${diskId}/${id}`;
+    const deviceId = readAttr(fs, `${base}/dev`);
+    const udev = readUdevProperties(deviceId ? `b${deviceId}` : "", fs.read);
+    const sectors = readNumber(fs, `${base}/size`) ?? 0;
+    const devicePath = `/dev/${id}`;
+    const mine = mounts.filter((m) => (deviceId && m.deviceId === deviceId) || m.source === devicePath);
+    // udev knows the type even for a partition nothing has mounted, which is the
+    // case the mountinfo scan cannot answer at all.
+    const filesystem = udevValue(udev, "ID_FS_TYPE") ?? mine[0]?.filesystem;
+    return {
+      id,
+      devicePath,
+      sizeBytes: sectors * SECTOR_BYTES,
+      ...(filesystem ? { filesystem } : {}),
+      mounts: mine.map((m) => ({ mountPoint: m.mountPoint, filesystem: m.filesystem })),
+    };
+  });
+}
+
+export type StatfsReader = (path: string) => Promise<{ blocks: number; bavail: number; bfree: number; bsize: number }>;
+
+const realStatfs: StatfsReader = async (path) => {
+  const { statfs } = await import("node:fs/promises");
+  return statfs(path) as unknown as ReturnType<StatfsReader> extends Promise<infer T> ? T : never;
+};
+
+/**
+ * `used` is computed against the blocks a non-root user may actually have, not
+ * against the total: ext4 reserves 5% for root, so `blocks - bfree` reports a
+ * fresh filesystem as several percent full while `df` says 1%. This is `df`'s own
+ * arithmetic — total is what you can use plus what is used.
+ */
+export function usageFromStatfs(s: { blocks: number; bavail: number; bfree: number; bsize: number }): PartitionMount {
+  const used = (s.blocks - s.bfree) * s.bsize;
+  const total = used + s.bavail * s.bsize;
+  return { mountPoint: "", filesystem: "", usedBytes: used, totalBytes: total };
+}
+
+/**
+ * Fills in every mount's usage, in parallel. A mount that refuses is left with no
+ * figures rather than zeroes — an unreadable filesystem is not an empty one.
+ */
+export async function attachPartitionUsage(
+  disks: DiskInfo[],
+  statfs: StatfsReader = realStatfs,
+): Promise<void> {
+  const jobs: Promise<void>[] = [];
+  for (const disk of disks) {
+    for (const part of disk.partitions ?? []) {
+      for (const mount of part.mounts) {
+        jobs.push(
+          statfs(mount.mountPoint)
+            .then((s) => {
+              const { usedBytes, totalBytes } = usageFromStatfs(s);
+              mount.usedBytes = usedBytes;
+              mount.totalBytes = totalBytes;
+            })
+            .catch(() => {}),
+        );
+      }
+    }
+  }
+  await Promise.all(jobs);
+}

package/src/services/system-metrics/process-collector-linux.ts

@@ -4,14 +4,20 @@
  * already anchors the `/proc/<pid>/stat` parse on the last `)` so a process
  * name containing spaces cannot shift the fields.
  *
- * Per-process VRAM needs the one `nvidia-smi` call; per-process GPU busy % has
- * no unprivileged source at all, so `gpuPct` stays undefined here.
+ * Per-process VRAM needs the one `nvidia-smi` call. Per-process GPU busy % comes
+ * from DRM fdinfo where the driver publishes it (Intel, AMD) — the proprietary
+ * NVIDIA driver publishes neither, so an NVIDIA-only host still fills memory
+ * alone.
  */
 import { readProcTable, type ProcEntry } from "../proc-table-linux.ts";
 import type { ProcessCollection, ProcessCollector, RawProcessRow } from "./process-collector-types.ts";
 import { createStickyColumns } from "./process-collector-types.ts";
 import { readProcIoBytes, type ProcIoBytes } from "./process-io-linux.ts";
+import { readProcSwapMB } from "./process-swap-linux.ts";
+import { realLinuxFs } from "./linux-fs.ts";
+import { serviceKeyFromCgroup } from "../system-services/app-cgroup-linux.ts";
 import type { ProcessGpuMemoryCollector } from "./gpu-process-memory-nvidia.ts";
+import type { DrmGpuCollector } from "./gpu-fdinfo-linux.ts";
 
 const KB_PER_MB = 1024;
 
@@ -36,10 +42,20 @@ export function procEntriesToRows(entries: readonly ProcEntry[]): RawProcessRow[
 export interface LinuxProcessCollectorOptions {
   /** Injected so unit tests never touch a real `/proc`. */
   readIo?: (pid: number) => ProcIoBytes | null;
+  /** `VmSwap` for one pid, MB. Null = gone or unreadable. */
+  readSwap?: (pid: number) => number | null;
+  /** `/proc/<pid>/cgroup` for one pid, used only to name its systemd unit. */
+  readCgroup?: (pid: number) => string | null;
+  /** Whose `systemctl --user` the Services page is reading. Defaults to this
+   *  process's own uid. */
+  selfUid?: number;
   /** Omitted or null → no per-process VRAM query at all. The production wiring
    *  in `system-metrics-platform.ts` injects it; defaulting to a real collector
    *  here would make an innocent unit test spawn `nvidia-smi`. */
   gpuMemory?: ProcessGpuMemoryCollector | null;
+  /** Shared with the whole-GPU collector: it memoises one `/proc` walk per tick,
+   *  so whichever of the two asks first pays for it and both see the same numbers. */
+  drm?: DrmGpuCollector | null;
 }
 
 export function createLinuxProcessCollector(
@@ -47,7 +63,17 @@ export function createLinuxProcessCollector(
   opts: LinuxProcessCollectorOptions = {},
 ): ProcessCollector {
   const readIo = opts.readIo ?? readProcIoBytes;
+  const readSwap = opts.readSwap ?? readProcSwapMB;
+  // The Apps page reads the same file under a DIFFERENT rule (it wants the
+  // outermost app unit, this wants the innermost unit of any kind), so the two
+  // cannot share one read without one of them getting the wrong answer. 1.3 ms
+  // for 561 pids, measured on this host.
+  const readCgroup = opts.readCgroup ?? ((pid: number) => realLinuxFs.read(`/proc/${pid}/cgroup`));
+  // Which user manager is "ours" — a unit of another uid is not on the Services
+  // page at all, so its processes must not land on our same-named row.
+  const selfUid = opts.selfUid ?? process.getuid?.() ?? 0;
   const gpuMemory = opts.gpuMemory ?? null;
+  const drm = opts.drm ?? null;
   const observeColumns = createStickyColumns();
 
   return {
@@ -58,28 +84,54 @@ export function createLinuxProcessCollector(
         return { rows: [], columns: observeColumns({}), warnings: ["Process list unavailable: /proc is not readable"] };
       }
       const gpuMemByPid = (await gpuMemory?.collect()) ?? null;
+      const drmByPid = drm?.usage().perProcess ?? null;
 
       let anyIo = false;
+      let anySwap = false;
       const rows = procEntriesToRows(table).map((r) => {
         // EACCES for another user's process is expected, not an error: that row
         // simply has no disk figures.
         const io = readIo(r.pid);
         if (io) anyIo = true;
+        // Both sources list only the processes actually using the GPU, so a
+        // missing pid means "measured, holding none" — not "unknown".
+        const drmRow = drmByPid?.get(r.pid);
+        const nvidiaMem = gpuMemByPid ? gpuMemByPid.get(r.pid) ?? 0 : undefined;
+        const drmMem = drmByPid ? (drmRow ? drmRow.vramMB + drmRow.sharedMB : 0) : undefined;
+        // A process that exited between the table read and now has neither; both
+        // stay absent for that row rather than being reported as zero.
+        const swapMB = readSwap(r.pid);
+        if (swapMB !== null) anySwap = true;
+        const unitKey = serviceKeyFromCgroup(readCgroup(r.pid) ?? "", selfUid);
         return {
           ...r,
+          ...(swapMB === null ? {} : { swapMB }),
+          ...(unitKey === null ? {} : { unitKey }),
           diskReadBytes: io?.readBytes,
           diskWriteBytes: io?.writeBytes,
-          // The query lists only processes holding VRAM, so a missing pid means
-          // "measured, holding none".
-          gpuMemMB: gpuMemByPid ? gpuMemByPid.get(r.pid) ?? 0 : undefined,
+          ...(drmByPid ? { gpuPct: drmRow?.gpuPct ?? 0 } : {}),
+          gpuMemMB: sumDefined(nvidiaMem, drmMem),
         };
       });
 
       return {
         rows,
-        columns: observeColumns({ disk: anyIo, gpu: gpuMemByPid !== null }),
+        columns: observeColumns({
+          disk: anyIo,
+          gpu: gpuMemByPid !== null || drmByPid !== null,
+          swap: anySwap,
+        }),
         warnings: [],
       };
     },
   };
 }
+
+/** Undefined only when NEITHER source measured anything — a host with one of the
+ *  two must not report "unknown" for a figure it really does have. */
+function sumDefined(a: number | undefined, b: number | undefined): number | undefined {
+  if (a === undefined && b === undefined) return undefined;
+  return round1((a ?? 0) + (b ?? 0));
+}
+
+const round1 = (n: number) => Math.round(n * 10) / 10;

package/src/services/system-metrics/process-collector-types.ts

@@ -13,6 +13,12 @@ export interface RawProcessRow {
   /** Cumulative CPU time (user + kernel), milliseconds. */
   cpuMs: number;
   ramMB: number;
+  /** Swapped-out anonymous memory, MB. `undefined` = this OS has no per-process
+   *  source; 0 is a real reading (a kernel thread has no address space). */
+  swapMB?: number;
+  /** `"<scope>:<unit>"` — which Services row owns this pid. Absent off systemd,
+   *  for a pid in no unit, and for another user's units. */
+  unitKey?: string;
   /** Epoch ms UTC; 0 when unknown. */
   startedAt: number;
   /** CUMULATIVE per-process byte counters. The rows builder turns them into
@@ -49,7 +55,7 @@ export interface ProcessCollector {
 
 /** Frozen: it is shared by every light-tier snapshot, so an accidental mutation
  *  would rewrite history for all of them. */
-export const NO_PROCESS_COLUMNS: ProcessColumnAvailability = Object.freeze({ disk: false, gpu: false, net: false });
+export const NO_PROCESS_COLUMNS: ProcessColumnAvailability = Object.freeze({ disk: false, gpu: false, net: false, swap: false });
 
 /**
  * Sticky column availability. A capability is advertised as soon as it has
@@ -64,6 +70,7 @@ export function createStickyColumns(): (seen: Partial<ProcessColumnAvailability>
     state.disk ||= seen.disk === true;
     state.gpu ||= seen.gpu === true;
     state.net ||= seen.net === true;
+    state.swap ||= seen.swap === true;
     return { ...state };
   };
 }