disk-space-saviour 0.21.0 → 0.22.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.22.0
+
+### Minor Changes
+
+- a63f8ca: Add `dss usage`, which shows where the space of a whole volume goes (largest directories and files, what dss can free or has blocked inside each, APFS volumes, snapshots and unread space), list APFS clones that share their blocks with an installed app under `SHARED WITH INSTALLED APPS`, search Git worktree folders at full depth, keep per-app macOS Library folders while a process of the owning app runs, name the process and app holding a busy path, group blocked space by the condition that frees it in a `WARNING:` line and a `FREEABLE ON CONDITIONS` section, scan again when a process that blocked items has exited, warn when a clean plan rests on an incomplete scan, and collapse access errors inside directories this user cannot enter into one line.
+
 ## 0.21.0
 
 ### Minor Changes

package/README.md

@@ -57,6 +57,7 @@ dss scan [paths...] [--docker] [--depth N] [--json]      # report only
 dss clean [paths...] --tier safe|moderate [--yes] [--older-than 1h]
 dss emergency --free 20G | --until 80% [--path /] [--yes]
 dss docker scan|clean [--container ID] [--recursive]
+dss usage [paths...] [--min-size 1G] [--json]            # where space goes
 ```
 
 | Exit code | Meaning                                  |
@@ -85,6 +86,22 @@ Run `dss --help` for every option. The most useful ones:
   Recent reports authenticated by this installation are reused; older, unsigned
   or edited reports require discovery again. Changing discovery or action options
   also rebuilds the plan. Every deletion still gets fresh checks.
+- `dss usage` shows where the space of a whole volume goes, including data
+  no rule covers. One read-only `du -axk` pass walks the macOS Data volume
+  (`/Users`, `/Applications`, `/private`, `/opt`, ...) or `/` on Linux, or
+  the given paths, staying on their filesystem. It prints a tree of the
+  largest directories (1% of the walk and up, or `--min-size`), the largest
+  files, and for each directory what the latest dss scan or clean found
+  inside it (`[dss: 1.2 GiB freeable, 3.4 GiB blocked]`). On macOS it adds
+  the APFS volumes a walk cannot see (system, VM swap, Preboot, Recovery),
+  local snapshots and the part of the Data volume left unread. It needs
+  `du`, so it runs on macOS and Linux; a full walk takes minutes.
+- APFS clones that share every block with an installed app, such as Chrome's
+  code-sign clones, free nothing when deleted, so they are never offered. The
+  scan lists them under `SHARED WITH INSTALLED APPS` and `dss usage` marks
+  them, because `du` and Finder count them at full size.
+- Git worktree folders (`.worktrees`, `worktrees`) restart the project search
+  depth, so dependencies of nested worktrees are found below `--max-depth`.
 - `clean` automatically reuses a matching scan from the last 30 minutes.
   `--fresh` bypasses this plan and the discovery/size index; `--cache-dir DIR`
   chooses the state location (default `$XDG_STATE_HOME/disk-space-saviour`, or
@@ -149,6 +166,24 @@ is needed. Agent scratch cleanup requires inactivity and Git safety checks.
   cache, while `bun install`, `bunx` or an auto-installing script does.
   A directory on the `PATH` of a running process is kept too: the process
   may still start programs from it.
+- **Per-app macOS folders stay while their app runs.** Caches, containers
+  and other folders under `~/Library/<kind>/<bundle-id>` belong to the app
+  with that bundle identifier, read from the `Info.plist` of every bundle a
+  running process starts from. Such a folder is blocked while that app, a
+  helper or an updater of it runs (for example the WebKit cache of Music,
+  Telegram's group container), even when no rule names the app's process.
+  A path held open names its holder: `in use: <path> (pid N, App)`.
+- **Blocked space is grouped by what frees it.** A `WARNING:` line and the
+  `FREEABLE ON CONDITIONS` section total blocked space by the condition that
+  clears every blocker of an item: quit an app, a process or Claude Code
+  session ending, files closing, the activity window passing, a container
+  stopping or a later scan finishing what this one ran out of time for.
+  Items kept for Git state, protected installs or unverifiable records are
+  counted apart. `clean` repeats the summary after the plan. Rerun dss once
+  a condition is met; it rechecks everything before deleting. `clean` scans
+  again instead of reusing a saved scan when a process named by its blockers
+  has exited, and warns when the scan behind its plan stopped early (for
+  example at `--scan-budget`), since items it never reached are not planned.
 - **Toolchain versions are kept while anything may need them.** The
   manager's default and aliases, versions pinned by a project (`.nvmrc`,
   `rust-toolchain.toml`, ...) and the newest install stay. A partial nvm pin

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "disk-space-saviour",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "Safely reclaims disk space: caches and build outputs of 20+ ecosystems, forgotten projects, and Docker (running, stopped and nested containers), with an emergency mode",
   "type": "module",
   "main": "src/index.js",

package/src/app-owners.js

@@ -0,0 +1,87 @@
+/**
+ * macOS apps that own per-app Library folders.
+ *
+ * Caches, containers and other per-app data under `~/Library/<kind>/` are
+ * named after the owning app's bundle identifier
+ * (`~/Library/Caches/com.apple.Music/WebKit`, group containers carry a
+ * team prefix: `6N38VWS5BX.ru.keepcoder.Telegram`). A running app may read
+ * or write such a folder at any moment without holding a file open, so a
+ * folder stays while a process runs from a bundle of its owner. This
+ * covers apps a rule's process names do not list, such as every app that
+ * embeds WebKit.
+ */
+
+const OWNED =
+  /\/Library\/(Caches|Containers|Group Containers|HTTPStorages|WebKit|Saved Application State|Application Scripts|Application Support|Logs|Cookies)\/([^/]+)/;
+const BUNDLE_ID = /^[A-Za-z0-9-]+(?:\.[A-Za-z0-9_-]+)+$/;
+
+/** Bundle identifier owning `target`, or null outside per-app folders. */
+export function ownerBundleId(target) {
+  const match = OWNED.exec(target);
+  if (!match) {
+    return null;
+  }
+  let id = match[2].replace(/\.(savedState|binarycookies)$/, '');
+  if (match[1] === 'Group Containers') {
+    id = id.replace(/^(?:[A-Z0-9]{10}\.|group\.)/, '');
+  }
+  return BUNDLE_ID.test(id) ? id : null;
+}
+
+/** Bundles (`.app`, `.appex`, `.xpc`) an executable runs from, outermost first. */
+export function bundleRoots(executable) {
+  const roots = [];
+  const parts = (executable ?? '').split('/');
+  for (let index = 1; index < parts.length - 1; index++) {
+    if (/\.(app|appex|xpc)$/.test(parts[index])) {
+      roots.push(parts.slice(0, index + 1).join('/'));
+    }
+  }
+  return roots;
+}
+
+/** `CFBundleIdentifier` of an XML property list, or null. */
+export function parseBundleIdentifier(plist) {
+  return (
+    /<key>CFBundleIdentifier<\/key>\s*<string>([^<]+)<\/string>/
+      .exec(plist ?? '')?.[1]
+      ?.trim() || null
+  );
+}
+
+/**
+ * Whether a running bundle belongs to the owner of a folder: the same
+ * identifier, or one nested under the other (helpers such as
+ * `com.google.Chrome.helper`, updaters such as `….ShipIt`).
+ */
+export function ownsFolder(running, owner) {
+  const a = running.toLowerCase();
+  const b = owner.toLowerCase();
+  return a === b || a.startsWith(`${b}.`) || b.startsWith(`${a}.`);
+}
+
+/**
+ * Identifiers a process runs under. A bundle without a readable identifier
+ * falls back to its name, which still matches an owner ending in it
+ * (`Telegram.app` and `ru.keepcoder.Telegram`).
+ * @param {string[]} roots bundle paths of the process
+ * @param {Map<string, string|null>} ids bundle path → identifier
+ */
+export function processBundles(roots, ids) {
+  return roots.map((root) => ({
+    id: ids.get(root) ?? null,
+    name: root
+      .split('/')
+      .at(-1)
+      .replace(/\.(app|appex|xpc)$/, ''),
+  }));
+}
+
+/** Whether one of `bundles` owns the folder of bundle identifier `owner`. */
+export function bundlesOwn(bundles, owner) {
+  return bundles.some((bundle) =>
+    bundle.id
+      ? ownsFolder(bundle.id, owner)
+      : owner.toLowerCase().split('.').at(-1) === bundle.name.toLowerCase()
+  );
+}

package/src/clean.js

@@ -1013,6 +1013,17 @@ export async function finishAudit(audit, report, options) {
     .filter((e) => e.status === 'planned')
     .reduce((sum, e) => sum + e.plannedBytes, 0);
   audit.environments = environmentTotals(report, audit.entries);
+  // What the run had to leave, grouped by the condition that frees it.
+  audit.blocked = report.totals?.blocked ?? null;
+  // Scanners an incomplete scan never reached contribute no items at all.
+  audit.incomplete = (report.environments ?? [])
+    .filter(
+      (env) =>
+        env.scanStatus &&
+        env.scanStatus !== 'complete' &&
+        env.scanStatus !== 'goal-reached'
+    )
+    .map((env) => ({ label: env.label, status: env.scanStatus }));
   if (options.audit !== false) {
     await writeAudit(audit, options);
   }

package/src/cli.js

@@ -13,14 +13,16 @@ import { parseArgs } from 'node:util';
 
 import { startAudit, writeAudit } from './audit.js';
 import { clean } from './clean.js';
+import { exitedBlockerPids, pidAlive } from './conditions.js';
 import { emergency } from './emergency.js';
 import { setTrace } from './exec.js';
 import { resolveGoal, resolveOptions } from './options.js';
 import { formatAudit, formatReport } from './report.js';
 import { scan } from './scan.js';
+import { formatUsage, usage } from './usage.js';
 import { cleanDuringScan } from './fast-clean.js';
 import { defaultStateDirectory, loadScan } from './scan-state.js';
-import { formatBytes } from './units.js';
+import { formatBytes, parseSize } from './units.js';
 
 export const USAGE = `Usage: dss <command> [paths...] [options]
 
@@ -28,6 +30,9 @@ Commands:
   scan [paths...]            Report reclaimable space (never deletes)
   clean [paths...]           Delete what the chosen tier allows
   emergency                  Escalate tiers until a free-space goal is met
+  usage [paths...]           Show where space goes on whole volumes: the
+                             largest directories and files, what dss can
+                             free inside them, APFS volumes (never deletes)
   docker scan|clean          Only Docker: daemons, containers, nested daemons
   help, version
 
@@ -288,7 +293,7 @@ export function processIo() {
   };
 }
 
-const API = { scan, clean, emergency, cleanDuringScan };
+const API = { scan, clean, emergency, cleanDuringScan, usage };
 
 class Cli {
   constructor(io, api) {
@@ -305,6 +310,23 @@ class Cli {
     return this.printScan(report, options, values);
   }
 
+  async usage(options, values) {
+    const report = await this.api.usage({
+      roots: options.roots,
+      // Without --min-size the tree shows directories of 1% of a root.
+      minSize: values['min-size'] ? parseSize(values['min-size']) : undefined,
+      verbose: values.verbose,
+      signal: options.signal,
+      auditDir: options.auditDir,
+      onUsageProgress: (progress) =>
+        this.io.stderr(
+          `[usage] ${progress.root}: ${Math.round(progress.elapsedMs / 1000)}s, ${progress.entries.toLocaleString('en-US')} entries, at ${progress.at ?? progress.root}`
+        ),
+    });
+    this.print(values, report, () => formatUsage(report));
+    return 0;
+  }
+
   async printScan(report, options, values) {
     const audit = scanAudit(report);
     if (options.audit !== false) {
@@ -329,7 +351,12 @@ class Cli {
     const file = values.from ?? values.report;
     if (!file) {
       const recent = await loadScan(resolveOptions(options));
-      if (recent) {
+      const exited = recent ? exitedBlockerPids(recent, pidAlive) : [];
+      if (exited.length > 0) {
+        this.io.stderr(
+          `Scanning again: processes that blocked items in the scan from ${recent.createdAt} exited (pid ${exited.slice(0, 5).join(', ')}${exited.length > 5 ? ', …' : ''}).`
+        );
+      } else if (recent) {
         this.io.stderr(
           `Reusing scan from ${recent.createdAt}; planned items will be checked before deletion.`
         );
@@ -491,6 +518,8 @@ function dispatch(cli, command, options, values) {
       return cli.clean(options, values);
     case 'emergency':
       return cli.emergency(options, values);
+    case 'usage':
+      return cli.usage(options, values);
     case 'docker-scan':
       return cli.scan(dockerOnly(options, values), values);
     case 'docker-clean':

package/src/conditions.js

@@ -0,0 +1,145 @@
+/**
+ * Space that frees when a condition is met: blocked items grouped by what
+ * keeps them, so a report says "quit Telegram: 1.9 GiB" in one line for
+ * hundreds of busy items. An item frees only when every one of
+ * its blockers clears; items kept for reasons no running program explains
+ * (Git state, protected installs, unreadable records) are counted apart.
+ */
+
+const CONDITIONS = [
+  [
+    /^(?:busy: )?(.+?) is running in (.+?) \(pid (\d+)\)$/,
+    (m) => ({
+      key: `exit:${m[3]}`,
+      action: `${m[1]} (pid ${m[3]}) in ${m[2]} exits`,
+    }),
+  ],
+  [
+    /^(?:busy: )?(.+?) is running \(pid \d+(?:, working directory unknown)?\)(?: and owns \S+)?$/,
+    (m) => ({ key: `quit:${m[1]}`, action: `quit ${m[1]}` }),
+  ],
+  [
+    /^locked by running Claude Code \(pid (\d+)/,
+    (m) => ({
+      key: `exit:${m[1]}`,
+      action: `the Claude Code session (pid ${m[1]}) ends`,
+    }),
+  ],
+  [
+    /^(?:busy: )?on the PATH of (.+?) \(pid (\d+)\)/,
+    (m) => ({ key: `exit:${m[2]}`, action: `${m[1]} (pid ${m[2]}) exits` }),
+  ],
+  [
+    /^(?:busy: )?in use: .+ \(pid (\d+)(?:, (.+))?\)$/,
+    (m) => ({
+      key: `exit:${m[1]}`,
+      action: `${m[2] ?? 'process'} (pid ${m[1]}) exits`,
+    }),
+  ],
+  [
+    /^(?:busy: )?(?:in use: |every path is in use)/,
+    () => ({ key: 'open', action: 'the programs holding the files open exit' }),
+  ],
+  [
+    /^(?:busy: )?modified .+ ago, inside the (.+) activity window$/,
+    (m) => ({
+      key: 'idle',
+      action: `they stay untouched for the ${m[1]} activity window`,
+    }),
+  ],
+  [
+    /^scan incomplete: (.+)$/,
+    (m) => ({
+      key: 'rescan',
+      action: `a later scan finishes measuring them (${m[1]})`,
+    }),
+  ],
+  [
+    /^bind-mounted by running container (\S+)/,
+    (m) => ({ key: `container:${m[1]}`, action: `container ${m[1]} stops` }),
+  ],
+];
+
+/** What must happen for `blocker` to clear, or null when nothing running explains it. */
+export function blockerCondition(blocker) {
+  for (const [pattern, condition] of CONDITIONS) {
+    const match = pattern.exec(blocker);
+    if (match) {
+      return condition(match);
+    }
+  }
+  return null;
+}
+
+/**
+ * Blocked space grouped by the conditions that free it, largest first.
+ * @param {object[]} items blocked items, nested ones already dropped
+ * @returns {{conditions: object[], other: {items: number, bytes: number}}}
+ */
+export function blockedConditions(items) {
+  const groups = new Map();
+  const other = { items: 0, bytes: 0 };
+  for (const item of items) {
+    const found = item.blockers.map(blockerCondition);
+    if (found.length === 0 || found.includes(null)) {
+      other.items += 1;
+      other.bytes += item.bytes;
+      continue;
+    }
+    // The first blocker names a process most specifically (a Claude Code
+    // lock before the files it holds open).
+    const unique = found.filter(
+      (entry, index) => found.findIndex((e) => e.key === entry.key) === index
+    );
+    const key = unique
+      .map((entry) => entry.key)
+      .sort()
+      .join('+');
+    const group = groups.get(key) ?? {
+      action: unique.map((entry) => entry.action).join(' and '),
+      items: 0,
+      bytes: 0,
+      tiers: {},
+    };
+    group.items += 1;
+    group.bytes += item.bytes;
+    group.tiers[item.tier] = (group.tiers[item.tier] ?? 0) + item.bytes;
+    groups.set(key, group);
+  }
+  return {
+    conditions: [...groups.values()].sort((a, b) => b.bytes - a.bytes),
+    other,
+  };
+}
+
+/**
+ * Host processes named by blockers of a saved scan that no longer run, so
+ * the items they blocked may be free now and the scan is stale.
+ * @param {object} report saved scan
+ * @param {(pid: number) => boolean} alive
+ * @returns {number[]}
+ */
+export function exitedBlockerPids(report, alive) {
+  const pids = new Set();
+  for (const item of report.items ?? []) {
+    if (item.env !== 'host') {
+      continue;
+    }
+    for (const blocker of item.blockers ?? []) {
+      for (const match of blocker.matchAll(/\(pid (\d+)/g)) {
+        pids.add(Number(match[1]));
+      }
+    }
+  }
+  return [...pids].filter((pid) => !alive(pid));
+}
+
+/** Whether a process with `pid` exists, including other users' processes. */
+export function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === 'EPERM';
+  }
+}

package/src/env/local.js

@@ -89,7 +89,7 @@ export function parsePsSearchPaths(output) {
  * host and inside containers (see shell.js).
  */
 
-import { promises as fsp } from 'node:fs';
+import { constants as fsConstants, promises as fsp } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { URL, fileURLToPath } from 'node:url';
@@ -97,6 +97,7 @@ import { procIdentity, procOpenPaths } from './proc.js';
 import { CACHE_VARIABLES } from './cache-roots.js';
 
 import { hostExecutor } from '../exec.js';
+import { parseBundleIdentifier } from '../app-owners.js';
 import { matchesGlob } from '../paths.js';
 import { mapLimit } from './parallel.js';
 import { directoryFingerprint, SIZE_MAX_AGE } from '../scan-state.js';
@@ -251,6 +252,36 @@ export class LocalEnv {
     );
   }
 
+  /**
+   * Access errors as report messages. Paths inside a directory this user
+   * cannot enter collapse into one line: nothing inside such a directory
+   * can be deleted by this user, so no candidate hides there.
+   * @returns {Promise<string[]>}
+   */
+  async accessErrorMessages() {
+    const messages = [];
+    const foreign = new Set();
+    for (const [target, message] of this.accessErrors ?? []) {
+      const parent = path.dirname(target);
+      const enterable = await fsp
+        .access(parent, fsConstants.X_OK)
+        .then(() => true)
+        .catch(() => false);
+      if (enterable) {
+        messages.push(message);
+      } else {
+        foreign.add(parent);
+      }
+    }
+    if (foreign.size > 0) {
+      const [example] = [...foreign].sort();
+      messages.push(
+        `skipped ${foreign.size} ${foreign.size === 1 ? 'directory' : 'directories'} this user cannot enter, such as ${example}; nothing inside can be deleted without their owner's rights`
+      );
+    }
+    return messages;
+  }
+
   async #lstat(target) {
     try {
       return await (this.options.fileFs ?? fsp).lstat(target);
@@ -830,6 +861,8 @@ export class LocalEnv {
       .map((m) => ({
         pid: Number(m[1]),
         name: path.basename(m[2].trim()),
+        // macOS `comm` is the executable's full path.
+        executable: m[2].trim(),
         cwd: cwds.get(Number(m[1])) ?? null,
         command: commands.get(Number(m[1])) ?? '',
         searchPath: searchPaths.get(Number(m[1])) ?? [],
@@ -978,12 +1011,22 @@ export class LocalEnv {
       if (result.code !== 0 && !result.stdout) {
         return null;
       }
-      return new Set(
-        result.stdout
-          .split('\n')
-          .filter((line) => line.startsWith('n/'))
-          .map((line) => line.slice(1))
-      );
+      // `-F` always prints the pid (`p`) before the files of a process.
+      const paths = new Set();
+      const owners = new Map();
+      let pid = null;
+      for (const line of result.stdout.split('\n')) {
+        if (line.startsWith('p')) {
+          pid = Number(line.slice(1));
+        } else if (line.startsWith('n/')) {
+          paths.add(line.slice(1));
+          if (!owners.has(line.slice(1))) {
+            owners.set(line.slice(1), pid);
+          }
+        }
+      }
+      this.openPathPids = owners;
+      return paths;
     }
     return null;
   }
@@ -992,6 +1035,26 @@ export class LocalEnv {
     return this.executor.run(argv, options);
   }
 
+  /** `CFBundleIdentifier` of a macOS bundle, or null. */
+  async bundleIdentifier(bundle) {
+    if (this.platform !== 'darwin') {
+      return null;
+    }
+    const plist = path.join(bundle, 'Contents', 'Info.plist');
+    const text = await fsp.readFile(plist, 'utf8').catch(() => null);
+    if (text === null) {
+      return null;
+    }
+    if (!text.startsWith('bplist')) {
+      return parseBundleIdentifier(text);
+    }
+    const result = await this.run(
+      ['plutil', '-extract', 'CFBundleIdentifier', 'raw', '-o', '-', plist],
+      { timeoutMs: 10000 }
+    ).catch(() => null);
+    return result?.code === 0 ? result.stdout.trim() || null : null;
+  }
+
   async which(command) {
     const dirs = (process.env.PATH ?? '').split(path.delimiter);
     const extensions =

package/src/index.d.ts

@@ -219,6 +219,16 @@ export interface Report {
   options: Record<string, unknown>;
   environments: EnvironmentDescriptor[];
   items: Item[];
+  /**
+   * Host items that share every block with an installed app (APFS clones):
+   * never offered, listed so the space `du` counts for them is explained.
+   */
+  shared?: Array<{
+    rule: string;
+    path: string;
+    apparentBytes: number;
+    sharedWith: string;
+  }>;
   /** Tier totals exclude items that need explicit consent (`consent`). */
   totals: Record<Tier | 'blocked' | 'consent', TierTotal>;
   docker: {
@@ -300,6 +310,50 @@ export declare function clean(
 /** Escalates tiers until the free-space goal is met, then stops. */
 export declare function emergency(options: EmergencyOptions): Promise<AuditLog>;
 
+export interface UsageOptions {
+  /** Directories to walk; default the macOS Data volume or `/`. */
+  roots?: string[] | null;
+  /** Smallest directory in the tree, in bytes; default 1% of a root. */
+  minSize?: number;
+  verbose?: boolean;
+  signal?: AbortSignal;
+  auditDir?: string;
+  onUsageProgress?: (progress: {
+    root: string;
+    elapsedMs: number;
+    entries: number;
+    at: string | null;
+  }) => void;
+}
+
+export interface UsageReport {
+  schema: 1;
+  createdAt: string;
+  durationMs: number;
+  platform: string;
+  scan: { file: string; createdAt: string | null } | null;
+  roots: Array<{
+    root: string;
+    path: string;
+    bytes: number;
+    entries: number;
+    tree: object;
+    files: Array<{ path: string; bytes: number }>;
+    [key: string]: unknown;
+  }>;
+  volumes: Array<{
+    name: string;
+    mount: string | null;
+    bytes: number;
+    role: string;
+  }>;
+  snapshots: number | null;
+}
+
+/** Shows where the space of whole volumes goes. Never deletes. */
+export declare function usage(options?: UsageOptions): Promise<UsageReport>;
+export declare function formatUsage(report: UsageReport): string;
+
 export declare function formatReport(
   report: Report,
   options?: { verbose?: boolean }

package/src/index.js

@@ -23,6 +23,7 @@ export {
   writeAudit,
 } from './audit.js';
 export { formatReport, formatAudit, formatDisk } from './report.js';
+export { usage, formatUsage } from './usage.js';
 export { runCli, parseCli, USAGE } from './cli.js';
 export { DEFAULTS, resolveOptions, resolveGoal } from './options.js';
 export {

package/src/items.js

@@ -7,6 +7,8 @@
  * named flag (or an interactive yes) on top of their tier being selected.
  */
 
+import { blockedConditions } from './conditions.js';
+
 export const TIERS = ['safe', 'moderate', 'aggressive'];
 
 /**
@@ -111,6 +113,7 @@ export function tierTotals(items) {
     unknownBytes: blocked
       .filter((item) => item.sizeUnknown)
       .reduce((sum, item) => sum + (item.totalBytes ?? item.bytes), 0),
+    ...blockedConditions(blocked),
   };
   return totals;
 }