@bgord/bun 0.7.0 → 0.8.1

package/src/prerequisites/binary.ts

@@ -1,35 +1,31 @@
 import bun from "bun";
 import { z } from "zod/v4";
 
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import * as prereqs from "../prerequisites.service";
 
 const PrerequisiteBinaryValue = z
   .string()
   .min(1)
   .max(64)
   .refine((value) => !value.includes(" "));
+
 type PrerequisiteBinaryValueType = z.infer<typeof PrerequisiteBinaryValue>;
 
 type PrerequisiteBinaryConfigType = {
   binary: PrerequisiteBinaryValueType;
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
 };
 
-export class PrerequisiteBinary extends AbstractPrerequisite<PrerequisiteBinaryConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.binary;
+export class PrerequisiteBinary extends prereqs.AbstractPrerequisite<PrerequisiteBinaryConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.binary;
 
   constructor(readonly config: PrerequisiteBinaryConfigType) {
     super(config);
   }
 
   async verify() {
-    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
 
     try {
       const binary = PrerequisiteBinaryValue.parse(this.config.binary);

package/src/prerequisites/bun.ts

@@ -1,27 +1,24 @@
 import * as tools from "@bgord/tools";
 
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import * as prereqs from "../prerequisites.service";
 
 type PrerequisiteBunConfigType = {
   version: tools.PackageVersion;
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
   current: string;
 };
 
-export class PrerequisiteBun extends AbstractPrerequisite<PrerequisiteBunConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.bun;
+export class PrerequisiteBun extends prereqs.AbstractPrerequisite<PrerequisiteBunConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.bun;
 
   constructor(readonly config: PrerequisiteBunConfigType) {
     super(config);
   }
 
-  async verify(): Promise<PrerequisiteStatusEnum> {
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
+
     const current = tools.PackageVersion.fromString(this.config.current);
 
     if (current.isGreaterThanOrEqual(this.config.version)) {

package/src/prerequisites/dependency-vulnerabilities.ts

@@ -0,0 +1,54 @@
+import bun from "bun";
+
+import {
+  AbstractPrerequisite,
+  PrerequisiteLabelType,
+  PrerequisiteStatusEnum,
+  PrerequisiteStrategyEnum,
+} from "../prerequisites.service";
+
+type PrerequisiteDependencyVulnerabilityConfigType = {
+  label: PrerequisiteLabelType;
+  enabled?: boolean;
+};
+
+type BunAuditOutput = {
+  [packageName: string]: {
+    severity: "low" | "moderate" | "high" | "critical";
+  }[];
+};
+
+export class PrerequisiteDependencyVulnerabilities extends AbstractPrerequisite<PrerequisiteDependencyVulnerabilityConfigType> {
+  readonly strategy = PrerequisiteStrategyEnum.dependencyVulnerabilities;
+
+  constructor(readonly config: PrerequisiteDependencyVulnerabilityConfigType) {
+    super(config);
+  }
+
+  async verify(): Promise<PrerequisiteStatusEnum> {
+    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+
+    try {
+      const result = await bun.$`bun audit --json`;
+
+      if (result.exitCode !== 0) return this.reject();
+
+      const audit = JSON.parse(result.stdout.toString()) as BunAuditOutput;
+
+      const criticalVulnerabilitiesCount = Object.values(audit).filter((name) =>
+        name.some((vulnerability) => vulnerability.severity === "critical"),
+      ).length;
+
+      const highVulnerabilitiesCount = Object.values(audit).filter((name) =>
+        name.some((vulnerability) => vulnerability.severity === "high"),
+      ).length;
+
+      if (criticalVulnerabilitiesCount > 0 || highVulnerabilitiesCount > 0) {
+        return this.reject();
+      }
+      return this.pass();
+    } catch (error) {
+      return this.reject();
+    }
+  }
+}

package/src/prerequisites/external-api.ts

@@ -0,0 +1,27 @@
+import * as prereqs from "../prerequisites.service";
+
+type PrerequisiteExternalApiConnectivityConfigType = {
+  label: prereqs.PrerequisiteLabelType;
+  enabled?: boolean;
+  request: () => Promise<Response>;
+};
+
+export class PrerequisiteExternalApi extends prereqs.AbstractPrerequisite<PrerequisiteExternalApiConnectivityConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.externalApi;
+
+  constructor(readonly config: PrerequisiteExternalApiConnectivityConfigType) {
+    super(config);
+  }
+
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
+
+    try {
+      const result = await this.config.request();
+
+      return result.ok ? this.pass() : this.reject();
+    } catch (error) {
+      return this.reject();
+    }
+  }
+}

package/src/prerequisites/index.ts

@@ -1,5 +1,7 @@
 export * from "./binary";
 export * from "./bun";
+export * from "./dependency-vulnerabilities";
+export * from "./external-api";
 export * from "./jobs";
 export * from "./log-file";
 export * from "./mailer";

package/src/prerequisites/jobs.ts

@@ -1,27 +1,21 @@
-import { Jobs, MultipleJobsType } from "../jobs";
-
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import { Jobs, MultipleJobsType } from "../jobs.service";
+import * as prereqs from "../prerequisites.service";
 
 type PrerequisiteJobsConfigType = {
   jobs: MultipleJobsType;
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
 };
 
-export class PrerequisiteJobs extends AbstractPrerequisite<PrerequisiteJobsConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.jobs;
+export class PrerequisiteJobs extends prereqs.AbstractPrerequisite<PrerequisiteJobsConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.jobs;
 
   constructor(readonly config: PrerequisiteJobsConfigType) {
     super(config);
   }
 
-  async verify(): Promise<PrerequisiteStatusEnum> {
-    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
 
     return Jobs.areAllRunning(this.config.jobs) ? this.pass() : this.reject();
   }

package/src/prerequisites/log-file.ts

@@ -1,26 +1,21 @@
-import { Logger } from "../logger";
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import { Logger } from "../logger.service";
+import * as prereqs from "../prerequisites.service";
 
 type PrerequisiteLogFileConfigType = {
   logger: Logger;
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
 };
 
-export class PrerequisiteLogFile extends AbstractPrerequisite<PrerequisiteLogFileConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.logFile;
+export class PrerequisiteLogFile extends prereqs.AbstractPrerequisite<PrerequisiteLogFileConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.logFile;
 
   constructor(readonly config: PrerequisiteLogFileConfigType) {
     super(config);
   }
 
-  async verify(): Promise<PrerequisiteStatusEnum> {
-    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
 
     try {
       const path = this.config.logger.getProductionLogFilePath();

package/src/prerequisites/mailer.ts

@@ -1,26 +1,21 @@
-import { Mailer } from "../mailer";
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import { Mailer } from "../mailer.service";
+import * as prereqs from "../prerequisites.service";
 
 type PrerequisiteMailerConfigType = {
   mailer: Mailer;
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
 };
 
-export class PrerequisiteMailer extends AbstractPrerequisite<PrerequisiteMailerConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.mailer;
+export class PrerequisiteMailer extends prereqs.AbstractPrerequisite<PrerequisiteMailerConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.mailer;
 
   constructor(readonly config: PrerequisiteMailerConfigType) {
     super(config);
   }
 
-  async verify(): Promise<PrerequisiteStatusEnum> {
-    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
 
     try {
       await this.config.mailer.verify();

package/src/prerequisites/memory.ts

@@ -1,28 +1,23 @@
 import * as tools from "@bgord/tools";
-import { MemoryConsumption } from "../memory-consumption";
 
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import { MemoryConsumption } from "../memory-consumption.service";
+import * as prereqs from "../prerequisites.service";
 
 type PrerequisiteMemoryConfigType = {
   maximum: tools.Size;
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
 };
 
-export class PrerequisiteMemory extends AbstractPrerequisite<PrerequisiteMemoryConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.memory;
+export class PrerequisiteMemory extends prereqs.AbstractPrerequisite<PrerequisiteMemoryConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.memory;
 
   constructor(readonly config: PrerequisiteMemoryConfigType) {
     super(config);
   }
 
-  async verify(): Promise<PrerequisiteStatusEnum> {
-    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
 
     const memoryConsumption = MemoryConsumption.get();
 

package/src/prerequisites/node.ts

@@ -1,28 +1,23 @@
 import * as tools from "@bgord/tools";
 import bun from "bun";
 
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import * as prereqs from "../prerequisites.service";
 
 type PrerequisiteNodeConfigType = {
   version: tools.PackageVersion;
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
 };
 
-export class PrerequisiteNode extends AbstractPrerequisite<PrerequisiteNodeConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.node;
+export class PrerequisiteNode extends prereqs.AbstractPrerequisite<PrerequisiteNodeConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.node;
 
   constructor(readonly config: PrerequisiteNodeConfigType) {
     super(config);
   }
 
-  async verify(): Promise<PrerequisiteStatusEnum> {
-    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
 
     const { stdout } = await bun.$`node -v`;
     const version = stdout.toString().trim();

package/src/prerequisites/outside-connectivity.ts

@@ -1,24 +1,19 @@
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import * as prereqs from "../prerequisites.service";
 
 type PrerequisiteOutsideConnectivityConfigType = {
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
 };
 
-export class PrerequisiteOutsideConnectivity extends AbstractPrerequisite<PrerequisiteOutsideConnectivityConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.outsideConnectivity;
+export class PrerequisiteOutsideConnectivity extends prereqs.AbstractPrerequisite<PrerequisiteOutsideConnectivityConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.outsideConnectivity;
 
   constructor(readonly config: PrerequisiteOutsideConnectivityConfigType) {
     super(config);
   }
 
-  async verify(): Promise<PrerequisiteStatusEnum> {
-    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
 
     try {
       const result = await fetch("https://google.com");

package/src/prerequisites/path.ts

@@ -1,29 +1,24 @@
 import { constants } from "node:fs";
 import fsp from "node:fs/promises";
 
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import * as prereqs from "../prerequisites.service";
 
 type PrerequisitePathConfigType = {
   path: string;
   access?: { write?: boolean; execute?: boolean };
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
 };
 
-export class PrerequisitePath extends AbstractPrerequisite<PrerequisitePathConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.path;
+export class PrerequisitePath extends prereqs.AbstractPrerequisite<PrerequisitePathConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.path;
 
   constructor(readonly config: PrerequisitePathConfigType) {
     super(config);
   }
 
-  async verify(): Promise<PrerequisiteStatusEnum> {
-    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
 
     const write = this.config.access?.write ?? false;
     const execute = this.config.access?.execute ?? false;

package/src/prerequisites/port.ts

@@ -1,29 +1,23 @@
 import net from "node:net";
 
-import type { PortType } from "../port";
-
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import type { PortType } from "../port.vo";
+import * as prereqs from "../prerequisites.service";
 
 type PrerequisitePortConfigType = {
   port: PortType;
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
 };
 
-export class PrerequisitePort extends AbstractPrerequisite<PrerequisitePortConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.port;
+export class PrerequisitePort extends prereqs.AbstractPrerequisite<PrerequisitePortConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.port;
 
   constructor(readonly config: PrerequisitePortConfigType) {
     super(config);
   }
 
-  async verify(): Promise<PrerequisiteStatusEnum> {
-    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
 
     return new Promise((resolve) => {
       const server = net.createServer();
@@ -31,13 +25,13 @@ export class PrerequisitePort extends AbstractPrerequisite<PrerequisitePortConfi
       server.listen(this.config.port, () =>
         server.close(() => {
           this.pass();
-          return resolve(PrerequisiteStatusEnum.success);
+          return resolve(prereqs.PrerequisiteStatusEnum.success);
         }),
       );
 
       server.on("error", () => {
         this.reject();
-        return resolve(PrerequisiteStatusEnum.failure);
+        return resolve(prereqs.PrerequisiteStatusEnum.failure);
       });
     });
   }

package/src/prerequisites/ram.ts

@@ -1,28 +1,23 @@
 import os from "node:os";
 import * as tools from "@bgord/tools";
 
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import * as prereqs from "../prerequisites.service";
 
 type PrerequisiteRAMConfigType = {
   minimum: tools.Size;
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
 };
 
-export class PrerequisiteRAM extends AbstractPrerequisite<PrerequisiteRAMConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.RAM;
+export class PrerequisiteRAM extends prereqs.AbstractPrerequisite<PrerequisiteRAMConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.RAM;
 
   constructor(readonly config: PrerequisiteRAMConfigType) {
     super(config);
   }
 
-  async verify(): Promise<PrerequisiteStatusEnum> {
-    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
 
     const freeRAM = new tools.Size({
       unit: tools.SizeUnit.b,

package/src/prerequisites/self.ts

@@ -1,24 +1,19 @@
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import * as prereqs from "../prerequisites.service";
 
 type PrerequisiteSelfConfigType = {
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
 };
 
-export class PrerequisiteSelf extends AbstractPrerequisite<PrerequisiteSelfConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.self;
+export class PrerequisiteSelf extends prereqs.AbstractPrerequisite<PrerequisiteSelfConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.self;
 
   constructor(readonly config: PrerequisiteSelfConfigType) {
     super(config);
   }
 
-  async verify(): Promise<PrerequisiteStatusEnum> {
-    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
     return this.pass();
   }
 }

package/src/prerequisites/space.ts

@@ -2,28 +2,23 @@ import path from "node:path";
 import * as tools from "@bgord/tools";
 import checkDiskSpace from "check-disk-space";
 
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import * as prereqs from "../prerequisites.service";
 
 type PrerequisiteSpaceConfigType = {
   minimum: tools.Size;
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
 };
 
-export class PrerequisiteSpace extends AbstractPrerequisite<PrerequisiteSpaceConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.space;
+export class PrerequisiteSpace extends prereqs.AbstractPrerequisite<PrerequisiteSpaceConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.space;
 
   constructor(readonly config: PrerequisiteSpaceConfigType) {
     super(config);
   }
 
-  async verify(): Promise<PrerequisiteStatusEnum> {
-    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
 
     const fsRoot = path.sep;
     const bytes = await checkDiskSpace(fsRoot);

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

@@ -1,33 +1,28 @@
 import sslChecker from "ssl-checker";
 
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import * as prereqs from "../prerequisites.service";
 
 type PrerequisiteSSLCertificateExpiryConfigType = {
   host: string;
   validDaysMinimum: number;
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
 };
 
-export class PrerequisiteSSLCertificateExpiry extends AbstractPrerequisite<PrerequisiteSSLCertificateExpiryConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.sslCertificateExpiry;
+export class PrerequisiteSSLCertificateExpiry extends prereqs.AbstractPrerequisite<PrerequisiteSSLCertificateExpiryConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.sslCertificateExpiry;
 
   constructor(readonly config: PrerequisiteSSLCertificateExpiryConfigType) {
     super(config);
   }
 
-  async verify(): Promise<PrerequisiteStatusEnum> {
-    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
 
     try {
       const result = await sslChecker(this.config.host);
 
-      if (!result.valid) return PrerequisiteStatusEnum.failure;
+      if (!result.valid) return prereqs.PrerequisiteStatusEnum.failure;
 
       return result.daysRemaining <= this.config.validDaysMinimum ? this.reject() : this.pass();
     } catch (error) {

package/src/prerequisites/timezone-utc.ts

@@ -1,30 +1,25 @@
 import * as tools from "@bgord/tools";
 import { z } from "zod/v4";
 
-import {
-  AbstractPrerequisite,
-  PrerequisiteLabelType,
-  PrerequisiteStatusEnum,
-  PrerequisiteStrategyEnum,
-} from "../prerequisites";
+import * as prereqs from "../prerequisites.service";
 
 type PrerequisiteTimezoneUtcConfigType = {
   timezone: tools.TimezoneType;
-  label: PrerequisiteLabelType;
+  label: prereqs.PrerequisiteLabelType;
   enabled?: boolean;
 };
 
 export const TimezoneUtc = z.literal("UTC");
 
-export class PrerequisiteTimezoneUTC extends AbstractPrerequisite<PrerequisiteTimezoneUtcConfigType> {
-  readonly strategy = PrerequisiteStrategyEnum.timezoneUTC;
+export class PrerequisiteTimezoneUTC extends prereqs.AbstractPrerequisite<PrerequisiteTimezoneUtcConfigType> {
+  readonly strategy = prereqs.PrerequisiteStrategyEnum.timezoneUTC;
 
   constructor(readonly config: PrerequisiteTimezoneUtcConfigType) {
     super(config);
   }
 
-  async verify(): Promise<PrerequisiteStatusEnum> {
-    if (!this.enabled) return PrerequisiteStatusEnum.undetermined;
+  async verify(): Promise<prereqs.PrerequisiteStatusEnum> {
+    if (!this.enabled) return prereqs.PrerequisiteStatusEnum.undetermined;
 
     try {
       TimezoneUtc.parse(this.config.timezone);