@axium/sysadmin 0.2.6 → 0.3.0

package/dist/client/cli.js

@@ -9,6 +9,9 @@ import './socket.js';
 function usage(info) {
     return styleText('blueBright', formatBytes(info.used)) + '/' + styleText('blueBright', formatBytes(info.total));
 }
+function drive(device) {
+    return styleText('blueBright', formatBytes(device.size)) + (device.interface ? ' ' + styleText('dim', device.interface) : '');
+}
 const num = (value) => value === undefined ? styleText('red', '<unknown>') : styleText('blueBright', value.toString());
 const tab = '   ', tab2 = '       ';
 function dumpInfo(system, info) {
@@ -26,9 +29,19 @@ function dumpInfo(system, info) {
     console.log('Memory:', usage(memory));
     if (memory.swap)
         console.log(tab, 'Swap:', usage(memory.swap));
+    const models = new Map(storage.devices.map(device => [device.name, device]));
     console.log('Storage:');
-    for (const drive of storage)
-        console.log(tab, styleText('yellow', drive.model), usage(drive));
+    for (const volume of storage.volumes) {
+        const labels = [volume.filesystem, ...(volume.profile ? [volume.profile.toUpperCase()] : [])];
+        console.log(tab, styleText('cyanBright', volume.mountPoints.join(' ')), styleText('dim', labels.join(' ')), usage(volume));
+        for (const name of volume.devices) {
+            const device = models.get(name);
+            console.log(tab2, styleText('yellow', device?.model ?? name), device ? drive(device) : '');
+        }
+    }
+    for (const device of storage.devices.filter(d => storage.volumes.every(v => !v.devices.includes(d.name)))) {
+        console.log(tab, styleText('yellow', device.model), drive(device), styleText('dim', '(unused)'));
+    }
     console.log('Network:');
     for (const iface of networkInterfaces) {
         console.log(tab, styleText('cyanBright', iface.name), styleText('yellow', iface.model), iface.wireless ? '(wireless)' : '(wired)');

package/dist/client/info.js

@@ -1,6 +1,7 @@
 import { execFileSync } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
+import * as path from 'node:path';
 /** Read a sysfs/procfs file, returning the trimmed contents or undefined if unreadable. */
 function read(path) {
     try {
@@ -64,16 +65,148 @@ function gpus() {
     }
     return result;
 }
-/** Map mounted block devices to the filesystem usage (bytes) of their mount point. */
-function mountUsage() {
-    const usage = new Map();
+/** PCIe generations by their per-lane transfer rate in GT/s, as reported by `current_link_speed`. */
+const pcieGenerations = {
+    '2.5': '1.0',
+    '5.0': '2.0',
+    '8.0': '3.0',
+    '16.0': '4.0',
+    '32.0': '5.0',
+    '64.0': '6.0',
+    '128.0': '7.0',
+};
+/** Format a link rate given in Mbit/s, e.g. 10000 -> '10 Gbps'. */
+function formatLinkRate(mbps) {
+    return mbps >= 1000 ? `${(mbps / 1000).toFixed(1).replace(/\.0$/, '')} Gbps` : `${mbps} Mbps`;
+}
+/** The SATA link speed of an `ataN` device directory, e.g. '6.0 Gbps'. */
+function sataSpeed(ata) {
+    for (const link of list(ata)) {
+        if (!link.startsWith('link'))
+            continue;
+        for (const classLink of list(`${ata}/${link}/ata_link`)) {
+            const speed = read(`${ata}/${link}/ata_link/${classLink}/sata_spd`);
+            // Reported as `<unknown>` for PATA links and for ports with nothing negotiated.
+            if (speed && !speed.startsWith('<'))
+                return speed;
+        }
+    }
+}
+/** How a disk is attached, e.g. 'PCIe 4.0 x4', 'SATA 6.0 Gbps' or 'USB 10 Gbps'. */
+function diskInterface(dev) {
+    let dir;
+    try {
+        dir = fs.realpathSync(`/sys/block/${dev}/device`);
+    }
+    catch {
+        return undefined;
+    }
+    // Walk toward the root of the device tree; the nearest bus we recognize is the one the disk hangs off.
+    for (; dir.startsWith('/sys/devices/'); dir = path.dirname(dir)) {
+        const name = path.basename(dir);
+        if (/^ata\d+$/.test(name)) {
+            const speed = sataSpeed(dir);
+            return speed ? `SATA ${speed}` : 'SATA';
+        }
+        // PCI(e) endpoints expose the negotiated link; `current_link_speed` is like `16.0 GT/s PCIe`.
+        const link = read(`${dir}/current_link_speed`);
+        if (link) {
+            const rate = link.split(' ')[0];
+            const generation = pcieGenerations[Number(rate).toFixed(1)];
+            const width = read(`${dir}/current_link_width`);
+            return `PCIe ${generation ?? `${rate} GT/s`}${width && width !== '0' ? ` x${width}` : ''}`;
+        }
+        // USB devices (as opposed to their interfaces) carry the descriptor fields; `speed` is in Mbit/s.
+        if (fs.existsSync(`${dir}/idVendor`)) {
+            const speed = Number(read(`${dir}/speed`));
+            return speed > 0 ? `USB ${formatLinkRate(speed)}` : 'USB';
+        }
+    }
+}
+function devices() {
+    const result = [];
+    for (const name of list('/sys/block')) {
+        // Skip virtual devices (zram, loop, device-mapper, MD) which have no backing `device`.
+        if (!fs.existsSync(`/sys/block/${name}/device`))
+            continue;
+        const sectors = read(`/sys/block/${name}/size`);
+        if (!sectors)
+            continue;
+        result.push({
+            name,
+            model: read(`/sys/block/${name}/device/model`)?.trim() || name,
+            size: BigInt(sectors) * 512n,
+            interface: diskInterface(name),
+            rotational: read(`/sys/block/${name}/queue/rotational`) === '1',
+            removable: read(`/sys/block/${name}/removable`) === '1',
+        });
+    }
+    return result.sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Resolve a block device to the physical disks backing it, recursing through `slaves` so
+ * device-mapper (LVM, LUKS) and MD stacks resolve to real hardware rather than virtual devices.
+ */
+function physicalDisks(dev, into = new Set()) {
+    if (fs.existsSync(`/sys/class/block/${dev}/partition`)) {
+        // Partitions live inside their disk's directory: `.../nvme0n1/nvme0n1p3`.
+        try {
+            return physicalDisks(path.basename(path.dirname(fs.realpathSync(`/sys/class/block/${dev}`))), into);
+        }
+        catch {
+            return into;
+        }
+    }
+    if (fs.existsSync(`/sys/block/${dev}/device`))
+        into.add(dev);
+    else
+        for (const slave of list(`/sys/block/${dev}/slaves`))
+            physicalDisks(slave, into);
+    return into;
+}
+/** BTRFS filesystems keyed by each of their member devices. The kernel is the only source that knows all members. */
+function btrfsFilesystems() {
+    const result = new Map();
+    for (const fsid of list('/sys/fs/btrfs')) {
+        const devices = list(`/sys/fs/btrfs/${fsid}/devices`);
+        if (!devices.length)
+            continue;
+        // `allocation/data` holds a directory per chunk profile in use alongside its counter files.
+        const profile = list(`/sys/fs/btrfs/${fsid}/allocation/data`).find(entry => /^(single|dup|raid\d+(c\d+)?)$/.test(entry));
+        const info = { fsid, devices, profile: profile === 'single' ? undefined : profile };
+        for (const dev of devices)
+            result.set(dev, info);
+    }
+    return result;
+}
+function volumes() {
     const mounts = read('/proc/mounts');
     if (!mounts)
-        return usage;
+        return [];
+    const btrfs = btrfsFilesystems();
+    // Several mount points can share one filesystem (BTRFS subvolumes, bind mounts); they are one volume.
+    const byFilesystem = new Map();
     for (const line of mounts.split('\n')) {
-        const [source, mountPoint] = line.split(' ');
+        const [source, rawMountPoint, filesystem] = line.split(' ');
         if (!source?.startsWith('/dev/'))
             continue;
+        // /proc/mounts octal-escapes characters that would otherwise break the field separators.
+        const mountPoint = rawMountPoint.replace(/\\(\d{3})/g, (_, code) => String.fromCharCode(parseInt(code, 8)));
+        let dev;
+        try {
+            // The source may be a symlink, e.g. /dev/mapper/foo -> /dev/dm-0.
+            dev = fs.realpathSync(source).slice('/dev/'.length);
+        }
+        catch {
+            continue;
+        }
+        const btrfsInfo = btrfs.get(dev);
+        const existing = byFilesystem.get(btrfsInfo?.fsid ?? dev);
+        if (existing) {
+            if (!existing.mountPoints.includes(mountPoint))
+                existing.mountPoints.push(mountPoint);
+            continue;
+        }
         let stat;
         try {
             stat = fs.statfsSync(mountPoint, { bigint: true });
@@ -81,35 +214,25 @@ function mountUsage() {
         catch {
             continue;
         }
-        const total = stat.blocks * stat.bsize;
-        const used = (stat.blocks - stat.bfree) * stat.bsize;
-        usage.set(source.slice('/dev/'.length), { total, used });
+        // BTRFS tracks its own members; anything else spanning devices does so through MD or device-mapper.
+        const devices = new Set();
+        for (const member of btrfsInfo?.devices ?? [dev])
+            physicalDisks(member, devices);
+        if (!devices.size)
+            continue;
+        byFilesystem.set(btrfsInfo?.fsid ?? dev, {
+            mountPoints: [mountPoint],
+            filesystem,
+            devices: [...devices].sort((a, b) => a.localeCompare(b)),
+            profile: btrfsInfo?.profile ?? read(`/sys/block/${dev}/md/level`),
+            total: stat.blocks * stat.bsize,
+            used: (stat.blocks - stat.bfree) * stat.bsize,
+        });
     }
-    return usage;
+    return [...byFilesystem.values()].sort((a, b) => a.mountPoints[0].localeCompare(b.mountPoints[0]));
 }
 function storage() {
-    const usage = mountUsage();
-    const result = [];
-    for (const dev of list('/sys/block')) {
-        // Skip virtual devices (zram, loop, device-mapper) which have no backing `device`.
-        if (!fs.existsSync(`/sys/block/${dev}/device`))
-            continue;
-        const sectors = read(`/sys/block/${dev}/size`);
-        if (!sectors)
-            continue;
-        // `size` is always in 512-byte sectors regardless of logical block size.
-        const total = BigInt(sectors) * 512n;
-        // Sum filesystem usage across mounted partitions of this disk.
-        let used = 0n;
-        for (const [mounted, info] of usage) {
-            if (mounted === dev || mounted.startsWith(dev + 'p') || (mounted.startsWith(dev) && /\d$/.test(mounted))) {
-                used += info.used;
-            }
-        }
-        const model = read(`/sys/block/${dev}/device/model`)?.trim() || dev;
-        result.push({ model, total, used });
-    }
-    return result;
+    return { devices: devices(), volumes: volumes() };
 }
 let dmiMemory;
 /** Static memory hardware details from DMI. */

package/dist/common.d.ts

@@ -343,11 +343,24 @@ declare const SysadminClientToServer: {
             total: z.ZodCoercedBigInt<unknown>;
             used: z.ZodCoercedBigInt<unknown>;
         }, z.core.$strip>;
-        storage: z.ZodArray<z.ZodObject<{
-            model: z.ZodString;
-            total: z.ZodCoercedBigInt<unknown>;
-            used: z.ZodCoercedBigInt<unknown>;
-        }, z.core.$strip>>;
+        storage: z.ZodObject<{
+            devices: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                model: z.ZodString;
+                size: z.ZodCoercedBigInt<unknown>;
+                interface: z.ZodOptional<z.ZodString>;
+                rotational: z.ZodBoolean;
+                removable: z.ZodBoolean;
+            }, z.core.$strip>>;
+            volumes: z.ZodArray<z.ZodObject<{
+                mountPoints: z.ZodArray<z.ZodString>;
+                filesystem: z.ZodString;
+                devices: z.ZodArray<z.ZodString>;
+                profile: z.ZodOptional<z.ZodString>;
+                total: z.ZodCoercedBigInt<unknown>;
+                used: z.ZodCoercedBigInt<unknown>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
         networkInterfaces: z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             model: z.ZodString;
@@ -401,11 +414,24 @@ declare const SysadminServerToClient: {
             total: z.ZodCoercedBigInt<unknown>;
             used: z.ZodCoercedBigInt<unknown>;
         }, z.core.$strip>;
-        storage: z.ZodArray<z.ZodObject<{
-            model: z.ZodString;
-            total: z.ZodCoercedBigInt<unknown>;
-            used: z.ZodCoercedBigInt<unknown>;
-        }, z.core.$strip>>;
+        storage: z.ZodObject<{
+            devices: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                model: z.ZodString;
+                size: z.ZodCoercedBigInt<unknown>;
+                interface: z.ZodOptional<z.ZodString>;
+                rotational: z.ZodBoolean;
+                removable: z.ZodBoolean;
+            }, z.core.$strip>>;
+            volumes: z.ZodArray<z.ZodObject<{
+                mountPoints: z.ZodArray<z.ZodString>;
+                filesystem: z.ZodString;
+                devices: z.ZodArray<z.ZodString>;
+                profile: z.ZodOptional<z.ZodString>;
+                total: z.ZodCoercedBigInt<unknown>;
+                used: z.ZodCoercedBigInt<unknown>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
         networkInterfaces: z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             model: z.ZodString;

package/dist/info.d.ts

@@ -34,11 +34,44 @@ export declare const Memory: z.ZodObject<{
 }, z.core.$strip>;
 export interface Memory extends z.infer<typeof Memory> {
 }
-export declare const Storage: z.ZodObject<{
+export declare const StorageDevice: z.ZodObject<{
+    name: z.ZodString;
     model: z.ZodString;
+    size: z.ZodCoercedBigInt<unknown>;
+    interface: z.ZodOptional<z.ZodString>;
+    rotational: z.ZodBoolean;
+    removable: z.ZodBoolean;
+}, z.core.$strip>;
+export interface StorageDevice extends z.infer<typeof StorageDevice> {
+}
+export declare const StorageVolume: z.ZodObject<{
+    mountPoints: z.ZodArray<z.ZodString>;
+    filesystem: z.ZodString;
+    devices: z.ZodArray<z.ZodString>;
+    profile: z.ZodOptional<z.ZodString>;
     total: z.ZodCoercedBigInt<unknown>;
     used: z.ZodCoercedBigInt<unknown>;
 }, z.core.$strip>;
+export interface StorageVolume extends z.infer<typeof StorageVolume> {
+}
+export declare const Storage: z.ZodObject<{
+    devices: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        model: z.ZodString;
+        size: z.ZodCoercedBigInt<unknown>;
+        interface: z.ZodOptional<z.ZodString>;
+        rotational: z.ZodBoolean;
+        removable: z.ZodBoolean;
+    }, z.core.$strip>>;
+    volumes: z.ZodArray<z.ZodObject<{
+        mountPoints: z.ZodArray<z.ZodString>;
+        filesystem: z.ZodString;
+        devices: z.ZodArray<z.ZodString>;
+        profile: z.ZodOptional<z.ZodString>;
+        total: z.ZodCoercedBigInt<unknown>;
+        used: z.ZodCoercedBigInt<unknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export interface Storage extends z.infer<typeof Storage> {
 }
 export declare const NetworkInterface: z.ZodObject<{
@@ -83,11 +116,24 @@ export declare const SystemInfo: z.ZodObject<{
         total: z.ZodCoercedBigInt<unknown>;
         used: z.ZodCoercedBigInt<unknown>;
     }, z.core.$strip>;
-    storage: z.ZodArray<z.ZodObject<{
-        model: z.ZodString;
-        total: z.ZodCoercedBigInt<unknown>;
-        used: z.ZodCoercedBigInt<unknown>;
-    }, z.core.$strip>>;
+    storage: z.ZodObject<{
+        devices: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            model: z.ZodString;
+            size: z.ZodCoercedBigInt<unknown>;
+            interface: z.ZodOptional<z.ZodString>;
+            rotational: z.ZodBoolean;
+            removable: z.ZodBoolean;
+        }, z.core.$strip>>;
+        volumes: z.ZodArray<z.ZodObject<{
+            mountPoints: z.ZodArray<z.ZodString>;
+            filesystem: z.ZodString;
+            devices: z.ZodArray<z.ZodString>;
+            profile: z.ZodOptional<z.ZodString>;
+            total: z.ZodCoercedBigInt<unknown>;
+            used: z.ZodCoercedBigInt<unknown>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
     networkInterfaces: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         model: z.ZodString;

package/dist/info.js

@@ -24,9 +24,38 @@ export const Memory = z.object({
     /** Only available when swap is in use */
     swap: TotalUsed.optional(),
 });
-export const Storage = z.object({
-    ...TotalUsed.shape,
+export const StorageDevice = z.object({
+    /** Kernel name of the block device, e.g. 'nvme0n1' or 'sda' */
+    name: z.string(),
     model: z.string(),
+    /** Capacity in bytes */
+    size: z.coerce.bigint(),
+    /** How the device is attached, e.g. 'PCIe 4.0 x4' or 'SATA 6.0 Gbps' */
+    interface: z.string().optional(),
+    /** Whether the device is a spinning disk rather than solid state */
+    rotational: z.boolean(),
+    /** Whether the device's media can be removed, e.g. a card reader or optical drive */
+    removable: z.boolean(),
+});
+export const StorageVolume = z.object({
+    ...TotalUsed.shape,
+    /** Every mount point of the filesystem; more than one for e.g. BTRFS subvolumes or bind mounts */
+    mountPoints: z.string().array(),
+    /** Filesystem type, e.g. 'btrfs' or 'ext4' */
+    filesystem: z.string(),
+    /** Names of the devices backing this volume, matching `StorageDevice.name` */
+    devices: z.string().array(),
+    /**
+     * The RAID or allocation profile the volume is stored with, e.g. 'raid1'.
+     * Only known for filesystems that manage their own devices (BTRFS) and MD arrays; unset when it is plain 'single'.
+     */
+    profile: z.string().optional(),
+});
+export const Storage = z.object({
+    /** Physical devices, including ones not backing any volume */
+    devices: StorageDevice.array(),
+    /** Mounted filesystems, each of which may span several devices */
+    volumes: StorageVolume.array(),
 });
 export const NetworkInterface = z.object({
     name: z.string(),
@@ -47,7 +76,7 @@ export const SystemInfo = z.object({
     cpus: CPU.array(),
     gpus: GPU.array(),
     memory: Memory,
-    storage: Storage.array(),
+    storage: Storage,
     networkInterfaces: NetworkInterface.array(),
     /** e.g. 'arm', 'arm64', 'ia32', 'loong64', 'mips', 'mipsel', 'ppc64', 'riscv64', 's390x', and 'x64' */
     arch: z.string(),

package/locales/en.json

@@ -63,6 +63,8 @@
 			"memory_speed": "{speed} MT/s",
 			"swap": "Swap",
 			"storage": "Storage",
+			"storage_unused": "Unused",
+			"storage_array": "{count} drives",
 			"network": "Network",
 			"wireless": "Wireless",
 			"wired": "Wired",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axium/sysadmin",
-	"version": "0.2.6",
+	"version": "0.3.0",
 	"author": "James Prevett <axium@jamespre.dev>",
 	"description": "System administration for Axium",
 	"funding": {

package/routes/sysadmin/systems/[id]/+page.svelte

@@ -17,6 +17,11 @@
 	let loading = $state(true);
 
 	const matchingUser = $derived(info && systemUsers.find(u => u.username === info!.user.username));
+
+	const storageDevices = $derived(new Map((info?.storage.devices ?? []).map(device => [device.name, device])));
+	const unusedDevices = $derived(
+		(info?.storage.devices ?? []).filter(device => info!.storage.volumes.every(volume => !volume.devices.includes(device.name)))
+	);
 	const connectedUser = $derived(system.connectedUserId ? systemUsers.find(u => u.id === system.connectedUserId) : undefined);
 
 	async function setConnectedUser(connectedUserId: string | null) {
@@ -147,14 +152,57 @@
 				{/if}
 			</div>
 
-			{#if info.storage.length}
+			{#if info.storage.devices.length || info.storage.volumes.length}
 				<div class="component">
 					<h3><Icon i="hard-drive" /> {text('sysadmin.system.storage')}</h3>
-					{#each info.storage as disk}
-						<div class="line">
-							<span>{disk.model}</span>
+					{#each info.storage.volumes as volume}
+						{const disks = $derived(volume.devices.map(name => storageDevices.get(name)).filter(disk => !!disk))}
+						<div class="storage-line">
+							<span class="mount">{volume.mountPoints.join(' ')}</span>
+							{#if disks.length === 1}
+								<span class="subtle">{disks[0].model}</span>
+							{/if}
+							<span class="tags">
+								<span class="tag">{volume.filesystem}</span>
+								{#if volume.profile}
+									<span class="tag raid">{volume.profile.toUpperCase()}</span>
+								{/if}
+								{#if disks.length > 1}
+									<span class="subtle">{text('sysadmin.system.storage_array', { count: disks.length })}</span>
+								{:else if disks[0]?.interface}
+									<span class="subtle">{disks[0].interface}</span>
+								{/if}
+							</span>
+						</div>
+						<NumberBar value={fraction(volume.used, volume.total)} max={1} text={usageText(volume.used, volume.total)} />
+						{#if disks.length > 1}
+							<div class="disks">
+								{#each disks as disk}
+									<div class="disk">
+										<span class="icon-text">
+											<Icon i={disk.rotational ? 'hard-drive' : 'memory'} />
+											{disk.model}
+										</span>
+										<span class="subtle">
+											{formatBytes(disk.size)}
+											{#if disk.interface}<span class="dot">·</span>{disk.interface}{/if}
+										</span>
+									</div>
+								{/each}
+							</div>
+						{/if}
+					{/each}
+					{#each unusedDevices as disk}
+						<div class="storage-line">
+							<span class="mount">{disk.model}</span>
+							<span class="tags">
+								<span class="subtle">
+									{formatBytes(disk.size)}
+									{#if disk.interface}<span class="dot">·</span>{disk.interface}{/if}
+								</span>
+								<span class="tag unused">{text('sysadmin.system.storage_unused')}</span>
+							</span>
 						</div>
-						<NumberBar value={fraction(disk.used, disk.total)} max={1} text={usageText(disk.used, disk.total)} />
 					{/each}
 				</div>
 			{/if}
@@ -361,6 +409,62 @@
 		}
 	}
 
+	.storage-line {
+		display: flex;
+		align-items: center;
+		gap: 0.35em 1em;
+		flex-wrap: wrap;
+	}
+
+	.mount {
+		font-weight: bold;
+	}
+
+	.tags {
+		margin-left: auto;
+		display: inline-flex;
+		align-items: center;
+		gap: 0.5em;
+		flex-wrap: wrap;
+	}
+
+	.tag {
+		padding: 0.1em 0.6em;
+		border-radius: 1em;
+		font-size: 0.85em;
+		line-height: 1.5;
+		background-color: hsl(0 0 calc(var(--bg-light) + (var(--light-step) * 2)));
+	}
+
+	.raid {
+		background-color: var(--bg-strong);
+	}
+
+	.unused {
+		color: hsl(0 0 var(--fg-light));
+		background-color: transparent;
+		border: 1px solid hsl(0 0 calc(var(--bg-light) + (var(--light-step) * 3)));
+	}
+
+	.disks {
+		display: grid;
+		grid-template-columns: repeat(auto-fit, minmax(15em, 1fr));
+		gap: 0.5em;
+	}
+
+	.disk {
+		display: flex;
+		flex-direction: column;
+		gap: 0.15em;
+		padding: 0.5em 0.75em;
+		border-radius: 0.5em;
+		background-color: hsl(0 0 calc(var(--bg-light) + var(--light-step)));
+	}
+
+	.dot {
+		margin: 0 0.15em;
+	}
+
 	.net-line {
 		display: flex;
 		align-items: center;