@bgord/bun 1.1.5 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@axiomhq/winston": "1.3.1",
-    "@bgord/tools": "1.1.4",
+    "@bgord/tools": "1.1.5",
     "@hono/ua-blocker": "0.1.15",
     "better-auth": "1.3.34",
     "croner": "9.1.0",

package/src/healthcheck.service.ts

@@ -31,7 +31,7 @@ export class Healthcheck {
       const details: HealthcheckResultType["details"][number][] = [];
 
       for (const prerequisite of prerequisites) {
-        details.push({ label: prerequisite.label, outcome: await prerequisite.verify() });
+        details.push({ label: prerequisite.label, outcome: await prerequisite.verify(deps.Clock) });
       }
 
       const ok = details.every((result) => result.outcome.status !== prereqs.PrerequisiteStatusEnum.failure)

package/src/prerequisites/binary.ts

@@ -1,5 +1,7 @@
 import bun from "bun";
+import * as tools from "@bgord/tools";
 import type { BinaryType } from "../binary.vo";
+import type { ClockPort } from "../clock.port";
 import * as prereqs from "../prerequisites.service";
 
 export class PrerequisiteBinary implements prereqs.Prerequisite {
@@ -15,16 +17,18 @@ export class PrerequisiteBinary implements prereqs.Prerequisite {
     this.binary = config.binary;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
     try {
-      if (!this.enabled) return prereqs.Verification.undetermined();
+      if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
       const result = await bun.$`which ${this.binary}`.quiet();
 
-      if (result.exitCode === 0) return prereqs.Verification.success();
-      return prereqs.Verification.failure({ message: `Exit code ${result.exitCode}` });
+      if (result.exitCode === 0) return prereqs.Verification.success(stopwatch.stop());
+      return prereqs.Verification.failure(stopwatch.stop(), { message: `Exit code ${result.exitCode}` });
     } catch (error) {
-      return prereqs.Verification.failure(error as Error);
+      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
     }
   }
 }

package/src/prerequisites/bun.ts

@@ -1,4 +1,5 @@
 import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
 import * as prereqs from "../prerequisites.service";
 
 export class PrerequisiteBun implements prereqs.Prerequisite {
@@ -16,16 +17,22 @@ export class PrerequisiteBun implements prereqs.Prerequisite {
     this.current = config.current;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     try {
       const current = tools.PackageVersion.fromString(this.current);
 
-      if (current.isGreaterThanOrEqual(this.version)) return prereqs.Verification.success();
-      return prereqs.Verification.failure({ message: `Version: ${this.version.toString()}` });
+      if (current.isGreaterThanOrEqual(this.version)) return prereqs.Verification.success(stopwatch.stop());
+      return prereqs.Verification.failure(stopwatch.stop(), {
+        message: `Version: ${this.version.toString()}`,
+      });
     } catch {
-      return prereqs.Verification.failure({ message: `Invalid version passed: ${this.current}` });
+      return prereqs.Verification.failure(stopwatch.stop(), {
+        message: `Invalid version passed: ${this.current}`,
+      });
     }
   }
 }

package/src/prerequisites/clock-drift.ts

@@ -1,4 +1,4 @@
-import type * as tools from "@bgord/tools";
+import * as tools from "@bgord/tools";
 import type { ClockPort } from "../clock.port";
 import * as prereqs from "../prerequisites.service";
 import type { TimekeeperPort } from "../timekeeper.port";
@@ -27,17 +27,19 @@ export class PrerequisiteClockDrift implements prereqs.Prerequisite {
     this.clock = config.clock;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     const now = this.clock.now();
 
     const timestamp = await this.timekeeper.get();
-    if (!timestamp) return prereqs.Verification.undetermined();
+    if (!timestamp) return prereqs.Verification.undetermined(stopwatch.stop());
 
     const duration = now.difference(timestamp).toAbolute();
 
-    if (duration.isShorterThan(this.skew)) return prereqs.Verification.success();
-    return prereqs.Verification.failure({ message: `Difference: ${duration.seconds}s` });
+    if (duration.isShorterThan(this.skew)) return prereqs.Verification.success(stopwatch.stop());
+    return prereqs.Verification.failure(stopwatch.stop(), { message: `Difference: ${duration.seconds}s` });
   }
 }

package/src/prerequisites/dependency-vulnerabilities.ts

@@ -1,4 +1,6 @@
 import bun from "bun";
+import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
 import * as prereqs from "../prerequisites.service";
 
 type BunAuditOutput = { [packageName: string]: { severity: "low" | "moderate" | "high" | "critical" }[] };
@@ -13,13 +15,16 @@ export class PrerequisiteDependencyVulnerabilities implements prereqs.Prerequisi
     this.enabled = config.enabled === undefined ? true : config.enabled;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     try {
       const command = await bun.$`bun audit --json`.quiet();
 
-      if (command.exitCode !== 0) return prereqs.Verification.failure({ message: "Audit failure" });
+      if (command.exitCode !== 0)
+        return prereqs.Verification.failure(stopwatch.stop(), { message: "Audit failure" });
 
       const audit = JSON.parse(command.stdout.toString()) as BunAuditOutput;
 
@@ -32,13 +37,13 @@ export class PrerequisiteDependencyVulnerabilities implements prereqs.Prerequisi
       ).length;
 
       if (criticalVulnerabilitiesCount > 0 || highVulnerabilitiesCount > 0)
-        return prereqs.Verification.failure({
+        return prereqs.Verification.failure(stopwatch.stop(), {
           message: `Critical: ${criticalVulnerabilitiesCount} and high: ${highVulnerabilitiesCount}`,
         });
 
-      return prereqs.Verification.success();
+      return prereqs.Verification.success(stopwatch.stop());
     } catch (error) {
-      return prereqs.Verification.failure(error as Error);
+      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
     }
   }
 }

package/src/prerequisites/directory.ts

@@ -1,6 +1,7 @@
 import { constants } from "node:fs";
 import fsp from "node:fs/promises";
-import type * as tools from "@bgord/tools";
+import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
 import * as prereqs from "../prerequisites.service";
 
 export class PrerequisiteDirectory implements prereqs.Prerequisite {
@@ -24,8 +25,10 @@ export class PrerequisiteDirectory implements prereqs.Prerequisite {
     this.access = config.access;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     const write = this.access?.write ?? false;
     const execute = this.access?.execute ?? false;
@@ -35,9 +38,9 @@ export class PrerequisiteDirectory implements prereqs.Prerequisite {
     try {
       await fsp.access(this.directory, flags);
 
-      return prereqs.Verification.success();
+      return prereqs.Verification.success(stopwatch.stop());
     } catch (error) {
-      return prereqs.Verification.failure(error as Error);
+      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
     }
   }
 }

package/src/prerequisites/external-api.ts

@@ -1,3 +1,5 @@
+import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
 import * as prereqs from "../prerequisites.service";
 
 export class PrerequisiteExternalApi implements prereqs.Prerequisite {
@@ -14,16 +16,18 @@ export class PrerequisiteExternalApi implements prereqs.Prerequisite {
     this.request = config.request;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     try {
       const response = await this.request();
 
-      if (response.ok) return prereqs.Verification.success();
-      return prereqs.Verification.failure({ message: `HTTP ${response.status}` });
+      if (response.ok) return prereqs.Verification.success(stopwatch.stop());
+      return prereqs.Verification.failure(stopwatch.stop(), { message: `HTTP ${response.status}` });
     } catch (error) {
-      return prereqs.Verification.failure(error as Error);
+      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
     }
   }
 }

package/src/prerequisites/jobs.ts

@@ -1,3 +1,5 @@
+import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
 import { Jobs, type MultipleJobsType } from "../jobs.service";
 import * as prereqs from "../prerequisites.service";
 
@@ -15,9 +17,11 @@ export class PrerequisiteJobs implements prereqs.Prerequisite {
     this.jobs = config.jobs;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
-    if (Jobs.areAllRunning(this.jobs)) return prereqs.Verification.success();
-    return prereqs.Verification.failure();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
+    if (Jobs.areAllRunning(this.jobs)) return prereqs.Verification.success(stopwatch.stop());
+    return prereqs.Verification.failure(stopwatch.stop());
   }
 }

package/src/prerequisites/log-file.ts

@@ -1,3 +1,5 @@
+import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
 import type { LoggerWinstonProductionAdapter } from "../logger-winston-production.adapter";
 import * as prereqs from "../prerequisites.service";
 
@@ -15,17 +17,19 @@ export class PrerequisiteLogFile implements prereqs.Prerequisite {
     this.logger = config.logger;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     try {
       const path = this.logger.prodLogFile;
       const result = await Bun.file(path).exists();
 
-      if (result) return prereqs.Verification.success();
-      return prereqs.Verification.failure({ message: `Missing file: ${path}` });
+      if (result) return prereqs.Verification.success(stopwatch.stop());
+      return prereqs.Verification.failure(stopwatch.stop(), { message: `Missing file: ${path}` });
     } catch (error) {
-      return prereqs.Verification.failure(error as Error);
+      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
     }
   }
 }

package/src/prerequisites/mailer.ts

@@ -1,3 +1,5 @@
+import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
 import type { MailerPort } from "../mailer.port";
 import * as prereqs from "../prerequisites.service";
 
@@ -15,14 +17,16 @@ export class PrerequisiteMailer implements prereqs.Prerequisite {
     this.mailer = config.mailer;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     try {
       await this.mailer.verify();
-      return prereqs.Verification.success();
+      return prereqs.Verification.success(stopwatch.stop());
     } catch (error) {
-      return prereqs.Verification.failure(error as Error);
+      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
     }
   }
 }

package/src/prerequisites/memory.ts

@@ -1,4 +1,5 @@
 import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
 import { MemoryConsumption } from "../memory-consumption.service";
 import * as prereqs from "../prerequisites.service";
 
@@ -16,16 +17,18 @@ export class PrerequisiteMemory implements prereqs.Prerequisite {
     this.maximum = config.maximum;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     const memoryConsumption = MemoryConsumption.get();
 
     if (memoryConsumption.isGreaterThan(this.maximum)) {
-      return prereqs.Verification.failure({
+      return prereqs.Verification.failure(stopwatch.stop(), {
         message: `Memory consumption: ${memoryConsumption.format(tools.Size.unit.MB)}`,
       });
     }
-    return prereqs.Verification.success();
+    return prereqs.Verification.success(stopwatch.stop());
   }
 }

package/src/prerequisites/node.ts

@@ -1,4 +1,5 @@
 import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
 import * as prereqs from "../prerequisites.service";
 
 export class PrerequisiteNode implements prereqs.Prerequisite {
@@ -17,16 +18,20 @@ export class PrerequisiteNode implements prereqs.Prerequisite {
     this.current = config.current;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     try {
       const current = tools.PackageVersion.fromStringWithV(this.current);
 
-      if (current.isGreaterThanOrEqual(this.version)) return prereqs.Verification.success();
-      return prereqs.Verification.failure({ message: `Version: ${this.current}` });
+      if (current.isGreaterThanOrEqual(this.version)) return prereqs.Verification.success(stopwatch.stop());
+      return prereqs.Verification.failure(stopwatch.stop(), { message: `Version: ${this.current}` });
     } catch {
-      return prereqs.Verification.failure({ message: `Invalid version passed: ${this.current}` });
+      return prereqs.Verification.failure(stopwatch.stop(), {
+        message: `Invalid version passed: ${this.current}`,
+      });
     }
   }
 }

package/src/prerequisites/outside-connectivity.ts

@@ -1,3 +1,5 @@
+import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
 import * as prereqs from "../prerequisites.service";
 
 export class PrerequisiteOutsideConnectivity implements prereqs.Prerequisite {
@@ -12,16 +14,18 @@ export class PrerequisiteOutsideConnectivity implements prereqs.Prerequisite {
     this.enabled = config.enabled === undefined ? true : config.enabled;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
     try {
-      if (!this.enabled) return prereqs.Verification.undetermined();
+      if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
       const response = await fetch(this.url, { method: "HEAD" });
 
-      if (response.ok) return prereqs.Verification.success();
-      return prereqs.Verification.failure({ message: `HTTP ${response.status}` });
+      if (response.ok) return prereqs.Verification.success(stopwatch.stop());
+      return prereqs.Verification.failure(stopwatch.stop(), { message: `HTTP ${response.status}` });
     } catch (error) {
-      return prereqs.Verification.failure(error as Error);
+      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
     }
   }
 }

package/src/prerequisites/port.ts

@@ -1,4 +1,6 @@
 import net from "node:net";
+import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
 import type { PortType } from "../port.vo";
 import * as prereqs from "../prerequisites.service";
 
@@ -16,13 +18,17 @@ export class PrerequisitePort implements prereqs.Prerequisite {
     this.port = config.port;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     return new Promise((resolve) => {
       const server = net.createServer();
-      server.listen(this.port, () => server.close(() => resolve(prereqs.Verification.success())));
-      server.on("error", () => resolve(prereqs.Verification.failure()));
+      server.listen(this.port, () =>
+        server.close(() => resolve(prereqs.Verification.success(stopwatch.stop()))),
+      );
+      server.on("error", () => resolve(prereqs.Verification.failure(stopwatch.stop())));
     });
   }
 }

package/src/prerequisites/ram.ts

@@ -1,5 +1,6 @@
 import os from "node:os";
 import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
 import * as prereqs from "../prerequisites.service";
 
 export class PrerequisiteRAM implements prereqs.Prerequisite {
@@ -16,12 +17,16 @@ export class PrerequisiteRAM implements prereqs.Prerequisite {
     this.minimum = config.minimum;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     const freeRAM = tools.Size.fromBytes(os.freemem());
 
-    if (freeRAM.isGreaterThan(this.minimum)) return prereqs.Verification.success();
-    return prereqs.Verification.failure({ message: `Free RAM: ${freeRAM.format(tools.Size.unit.MB)}` });
+    if (freeRAM.isGreaterThan(this.minimum)) return prereqs.Verification.success(stopwatch.stop());
+    return prereqs.Verification.failure(stopwatch.stop(), {
+      message: `Free RAM: ${freeRAM.format(tools.Size.unit.MB)}`,
+    });
   }
 }

package/src/prerequisites/running-user.ts

@@ -1,4 +1,6 @@
 import os from "node:os";
+import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
 import * as prereqs from "../prerequisites.service";
 
 export class PrerequisiteRunningUser implements prereqs.Prerequisite {
@@ -15,12 +17,14 @@ export class PrerequisiteRunningUser implements prereqs.Prerequisite {
     this.username = config.username;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     const current = os.userInfo().username;
 
-    if (current === this.username) return prereqs.Verification.success();
-    return prereqs.Verification.failure({ message: `Current user: ${current}` });
+    if (current === this.username) return prereqs.Verification.success(stopwatch.stop());
+    return prereqs.Verification.failure(stopwatch.stop(), { message: `Current user: ${current}` });
   }
 }

package/src/prerequisites/self.ts

@@ -1,3 +1,5 @@
+import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
 import * as prereqs from "../prerequisites.service";
 
 export class PrerequisiteSelf implements prereqs.Prerequisite {
@@ -10,8 +12,10 @@ export class PrerequisiteSelf implements prereqs.Prerequisite {
     this.enabled = config.enabled === undefined ? true : config.enabled;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
-    return prereqs.Verification.success();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
+    return prereqs.Verification.success(stopwatch.stop());
   }
 }

package/src/prerequisites/space.ts

@@ -1,5 +1,6 @@
 import path from "node:path";
 import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
 import type { DiskSpaceCheckerPort } from "../disk-space-checker.port";
 import * as prereqs from "../prerequisites.service";
 
@@ -21,19 +22,21 @@ export class PrerequisiteSpace implements prereqs.Prerequisite {
     this.checker = config.checker;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     try {
       const root = path.sep;
       const freeDiskSpace = await this.checker.get(root);
 
-      if (freeDiskSpace.isGreaterThan(this.minimum)) return prereqs.Verification.success();
-      return prereqs.Verification.failure({
+      if (freeDiskSpace.isGreaterThan(this.minimum)) return prereqs.Verification.success(stopwatch.stop());
+      return prereqs.Verification.failure(stopwatch.stop(), {
         message: `Free disk space: ${freeDiskSpace.format(tools.Size.unit.MB)}`,
       });
     } catch (error) {
-      return prereqs.Verification.failure(error as Error);
+      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
     }
   }
 }

package/src/prerequisites/sqlite.ts

@@ -1,4 +1,6 @@
 import type { Database } from "bun:sqlite";
+import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
 import * as prereqs from "../prerequisites.service";
 
 export class PrerequisiteSQLite implements prereqs.Prerequisite {
@@ -15,8 +17,10 @@ export class PrerequisiteSQLite implements prereqs.Prerequisite {
     this.sqlite = config.sqlite;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     try {
       const integrity = this.sqlite.query("PRAGMA integrity_check;").get() as
@@ -24,11 +28,11 @@ export class PrerequisiteSQLite implements prereqs.Prerequisite {
         | undefined;
 
       if (!integrity || (integrity.integrity_check ?? "").toLowerCase() !== "ok") {
-        return prereqs.Verification.failure({ message: "Integrity check failed" });
+        return prereqs.Verification.failure(stopwatch.stop(), { message: "Integrity check failed" });
       }
-      return prereqs.Verification.success();
+      return prereqs.Verification.success(stopwatch.stop());
     } catch (error) {
-      return prereqs.Verification.failure(error as Error);
+      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
     }
   }
 }

package/src/prerequisites/ssl-certificate-expiry.ts

@@ -1,4 +1,6 @@
+import * as tools from "@bgord/tools";
 import type { CertificateInspectorPort } from "../certificate-inspector.port";
+import type { ClockPort } from "../clock.port";
 import * as prereqs from "../prerequisites.service";
 
 export class PrerequisiteSSLCertificateExpiry implements prereqs.Prerequisite {
@@ -25,15 +27,20 @@ export class PrerequisiteSSLCertificateExpiry implements prereqs.Prerequisite {
     this.inspector = config.inspector;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     const result = await this.inspector.inspect(this.host);
 
-    if (!result.success) return prereqs.Verification.failure({ message: "Certificate unavailable" });
+    if (!result.success)
+      return prereqs.Verification.failure(stopwatch.stop(), { message: "Certificate unavailable" });
     if (result.daysRemaining <= this.days) {
-      return prereqs.Verification.failure({ message: `${result.daysRemaining} days remaining` });
+      return prereqs.Verification.failure(stopwatch.stop(), {
+        message: `${result.daysRemaining} days remaining`,
+      });
     }
-    return prereqs.Verification.success();
+    return prereqs.Verification.success(stopwatch.stop());
   }
 }

package/src/prerequisites/timezone-utc.ts

@@ -1,5 +1,6 @@
-import type * as tools from "@bgord/tools";
+import * as tools from "@bgord/tools";
 import { z } from "zod/v4";
+import type { ClockPort } from "../clock.port";
 import * as prereqs from "../prerequisites.service";
 
 export const TimezoneUtc = z.literal("UTC");
@@ -18,12 +19,14 @@ export class PrerequisiteTimezoneUTC implements prereqs.Prerequisite {
     this.timezone = config.timezone;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     const result = TimezoneUtc.safeParse(this.timezone);
 
-    if (result.success) return prereqs.Verification.success();
-    return prereqs.Verification.failure({ message: `Timezone: ${this.timezone}` });
+    if (result.success) return prereqs.Verification.success(stopwatch.stop());
+    return prereqs.Verification.failure(stopwatch.stop(), { message: `Timezone: ${this.timezone}` });
   }
 }