@bgord/bun 1.19.12 → 1.19.14

package/src/environment-loader-noop.adapter.ts

@@ -1,9 +1,9 @@
-import {
-  type EnvironmentLoaderConfig,
-  EnvironmentLoaderError,
-  type EnvironmentLoaderPort,
-  type EnvironmentResultType,
+import type {
+  EnvironmentLoaderConfig,
+  EnvironmentLoaderPort,
+  EnvironmentResultType,
 } from "./environment-loader.port";
+import { StandardSchemaValidator } from "./standard-schema-validator.service";
 
 export class EnvironmentLoaderNoopAdapter<T extends object> implements EnvironmentLoaderPort<T> {
   constructor(
@@ -12,9 +12,9 @@ export class EnvironmentLoaderNoopAdapter<T extends object> implements Environme
   ) {}
 
   async load(): Promise<Readonly<EnvironmentResultType<T>>> {
-    const result = this.config.EnvironmentSchema["~standard"].validate(this.deterministic);
-    if (result instanceof Promise) throw new Error(EnvironmentLoaderError.NoAsyncSchema);
-    if (result.issues) throw new Error(result.issues[0]?.message);
-    return Object.freeze({ ...result.value, type: this.config.type });
+    return Object.freeze({
+      ...StandardSchemaValidator.validate(this.config.EnvironmentSchema, this.deterministic),
+      type: this.config.type,
+    });
   }
 }

package/src/environment-loader-process-safe.adapter.ts

@@ -1,11 +1,11 @@
 import type { CacheResolverStrategy } from "./cache-resolver.strategy";
-import {
-  type EnvironmentLoaderConfig,
-  EnvironmentLoaderError,
-  type EnvironmentLoaderPort,
-  type EnvironmentResultType,
+import type {
+  EnvironmentLoaderConfig,
+  EnvironmentLoaderPort,
+  EnvironmentResultType,
 } from "./environment-loader.port";
 import type { HashContentStrategy } from "./hash-content.strategy";
+import { StandardSchemaValidator } from "./standard-schema-validator.service";
 import { SubjectApplicationResolver } from "./subject-application-resolver.vo";
 import { SubjectSegmentFixedStrategy } from "./subject-segment-fixed.strategy";
 
@@ -22,12 +22,9 @@ export class EnvironmentLoaderProcessSafeAdapter<T extends object> implements En
     const resolver = new SubjectApplicationResolver([new SubjectSegmentFixedStrategy("env")], this.deps);
     const subject = await resolver.resolve();
 
-    const parsed = await this.deps.CacheResolver.resolve(subject.hex, async () => {
-      const result = this.config.EnvironmentSchema["~standard"].validate(this.env);
-      if (result instanceof Promise) throw new Error(EnvironmentLoaderError.NoAsyncSchema);
-      if (result.issues) throw new Error(result.issues[0]?.message);
-      return result.value;
-    });
+    const parsed = await this.deps.CacheResolver.resolve(subject.hex, async () =>
+      StandardSchemaValidator.validate(this.config.EnvironmentSchema, this.env),
+    );
 
     for (const key of Object.keys(parsed)) delete process.env[key];
 

package/src/environment-loader-process.adapter.ts

@@ -1,9 +1,9 @@
-import {
-  type EnvironmentLoaderConfig,
-  EnvironmentLoaderError,
-  type EnvironmentLoaderPort,
-  type EnvironmentResultType,
+import type {
+  EnvironmentLoaderConfig,
+  EnvironmentLoaderPort,
+  EnvironmentResultType,
 } from "./environment-loader.port";
+import { StandardSchemaValidator } from "./standard-schema-validator.service";
 
 export class EnvironmentLoaderProcessAdapter<T extends object> implements EnvironmentLoaderPort<T> {
   constructor(
@@ -12,9 +12,9 @@ export class EnvironmentLoaderProcessAdapter<T extends object> implements Enviro
   ) {}
 
   async load(): Promise<Readonly<EnvironmentResultType<T>>> {
-    const result = this.config.EnvironmentSchema["~standard"].validate(this.env);
-    if (result instanceof Promise) throw new Error(EnvironmentLoaderError.NoAsyncSchema);
-    if (result.issues) throw new Error(result.issues[0]?.message);
-    return Object.freeze({ ...result.value, type: this.config.type });
+    return Object.freeze({
+      ...StandardSchemaValidator.validate(this.config.EnvironmentSchema, this.env),
+      type: this.config.type,
+    });
   }
 }

package/src/environment-loader.port.ts

@@ -1,8 +1,6 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { NodeEnvironmentEnum } from "../src/node-env.vo";
 
-export const EnvironmentLoaderError = { NoAsyncSchema: "environment.loader.no.async.schema" };
-
 export type EnvironmentLoaderConfig<T extends object> = {
   type: NodeEnvironmentEnum;
   EnvironmentSchema: StandardSchemaV1<unknown, T>;

package/src/event-upcaster-chain.adapter.ts

@@ -6,6 +6,7 @@ import type { EventUpcasterStep } from "./event-upcaster-step.vo";
 const EventUpcasterChainAdapterError = {
   DuplicateStep: "event.upcaster.chain.duplicate.step",
   GapInChain: "event.upcaster.chain.gap",
+  StartOffset: "event.upcaster.chain.start.offset",
 };
 
 type EventUpcasterChainConfig = Record<GenericEvent["name"], ReadonlyArray<EventUpcasterStep<any, any>>>;
@@ -21,6 +22,10 @@ export class EventUpcasterChainAdapter implements EventUpcasterPort {
       ]),
     );
 
+    for (const [_, chain] of Object.entries(this.upcasters)) {
+      if (chain[0]?.config.fromVersion !== 1) throw new Error(EventUpcasterChainAdapterError.StartOffset);
+    }
+
     for (const chain of Object.values(this.upcasters)) {
       const versions = chain.map((step) => step.config.fromVersion);
 

package/src/event-validator-registry.adapter.ts

@@ -1,9 +1,7 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { GenericEvent } from "./event.types";
-import {
-  EventValidatorRegistryError,
-  type EventValidatorRegistryPort,
-} from "./event-validator-registry.port";
+import type { EventValidatorRegistryPort } from "./event-validator-registry.port";
+import { StandardSchemaValidator } from "./standard-schema-validator.service";
 
 export type GenericEventSchemaRegistry<Event> = Readonly<
   Record<GenericEvent["name"], StandardSchemaV1<unknown, Event>>
@@ -34,10 +32,6 @@ export class EventValidatorRegistryAdapter<Event> implements EventValidatorRegis
     const schema = this.map.get(name);
     if (!schema) throw new Error(EventValidatorRegistryAdapterError.UnknownEvent);
 
-    const result = schema["~standard"].validate(raw);
-
-    if (result instanceof Promise) throw new Error(EventValidatorRegistryError.NoAsyncSchema);
-    if (result.issues) throw new Error(result.issues[0]?.message);
-    return result.value;
+    return StandardSchemaValidator.validate(schema, raw);
   }
 }

package/src/event-validator-registry.port.ts

@@ -1,7 +1,5 @@
 import type { GenericEvent } from "./event.types";
 
-export const EventValidatorRegistryError = { NoAsyncSchema: "event.validator.registry.no.async.schema" };
-
 export interface EventValidatorRegistryPort<Event> {
   readonly names: ReadonlyArray<GenericEvent["name"]>;
 

package/src/file-uploader-hono.middleware.ts

@@ -1,10 +1,6 @@
 import { createMiddleware } from "hono/factory";
 import { HTTPException } from "hono/http-exception";
-import {
-  type FileUploaderConfig,
-  FileUploaderError,
-  FileUploaderMiddleware,
-} from "./file-uploader.middleware";
+import { type FileUploaderConfig, FileUploaderMiddleware } from "./file-uploader.middleware";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
 
 export class FileUploaderHonoMiddleware implements MiddlewareHonoPort {
@@ -21,18 +17,8 @@ export class FileUploaderHonoMiddleware implements MiddlewareHonoPort {
 
       const result = this.middleware.validate(file instanceof File ? file : null);
 
-      if (result.valid) return next();
-
-      switch (result.error) {
-        case FileUploaderError.MissingFile:
-          throw new HTTPException(400, { message: FileUploaderError.MissingFile });
-        case FileUploaderError.EmptyFile:
-          throw new HTTPException(400, { message: FileUploaderError.EmptyFile });
-        case FileUploaderError.SizeLimit:
-          throw new HTTPException(400, { message: FileUploaderError.SizeLimit });
-        case FileUploaderError.InvalidMime:
-          throw new HTTPException(400, { message: FileUploaderError.InvalidMime });
-      }
+      if (result.valid === false) throw new HTTPException(400, { message: result.error });
+      return next();
     });
   }
 }

package/src/file-uploader.middleware.ts

@@ -24,6 +24,7 @@ export class FileUploaderMiddleware {
 
     if (size.isGreaterThan(this.config.maxSize)) return { valid: false, error: FileUploaderError.SizeLimit };
 
+    // TODO: MIME spoofing possible by reading client-supplied file.type
     const mime = tools.Mime.fromString(file.type);
 
     if (!this.config.MimeRegistry.hasMime(mime)) {

package/src/graceful-shutdown.service.ts

@@ -1,9 +1,10 @@
 import * as tools from "@bgord/tools";
 import type { LoggerPort } from "./logger.port";
 
-type ServerType = ReturnType<typeof Bun.serve>;
+export type ServerType = ReturnType<typeof Bun.serve>;
 
 type Dependencies = { Logger: LoggerPort };
+type Config = { cleanup: () => Promise<void> | void; exit?: (code: number) => never };
 
 export class GracefulShutdown {
   private readonly base = { operation: "shutdown", component: "infra" } as const;
@@ -11,10 +12,10 @@ export class GracefulShutdown {
 
   constructor(
     private readonly deps: Dependencies,
-    private readonly exitFn: (code: number) => never = (code: number) => process.exit(code),
+    private readonly config: Config = { cleanup: tools.noop, exit: process.exit },
   ) {}
 
-  private shutdown(server: ServerType, cleanup: () => any, exitCode: number) {
+  private async shutdown(server: ServerType, exitCode: number) {
     // Stryker disable all
     if (this.isShuttingDown) return;
     this.isShuttingDown = true;
@@ -26,32 +27,30 @@ export class GracefulShutdown {
       this.deps.Logger.error({ message: "Server stop failed", error, ...this.base });
     }
 
-    Promise.resolve()
-      .then(() => cleanup())
-      .then(() => this.deps.Logger.info({ message: "HTTP server closed", ...this.base }))
-      .catch((error) => this.deps.Logger.error({ message: "Cleanup hook failed", error, ...this.base }))
-      .finally(() => this.exitFn(exitCode));
+    try {
+      await this.config.cleanup();
+      this.deps.Logger.info({ message: "HTTP server closed", ...this.base });
+    } catch (error) {
+      this.deps.Logger.error({ message: "Cleanup hook failed", error, ...this.base });
+    } finally {
+      this.config.exit?.(exitCode);
+    }
   }
 
-  applyTo(server: ServerType, cleanup: () => any = tools.noop) {
-    process.once("SIGTERM", () => {
-      this.deps.Logger.info({ message: "SIGTERM received", ...this.base });
-      this.shutdown(server, cleanup, 0);
-    });
-
-    process.once("SIGINT", () => {
-      this.deps.Logger.info({ message: "SIGINT received", ...this.base });
-      this.shutdown(server, cleanup, 0);
-    });
-
-    process.once("unhandledRejection", (error) => {
-      this.deps.Logger.error({ message: "UnhandledRejection received", error, ...this.base });
-      this.shutdown(server, cleanup, 1);
-    });
-
-    process.once("uncaughtException", (error) => {
-      this.deps.Logger.error({ message: "UncaughtException received", error, ...this.base });
-      this.shutdown(server, cleanup, 1);
-    });
+  applyTo(server: ServerType) {
+    const graceful = (signal: string) => () => {
+      this.deps.Logger.info({ message: `${signal} received`, ...this.base });
+      this.shutdown(server, 0);
+    };
+
+    const fatal = (event: string) => (error: unknown) => {
+      this.deps.Logger.error({ message: `${event} received`, error, ...this.base });
+      this.shutdown(server, 1);
+    };
+
+    process.once("SIGTERM", graceful("SIGTERM"));
+    process.once("SIGINT", graceful("SIGINT"));
+    process.once("unhandledRejection", fatal("UnhandledRejection"));
+    process.once("uncaughtException", fatal("UncaughtException"));
   }
 }

package/src/hostname.vo.ts

@@ -0,0 +1,15 @@
+import * as v from "valibot";
+
+export const HostnameError = {
+  Type: "hostname.type",
+  Invalid: "hostname.invalid",
+};
+
+export const Hostname = v.pipe(
+  v.string(HostnameError.Type),
+  v.domain(HostnameError.Invalid),
+  // Stryker disable next-line StringLiteral
+  v.brand("Hostname"),
+);
+
+export type HostnameType = v.InferOutput<typeof Hostname>;

package/src/http-logger.middleware.ts

@@ -44,7 +44,7 @@ export class HttpLoggerMiddleware {
   ) {}
 
   shouldSkip(context: HasRequestPath & HasRequestHeader): boolean {
-    if (context.request.header("accept") === "text/event-stream") return true;
+    if (context.request.header("accept")?.toLowerCase().startsWith("text/event-stream")) return true;
 
     return (
       this.config?.skip?.some((rule) => {

package/src/image-blur.adapter.ts

@@ -3,8 +3,13 @@ import type { FileRenamerPort } from "./file-renamer.port";
 import type { FileWriterPort } from "./file-writer.port";
 import type { ImageSupportedType } from "./image.types";
 import type { ImageBlurPort, ImageBlurStrategy } from "./image-blur.port";
+import type { NonceProviderPort } from "./nonce-provider.port";
 
-type Dependencies = { FileRenamer: FileRenamerPort; FileWriter: FileWriterPort };
+type Dependencies = {
+  FileRenamer: FileRenamerPort;
+  FileWriter: FileWriterPort;
+  NonceProvider: NonceProviderPort;
+};
 
 export class ImageBlurAdapter implements ImageBlurPort {
   constructor(private readonly deps: Dependencies) {}
@@ -13,7 +18,9 @@ export class ImageBlurAdapter implements ImageBlurPort {
     const final = recipe.strategy === "output_path" ? recipe.output : recipe.input;
 
     const filename = final.getFilename();
-    const temporary = final.withFilename(filename.withSuffix("-blurred"));
+    const temporary = final.withFilename(
+      filename.withSuffix(`-blurred-${this.deps.NonceProvider.generate()}`),
+    );
 
     const extension = final.getFilename().getExtension();
     const format = (extension === "jpg" ? "jpeg" : extension) as ImageSupportedType;

package/src/image-compressor.adapter.ts

@@ -3,8 +3,13 @@ import type { FileRenamerPort } from "./file-renamer.port";
 import type { FileWriterPort } from "./file-writer.port";
 import type { ImageSupportedType } from "./image.types";
 import type { ImageCompressorPort, ImageCompressorStrategy } from "./image-compressor.port";
+import type { NonceProviderPort } from "./nonce-provider.port";
 
-type Dependencies = { FileRenamer: FileRenamerPort; FileWriter: FileWriterPort };
+type Dependencies = {
+  FileRenamer: FileRenamerPort;
+  FileWriter: FileWriterPort;
+  NonceProvider: NonceProviderPort;
+};
 
 export class ImageCompressorAdapter implements ImageCompressorPort {
   private static readonly DEFAULT_QUALITY = 85;
@@ -16,7 +21,9 @@ export class ImageCompressorAdapter implements ImageCompressorPort {
 
     const final = recipe.strategy === "output_path" ? recipe.output : recipe.input;
     const filename = final.getFilename();
-    const temporary = final.withFilename(filename.withSuffix("-compressed"));
+    const temporary = final.withFilename(
+      filename.withSuffix(`-compressed-${this.deps.NonceProvider.generate()}`),
+    );
 
     const extension = final.getFilename().getExtension();
     const format = (extension === "jpg" ? "jpeg" : extension) as ImageSupportedType;

package/src/image-exif-clear.adapter.ts

@@ -4,15 +4,22 @@ import type { FileRenamerPort } from "./file-renamer.port";
 import type { FileWriterPort } from "./file-writer.port";
 import type { ImageSupportedType } from "./image.types";
 import type { ImageExifClearPort, ImageExifClearStrategy } from "./image-exif-clear.port";
+import type { NonceProviderPort } from "./nonce-provider.port";
 
-type Dependencies = { FileRenamer: FileRenamerPort; FileWriter: FileWriterPort };
+type Dependencies = {
+  FileRenamer: FileRenamerPort;
+  FileWriter: FileWriterPort;
+  NonceProvider: NonceProviderPort;
+};
 
 export class ImageExifClearAdapter implements ImageExifClearPort {
   constructor(private readonly deps: Dependencies) {}
 
   async clear(recipe: ImageExifClearStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
     const final = recipe.strategy === "output_path" ? recipe.output : recipe.input;
-    const temporary = final.withFilename(final.getFilename().withSuffix("-exif-cleared"));
+    const temporary = final.withFilename(
+      final.getFilename().withSuffix(`-exif-cleared-${this.deps.NonceProvider.generate()}`),
+    );
 
     const extension = final.getFilename().getExtension();
     const format = (extension === "jpg" ? "jpeg" : extension) as ImageSupportedType;

package/src/image-formatter.adapter.ts

@@ -4,11 +4,13 @@ import type { FileRenamerPort } from "./file-renamer.port";
 import type { FileWriterPort } from "./file-writer.port";
 import type { ImageSupportedType } from "./image.types";
 import type { ImageFormatterPort, ImageFormatterStrategy } from "./image-formatter.port";
+import type { NonceProviderPort } from "./nonce-provider.port";
 
 type Dependencies = {
   FileCleaner: FileCleanerPort;
   FileRenamer: FileRenamerPort;
   FileWriter: FileWriterPort;
+  NonceProvider: NonceProviderPort;
 };
 
 export class ImageFormatterAdapter implements ImageFormatterPort {
@@ -20,7 +22,9 @@ export class ImageFormatterAdapter implements ImageFormatterPort {
         ? recipe.output
         : recipe.input.withFilename(recipe.input.getFilename().withExtension(recipe.to));
 
-    const temporary = final.withFilename(final.getFilename().withSuffix("-formatted"));
+    const temporary = final.withFilename(
+      final.getFilename().withSuffix(`-formatted-${this.deps.NonceProvider.generate()}`),
+    );
 
     const extension = final.getFilename().getExtension();
     const format = (extension === "jpg" ? "jpeg" : extension) as ImageSupportedType;

package/src/image-generator-web-view.adapter.ts

@@ -8,6 +8,7 @@ export class ImageGeneratorWebViewAdapter implements ImageGeneratorPort {
   async generate(config: ImageGeneratorConfig): Promise<Uint8Array<ArrayBuffer>> {
     await using view = new Bun.WebView(config);
 
+    // TODO: Potential XSS risk
     await view.navigate(`data:text/html;charset=utf-8,${encodeURIComponent(config.template)}`);
 
     const image = await view.screenshot({

package/src/image-grayscale.adapter.ts

@@ -4,8 +4,13 @@ import type { FileRenamerPort } from "./file-renamer.port";
 import type { FileWriterPort } from "./file-writer.port";
 import type { ImageSupportedType } from "./image.types";
 import type { ImageGrayscalePort, ImageGrayscaleStrategy } from "./image-grayscale.port";
+import type { NonceProviderPort } from "./nonce-provider.port";
 
-type Dependencies = { FileRenamer: FileRenamerPort; FileWriter: FileWriterPort };
+type Dependencies = {
+  FileRenamer: FileRenamerPort;
+  FileWriter: FileWriterPort;
+  NonceProvider: NonceProviderPort;
+};
 
 export class ImageGrayscaleAdapter implements ImageGrayscalePort {
   constructor(private readonly deps: Dependencies) {}
@@ -14,7 +19,9 @@ export class ImageGrayscaleAdapter implements ImageGrayscalePort {
     const final = recipe.strategy === "output_path" ? recipe.output : recipe.input;
 
     const filename = final.getFilename();
-    const temporary = final.withFilename(filename.withSuffix("-grayscale"));
+    const temporary = final.withFilename(
+      filename.withSuffix(`-grayscale-${this.deps.NonceProvider.generate()}`),
+    );
 
     const extension = final.getFilename().getExtension();
     const format = (extension === "jpg" ? "jpeg" : extension) as ImageSupportedType;

package/src/image-processor.adapter.ts

@@ -4,11 +4,13 @@ import type { FileRenamerPort } from "./file-renamer.port";
 import type { FileWriterPort } from "./file-writer.port";
 import type { ImageSupportedType } from "./image.types";
 import type { ImageProcessorPort, ImageProcessorStrategy } from "./image-processor.port";
+import type { NonceProviderPort } from "./nonce-provider.port";
 
 type Dependencies = {
   FileCleaner: FileCleanerPort;
   FileRenamer: FileRenamerPort;
   FileWriter: FileWriterPort;
+  NonceProvider: NonceProviderPort;
 };
 
 export class ImageProcessorAdapter implements ImageProcessorPort {
@@ -22,7 +24,9 @@ export class ImageProcessorAdapter implements ImageProcessorPort {
         ? recipe.output
         : recipe.input.withFilename(recipe.input.getFilename().withExtension(recipe.to));
 
-    const temporary = final.withFilename(final.getFilename().withSuffix("-processed"));
+    const temporary = final.withFilename(
+      final.getFilename().withSuffix(`-processed-${this.deps.NonceProvider.generate()}`),
+    );
     const extension = final.getFilename().getExtension();
     const format = (extension === "jpg" ? "jpeg" : extension) as ImageSupportedType;
     const quality = recipe.quality ?? ImageProcessorAdapter.DEFAULT_QUALITY;

package/src/image-resizer.adapter.ts

@@ -4,8 +4,13 @@ import type { FileRenamerPort } from "./file-renamer.port";
 import type { FileWriterPort } from "./file-writer.port";
 import type { ImageSupportedType } from "./image.types";
 import type { ImageResizerPort, ImageResizerStrategy } from "./image-resizer.port";
+import type { NonceProviderPort } from "./nonce-provider.port";
 
-type Dependencies = { FileWriter: FileWriterPort; FileRenamer: FileRenamerPort };
+type Dependencies = {
+  FileWriter: FileWriterPort;
+  FileRenamer: FileRenamerPort;
+  NonceProvider: NonceProviderPort;
+};
 
 export class ImageResizerAdapter implements ImageResizerPort {
   constructor(private readonly deps: Dependencies) {}
@@ -13,7 +18,9 @@ export class ImageResizerAdapter implements ImageResizerPort {
   async resize(recipe: ImageResizerStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
     const final = recipe.strategy === "output_path" ? recipe.output : recipe.input;
     const filename = final.getFilename();
-    const temporary = final.withFilename(filename.withSuffix("-resized"));
+    const temporary = final.withFilename(
+      filename.withSuffix(`-resized-${this.deps.NonceProvider.generate()}`),
+    );
 
     const extension = final.getFilename().getExtension();
     const format = (extension === "jpg" ? "jpeg" : extension) as ImageSupportedType;

package/src/image.types.ts

@@ -1 +1 @@
-export type ImageSupportedType = Exclude<Bun.Image.Format, "bmp" | "tiff" | "gif">;
+export type ImageSupportedType = "jpeg" | "png" | "webp";

package/src/index.ts

@@ -10,6 +10,7 @@ export * from "./ab-assignment-query.strategy";
 export * from "./ab-hono.middleware";
 export * from "./ab-hono-noop.middleware";
 export * from "./ab-variant.vo";
+export * from "./ab-variant-name.vo";
 export * from "./ab-variant-selector.service";
 export * from "./ab-variant-weight.vo";
 export * from "./ab-variants.vo";
@@ -201,6 +202,7 @@ export * from "./hcaptcha-secret-key.vo";
 export * from "./hcaptcha-site-key.vo";
 export * from "./healthcheck.handler";
 export * from "./healthcheck-hono.handler";
+export * from "./hostname.vo";
 export * from "./http-logger.middleware";
 export * from "./http-logger-hono.middleware";
 export * from "./id-provider.port";

package/src/job-registry.adapter.ts

@@ -1,7 +1,8 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { GenericJob } from "./job.types";
-import { type JobHandler, JobRegistryError, type JobRegistryPort } from "./job-registry.port";
+import type { JobHandler, JobRegistryPort } from "./job-registry.port";
 import type { JobRetryPolicyStrategy } from "./job-retry-policy.strategy";
+import { StandardSchemaValidator } from "./standard-schema-validator.service";
 
 export type JobRegistryEntry<Specific extends GenericJob> = {
   schema: StandardSchemaV1<unknown, Specific>;
@@ -38,11 +39,7 @@ export class JobRegistryAdapter<Job extends GenericJob> implements JobRegistryPo
     const entry = this.map.get(name);
     if (!entry) throw new Error(JobRegistryAdapterError.UnknownJob);
 
-    const result = entry.schema["~standard"].validate(raw);
-
-    if (result instanceof Promise) throw new Error(JobRegistryError.NoAsyncSchema);
-    if (result.issues) throw new Error(result.issues[0]?.message);
-    return result.value;
+    return StandardSchemaValidator.validate(entry.schema, raw);
   }
 
   getRetryPolicy(name: GenericJob["name"]): JobRetryPolicyStrategy {

package/src/job-registry.port.ts

@@ -1,8 +1,6 @@
 import type { GenericJob } from "./job.types";
 import type { JobRetryPolicyStrategy } from "./job-retry-policy.strategy";
 
-export const JobRegistryError = { NoAsyncSchema: "job.registry.no.async.schema" };
-
 export type JobHandler<Job extends GenericJob> = (job: Job) => Promise<void>;
 
 export interface JobRegistryPort<Job extends GenericJob> {

package/src/prerequisite-verifier-binary.adapter.ts

@@ -15,7 +15,7 @@ export class PrerequisiteVerifierBinaryAdapter implements PrerequisiteVerifierPo
       const result = Bun.which(this.config.binary);
 
       if (result) return PrerequisiteVerification.success;
-      return PrerequisiteVerification.failure();
+      return PrerequisiteVerification.failure("Binary not present");
     } catch (error) {
       return PrerequisiteVerification.failure(error);
     }

package/src/prerequisite-verifier-dns.adapter.ts

@@ -1,11 +1,12 @@
 import dns from "node:dns/promises";
+import type { HostnameType } from "./hostname.vo";
 import {
   PrerequisiteVerification,
   type PrerequisiteVerificationResult,
   type PrerequisiteVerifierPort,
 } from "./prerequisite-verifier.port";
 
-type Config = { hostname: string };
+type Config = { hostname: HostnameType };
 
 export class PrerequisiteVerifierDnsAdapter implements PrerequisiteVerifierPort {
   constructor(private readonly config: Config) {}

package/src/prerequisite-verifier-ssl-certificate-expiry.adapter.ts

@@ -1,5 +1,6 @@
 import type * as tools from "@bgord/tools";
 import type { CertificateInspectorPort } from "./certificate-inspector.port";
+import type { HostnameType } from "./hostname.vo";
 import {
   PrerequisiteVerification,
   type PrerequisiteVerificationResult,
@@ -8,7 +9,7 @@ import {
 
 type Dependencies = { CertificateInspector: CertificateInspectorPort };
 
-type Config = { hostname: string; minimum: tools.Duration };
+type Config = { hostname: HostnameType; minimum: tools.Duration };
 
 export class PrerequisiteVerifierSSLCertificateExpiryAdapter implements PrerequisiteVerifierPort {
   constructor(

package/src/prerequisite-verifier-translations.adapter.ts

@@ -41,14 +41,14 @@ export class PrerequisiteVerifierTranslationsAdapter<T extends tools.LanguageTyp
 
     for (const language in dictionary) {
       // Stryker disable all
-      const phrases = dictionary[language] ?? [];
+      const translations = dictionary[language] ?? [];
       // Stryker restore all
 
-      for (const phrase of phrases) {
+      for (const key of translations) {
         for (const supportedLanguage of languages) {
-          const phraseExists = new Set(dictionary[supportedLanguage]).has(phrase);
+          const exists = new Set(dictionary[supportedLanguage]).has(key);
 
-          if (!phraseExists) problems.push({ key: phrase, existsIn: language, missingIn: supportedLanguage });
+          if (!exists) problems.push({ key, existsIn: language, missingIn: supportedLanguage });
         }
       }
     }

package/src/reactive-config-file-json.adapter.ts

@@ -1,10 +1,7 @@
 import type * as tools from "@bgord/tools";
 import type { FileReaderJsonPort } from "./file-reader-json.port";
-import {
-  ReactiveConfigError,
-  type ReactiveConfigPort,
-  type ReactiveConfigSchema,
-} from "./reactive-config.port";
+import type { ReactiveConfigPort, ReactiveConfigSchema } from "./reactive-config.port";
+import { StandardSchemaValidator } from "./standard-schema-validator.service";
 
 type Dependencies = { FileReaderJson: FileReaderJsonPort };
 
@@ -18,9 +15,6 @@ export class ReactiveConfigFileJsonAdapter<T extends object> implements Reactive
   async get(): Promise<Readonly<T>> {
     const raw = await this.deps.FileReaderJson.read(this.path);
 
-    const result = this.schema["~standard"].validate(raw);
-    if (result instanceof Promise) throw new Error(ReactiveConfigError.NoAsyncSchema);
-    if (result.issues) throw new Error(result.issues[0]?.message);
-    return Object.freeze(result.value);
+    return Object.freeze(StandardSchemaValidator.validate(this.schema, raw));
   }
 }