@bgord/bun 1.14.7 → 1.15.0

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

@@ -1,7 +1,8 @@
-import type {
-  EnvironmentLoaderConfig,
-  EnvironmentLoaderPort,
-  EnvironmentResultType,
+import {
+  type EnvironmentLoaderConfig,
+  EnvironmentLoaderError,
+  type EnvironmentLoaderPort,
+  type EnvironmentResultType,
 } from "./environment-loader.port";
 
 export class EnvironmentLoaderProcessAdapter<T extends object> implements EnvironmentLoaderPort<T> {
@@ -11,6 +12,10 @@ export class EnvironmentLoaderProcessAdapter<T extends object> implements Enviro
   ) {}
 
   async load(): Promise<Readonly<EnvironmentResultType<T>>> {
-    return Object.freeze({ ...this.config.EnvironmentSchema.parse(this.env), type: this.config.type });
+    const result = this.config.EnvironmentSchema["~standard"].validate(this.env);
+    if (result instanceof Promise) throw new Error(EnvironmentLoaderError.NoAsyncSchema);
+    // Stryker disable next-line OptionalChaining
+    if (result.issues) throw new Error(result.issues[0]?.message);
+    return Object.freeze({ ...result.value, type: this.config.type });
   }
 }

package/src/environment-loader.port.ts

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

package/src/event-envelope.ts

@@ -1,5 +1,5 @@
 import * as tools from "@bgord/tools";
-import * as z from "zod/v4";
+import * as v from "valibot";
 import type { ClockPort } from "./clock.port";
 import { CorrelationStorage } from "./correlation-storage.service";
 import { EventStream, type EventStreamType } from "./event-stream.vo";
@@ -13,8 +13,8 @@ export const EventEnvelopeSchema = {
   correlationId: UUID,
   createdAt: tools.TimestampValue,
   stream: EventStream,
-  version: z.literal(1),
-  revision: tools.RevisionValue.optional(),
+  version: v.literal(1),
+  revision: v.optional(tools.RevisionValue),
 };
 
 export const createEventEnvelope = (stream: EventStreamType, deps: Dependencies) =>

package/src/event-store-with-logger.adapter.ts

@@ -40,6 +40,7 @@ export class EventStoreWithLoggerAdapter<Event extends GenericEvent> implements
       component: "infra",
       operation: "event_store_save",
       correlationId: CorrelationStorage.get(),
+      // Stryker disable next-line OptionalChaining
       metadata: { stream: events[0]?.stream, names: events.map((event) => event.name), count: events.length },
     });
 

package/src/event-stream.vo.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 
 export const EventStreamError = {
   Type: "event.store.type",
@@ -6,9 +6,10 @@ export const EventStreamError = {
   TooLong: "event.stream.too.long",
 };
 
-export const EventStream = z
-  .string(EventStreamError.Type)
-  .min(1, EventStreamError.Empty)
-  .max(256, EventStreamError.TooLong);
+export const EventStream = v.pipe(
+  v.string(EventStreamError.Type),
+  v.minLength(1, EventStreamError.Empty),
+  v.maxLength(256, EventStreamError.TooLong),
+);
 
-export type EventStreamType = z.infer<typeof EventStream>;
+export type EventStreamType = v.InferOutput<typeof EventStream>;

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

@@ -0,0 +1,44 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { GenericEvent } from "./event.types";
+import {
+  EventValidatorRegistryError,
+  type EventValidatorRegistryPort,
+} from "./event-validator-registry.port";
+
+export type GenericEventSchemaRegistry<Event> = Readonly<
+  Record<GenericEvent["name"], StandardSchemaV1<unknown, Event>>
+>;
+
+const EventValidatorRegistryAdapterError = {
+  MissingName: "event.validator.registry.adapter.error.missing.name",
+  UnknownEvent: "event.validator.registry.adapter.error.unknown.event",
+};
+
+export class EventValidatorRegistryAdapter<Event> implements EventValidatorRegistryPort<Event> {
+  private readonly map: Map<GenericEvent["name"], StandardSchemaV1<unknown, Event>>;
+  readonly names: ReadonlyArray<GenericEvent["name"]>;
+
+  constructor(registry: GenericEventSchemaRegistry<Event>) {
+    this.map = new Map(Object.entries(registry));
+    this.names = Object.keys(registry);
+  }
+
+  accepts(name: GenericEvent["name"]): boolean {
+    return this.map.has(name);
+  }
+
+  validate(raw: unknown): Event {
+    const name = (raw as { name?: GenericEvent["name"] }).name;
+    if (!name) throw new Error(EventValidatorRegistryAdapterError.MissingName);
+
+    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);
+    // Stryker disable next-line OptionalChaining
+    if (result.issues) throw new Error(result.issues[0]?.message);
+    return result.value;
+  }
+}

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

@@ -1,5 +1,7 @@
 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-draft-zip.service.ts

@@ -1,5 +1,6 @@
 import { Readable } from "node:stream";
 import * as tools from "@bgord/tools";
+import * as v from "valibot";
 import { DynamicImport } from "./dynamic-import.service";
 import { FileDraft } from "./file-draft.service";
 
@@ -20,7 +21,7 @@ export class FileDraftZip extends FileDraft {
     private readonly parts: ReadonlyArray<FileDraft>,
     private readonly yazl: YazlLibrary,
   ) {
-    super(basename, tools.Extension.parse("zip"), tools.Mimes.zip.mime);
+    super(basename, v.parse(tools.Extension, "zip"), tools.Mimes.zip.mime);
   }
 
   static async build(basename: tools.BasenameType, parts: ReadonlyArray<FileDraft>): Promise<FileDraftZip> {

package/src/hash-bucket.vo.ts

@@ -1,4 +1,5 @@
 import * as tools from "@bgord/tools";
+import * as v from "valibot";
 import type { Hash } from "./hash.vo";
 
 export class HashBucket {
@@ -10,7 +11,7 @@ export class HashBucket {
 
     const bucket = integer % 100;
 
-    return new HashBucket(tools.IntegerNonNegative.parse(bucket));
+    return new HashBucket(v.parse(tools.IntegerNonNegative, bucket));
   }
 
   isLessThan(threshold: tools.IntegerNonNegativeType): boolean {

package/src/hash-value.vo.ts

@@ -1,15 +1,15 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 
 export const HashValueError = { Type: "hash.value.type", InvalidHex: "hash.value.invalid.hex" } as const;
 
 // 64 hex chars allowed
 const CHARS_WHITELIST = /^[a-fA-F0-9]{64}$/;
 
-// Stryker disable all
-export const HashValue = z
-  // Stryker restore all
-  .string(HashValueError.Type)
-  .regex(CHARS_WHITELIST, HashValueError.InvalidHex)
-  .brand("HashValue");
+export const HashValue = v.pipe(
+  v.string(HashValueError.Type),
+  v.regex(CHARS_WHITELIST, HashValueError.InvalidHex),
+  // Stryker disable next-line StringLiteral
+  v.brand("HashValue"),
+);
 
-export type HashValueType = z.infer<typeof HashValue>;
+export type HashValueType = v.InferOutput<typeof HashValue>;

package/src/hash.vo.ts

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import { HashValue, type HashValueType } from "./hash-value.vo";
 
 export class Hash {
@@ -12,7 +13,7 @@ export class Hash {
   }
 
   static fromString(candidate: string): Hash {
-    return new Hash(HashValue.parse(candidate));
+    return new Hash(v.parse(HashValue, candidate));
   }
 
   get(): HashValueType {

package/src/hcaptcha-secret-key.vo.ts

@@ -1,15 +1,15 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 
 export const HCaptchaSecretKeyError = {
   Type: "hcaptcha.secret.key.type",
   Length: "hcaptcha.secret.key.length",
 };
 
-// Stryker disable all
-export const HCaptchaSecretKey = z
-  // Stryker restore all
-  .string(HCaptchaSecretKeyError.Type)
-  .length(35, HCaptchaSecretKeyError.Length)
-  .brand("HCaptchaSecretKey");
+export const HCaptchaSecretKey = v.pipe(
+  v.string(HCaptchaSecretKeyError.Type),
+  v.length(35, HCaptchaSecretKeyError.Length),
+  // Stryker disable next-line StringLiteral
+  v.brand("HCaptchaSecretKey"),
+);
 
-export type HCaptchaSecretKeyType = z.infer<typeof HCaptchaSecretKey>;
+export type HCaptchaSecretKeyType = v.InferOutput<typeof HCaptchaSecretKey>;

package/src/hcaptcha-site-key.vo.ts

@@ -1,12 +1,12 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 
 export const HCaptchaSiteKeyError = { Type: "hcaptcha.site.key.type", Length: "hcaptcha.site.key.length" };
 
-// Stryker disable all
-export const HCaptchaSiteKey = z
-  // Stryker restore all
-  .string(HCaptchaSiteKeyError.Type)
-  .length(36, HCaptchaSiteKeyError.Length)
-  .brand("HCaptchaSiteKey");
+export const HCaptchaSiteKey = v.pipe(
+  v.string(HCaptchaSiteKeyError.Type),
+  v.length(36, HCaptchaSiteKeyError.Length),
+  // Stryker disable next-line StringLiteral
+  v.brand("HCaptchaSiteKey"),
+);
 
-export type HCaptchaSiteKeyType = z.infer<typeof HCaptchaSiteKey>;
+export type HCaptchaSiteKeyType = v.InferOutput<typeof HCaptchaSiteKey>;

package/src/healthcheck.handler.ts

@@ -1,5 +1,6 @@
 import os from "node:os";
 import * as tools from "@bgord/tools";
+import * as v from "valibot";
 import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
 import type { ClockPort } from "./clock.port";
 import type { CommitShaValueType } from "./commit-sha-value.vo";
@@ -48,7 +49,7 @@ export type HealthcheckResult = {
     hostname: ReturnType<typeof os.hostname>;
     cpus: tools.IntegerNonNegativeType;
     startup: tools.TimestampValueType;
-    uptime: Omit<UptimeResultType, "duration"> & { durationMs: tools.DurationMsType };
+    uptime: Omit<UptimeResultType, "duration"> & { ms: tools.DurationMsType };
     memory: {
       total: { bytes: tools.Size["bytes"]; formatted: ReturnType<tools.Size["format"]> };
       heap: {
@@ -65,10 +66,10 @@ export type HealthcheckResult = {
   details: ReadonlyArray<{
     label: PrerequisiteLabelType;
     outcome: PrerequisiteVerificationResult;
-    durationMs: tools.DurationMsType;
+    ms: tools.DurationMsType;
   }>;
   logger?: LoggerStatsSnapshot;
-  durationMs: tools.Duration["ms"];
+  ms: tools.Duration["ms"];
   timestamp: tools.TimestampValueType;
 };
 
@@ -94,7 +95,7 @@ export class HealthcheckHandler {
         return {
           label: prerequisite.label,
           outcome: this.config.redactor ? this.config.redactor.redact(outcome) : outcome,
-          durationMs: stopwatch.stop().ms,
+          ms: stopwatch.stop().ms,
         };
       }),
     );
@@ -120,9 +121,9 @@ export class HealthcheckHandler {
       server: {
         pid: process.pid,
         hostname: os.hostname(),
-        cpus: tools.IntegerNonNegative.parse(os.cpus().length),
+        cpus: v.parse(tools.IntegerNonNegative, os.cpus().length),
         startup: this.deps.Clock.now().subtract(uptime.duration).ms,
-        uptime: { durationMs: uptime.duration.ms, formatted: uptime.formatted },
+        uptime: { ms: uptime.duration.ms, formatted: uptime.formatted },
         memory: {
           total: { bytes: memory.total.toBytes(), formatted: memory.total.format(tools.Size.unit.MB) },
           heap: {
@@ -143,7 +144,7 @@ export class HealthcheckHandler {
         inFlight: InFlightRequestsTracker.get(),
       },
       logger: this.deps.LoggerStatsProvider?.getStats(),
-      durationMs: stopwatch.stop().ms,
+      ms: stopwatch.stop().ms,
       timestamp: this.deps.Clock.now().ms,
     };
   }

package/src/http-logger.middleware.ts

@@ -90,7 +90,7 @@ export class HttpLoggerMiddleware {
       method: context.request.method,
       url: context.request.url(),
       status: input.status,
-      durationMs: duration.ms,
+      ms: duration.ms,
       client,
       cacheHit: input.cacheHit,
       metadata: { response: input.responseBody },

package/src/i18n.service.ts

@@ -1,4 +1,5 @@
 import * as tools from "@bgord/tools";
+import * as v from "valibot";
 import type { FileReaderJsonPort } from "../src/file-reader-json.port";
 import type { LoggerPort } from "../src/logger.port";
 
@@ -12,7 +13,7 @@ export type TranslationVariableType = Record<TranslationPlaceholderType, Transla
 type Dependencies = { FileReaderJson: FileReaderJsonPort; Logger: LoggerPort };
 
 export class I18n {
-  static DEFAULT_TRANSLATIONS_PATH = tools.DirectoryPathRelativeSchema.parse("infra/translations");
+  static DEFAULT_TRANSLATIONS_PATH = v.parse(tools.DirectoryPathRelativeSchema, "infra/translations");
 
   constructor(
     private readonly deps: Dependencies,

package/src/image-info-noop.adapter.ts

@@ -1,4 +1,5 @@
 import * as tools from "@bgord/tools";
+import * as v from "valibot";
 import type { ImageInfoPort, ImageInfoType } from "./image-info.port";
 
 export class ImageInfoNoopAdapter implements ImageInfoPort {
@@ -6,8 +7,8 @@ export class ImageInfoNoopAdapter implements ImageInfoPort {
 
   async inspect(_input: tools.FilePathRelative | tools.FilePathAbsolute): Promise<ImageInfoType> {
     return {
-      width: tools.ImageWidth.parse(400),
-      height: tools.ImageHeight.parse(400),
+      width: v.parse(tools.ImageWidth, 400),
+      height: v.parse(tools.ImageHeight, 400),
       mime: this.mime,
       size: tools.Size.fromBytes(0),
     };

package/src/image-info-sharp.adapter.ts

@@ -1,5 +1,6 @@
 import * as tools from "@bgord/tools";
 import type sharp from "sharp";
+import * as v from "valibot";
 import { DynamicImport } from "./dynamic-import.service";
 import type { FileInspectionPort } from "./file-inspection.port";
 import type { ImageInfoPort, ImageInfoType } from "./image-info.port";
@@ -36,9 +37,9 @@ export class ImageInfoSharpAdapter implements ImageInfoPort {
 
     const metadata = await pipeline.metadata();
 
-    const width = tools.ImageWidth.parse(metadata.width);
-    const height = tools.ImageHeight.parse(metadata.height);
-    const extension = tools.Extension.parse(metadata.format);
+    const width = v.parse(tools.ImageWidth, metadata.width);
+    const height = v.parse(tools.ImageHeight, metadata.height);
+    const extension = v.parse(tools.Extension, metadata.format);
     const mime = this.deps.MimeRegistry.fromExtension(extension);
 
     if (!mime) throw new Error(tools.MimeRegistryError.MimeNotFound);

package/src/in-flight-requests-tracker.service.ts

@@ -1,7 +1,8 @@
 import * as tools from "@bgord/tools";
+import * as v from "valibot";
 
 export class InFlightRequestsTracker {
-  private static count: tools.IntegerType = tools.Integer.parse(0);
+  private static count: tools.IntegerType = v.parse(tools.Integer, 0);
 
   static increment(): void {
     InFlightRequestsTracker.count++;
@@ -17,6 +18,6 @@ export class InFlightRequestsTracker {
 
   /** @internal */
   static _resetForTest(): void {
-    InFlightRequestsTracker.count = tools.Integer.parse(0);
+    InFlightRequestsTracker.count = v.parse(tools.Integer, 0);
   }
 }

package/src/index.ts

@@ -78,7 +78,6 @@ export * from "./environment-loader-encrypted.adapter";
 export * from "./environment-loader-noop.adapter";
 export * from "./environment-loader-process.adapter";
 export * from "./environment-loader-process-safe.adapter";
-export * from "./environment-schema.port";
 export * from "./error-normalizer.service";
 export * from "./etag-extractor.middleware";
 export * from "./etag-extractor-hono.middleware";
@@ -103,8 +102,8 @@ export * from "./event-store-dispatching.adapter";
 export * from "./event-store-noop.adapter";
 export * from "./event-store-with-logger.adapter";
 export * from "./event-stream.vo";
+export * from "./event-validator-registry.adapter";
 export * from "./event-validator-registry.port";
-export * from "./event-validator-registry-zod.adapter";
 export * from "./file-cleaner.adapter";
 export * from "./file-cleaner.port";
 export * from "./file-cleaner-forgiving.adapter";

package/src/logger.port.ts

@@ -1,5 +1,4 @@
 import type * as tools from "@bgord/tools";
-import * as z from "zod/v4";
 import type { CorrelationIdType } from "./correlation-id.vo";
 import type { NormalizedError } from "./error-normalizer.service";
 import type { NodeEnvironmentEnum } from "./node-env.vo";
@@ -15,7 +14,6 @@ export enum LogLevelEnum {
   debug = "debug",
   silly = "silly",
 }
-export const LogLevel = z.enum(LogLevelEnum);
 
 export type LogCoreType = {
   timestamp: string;
@@ -36,7 +34,7 @@ export type LogHttpType = LogCoreType & {
   method: string;
   url: string;
   status?: number;
-  durationMs?: tools.DurationMsType;
+  ms?: tools.DurationMsType;
   client: HttpClientInfo;
   cacheHit?: boolean;
 };

package/src/mailer-content-html.vo.ts

@@ -1,14 +1,14 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 
 export const MailerContentHtmlError = { Invalid: "mailer.content.html.invalid" };
 
-// Stryker disable all
-export const MailerContentHtml = z
-  // Stryker restore all
-  .string(MailerContentHtmlError.Invalid)
-  .min(1, MailerContentHtmlError.Invalid)
-  .max(10_000, MailerContentHtmlError.Invalid)
-  .brand("MailerContentHtml");
-export type MailerContentHtmlType = z.infer<typeof MailerContentHtml>;
+export const MailerContentHtml = v.pipe(
+  v.string(MailerContentHtmlError.Invalid),
+  v.minLength(1, MailerContentHtmlError.Invalid),
+  v.maxLength(10_000, MailerContentHtmlError.Invalid),
+  // Stryker disable next-line StringLiteral
+  v.brand("MailerContentHtml"),
+);
 
+export type MailerContentHtmlType = v.InferOutput<typeof MailerContentHtml>;
 export type EmailAttachmentType = { filename: string; path: string };

package/src/mailer-subject.vo.ts

@@ -1,13 +1,13 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 
 export const MailerSubjectError = { Invalid: "mailer.subject.invalid" };
 
-// Stryker disable all
-export const MailerSubject = z
-  // Stryker restore all
-  .string(MailerSubjectError.Invalid)
-  .min(1, MailerSubjectError.Invalid)
-  .max(128, MailerSubjectError.Invalid)
-  .brand("MailerSubject");
+export const MailerSubject = v.pipe(
+  v.string(MailerSubjectError.Invalid),
+  v.minLength(1, MailerSubjectError.Invalid),
+  v.maxLength(128, MailerSubjectError.Invalid),
+  // Stryker disable next-line StringLiteral
+  v.brand("MailerSubject"),
+);
 
-export type MailerSubjectType = z.infer<typeof MailerSubject>;
+export type MailerSubjectType = v.InferOutput<typeof MailerSubject>;

package/src/modules/history/event-handlers/onHistoryPopulatedEvent.ts

@@ -1,10 +1,11 @@
+import * as v from "valibot";
 import type * as Events from "../events";
 import type * as Ports from "../ports";
 import * as VO from "../value-objects";
 
 export const onHistoryPopulatedEvent =
   (projection: Ports.HistoryProjectionPort) => async (event: Events.HistoryPopulatedEventType) => {
-    const data = VO.HistoryParsed.parse({ ...event.payload, createdAt: event.createdAt });
+    const data = v.parse(VO.HistoryParsed, { ...event.payload, createdAt: event.createdAt });
 
     await projection.append(data);
   };

package/src/modules/history/events/HISTORY_CLEARED_EVENT.ts

@@ -1,13 +1,13 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 import { EventEnvelopeSchema } from "../../../event-envelope";
 import * as VO from "../value-objects";
 
 export const HISTORY_CLEARED_EVENT = "HISTORY_CLEARED_EVENT";
 
-export const HistoryClearedEvent = z.object({
+export const HistoryClearedEvent = v.object({
   ...EventEnvelopeSchema,
-  name: z.literal(HISTORY_CLEARED_EVENT),
-  payload: z.object({ subject: VO.HistorySubject }),
+  name: v.literal(HISTORY_CLEARED_EVENT),
+  payload: v.object({ subject: VO.HistorySubject }),
 });
 
-export type HistoryClearedEventType = z.infer<typeof HistoryClearedEvent>;
+export type HistoryClearedEventType = v.InferOutput<typeof HistoryClearedEvent>;

package/src/modules/history/events/HISTORY_POPULATED_EVENT.ts

@@ -1,17 +1,17 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 import { EventEnvelopeSchema } from "../../../event-envelope";
 import * as VO from "../value-objects";
 
 export const HISTORY_POPULATED_EVENT = "HISTORY_POPULATED_EVENT";
 
-export const HistoryPopulatedEvent = z.object({
+export const HistoryPopulatedEvent = v.object({
   ...EventEnvelopeSchema,
-  name: z.literal(HISTORY_POPULATED_EVENT),
-  payload: z.object({
+  name: v.literal(HISTORY_POPULATED_EVENT),
+  payload: v.object({
     id: VO.HistoryId,
     operation: VO.HistoryOperation,
     subject: VO.HistorySubject,
     payload: VO.HistoryPayload,
   }),
 });
-export type HistoryPopulatedEventType = z.infer<typeof HistoryPopulatedEvent>;
+export type HistoryPopulatedEventType = v.InferOutput<typeof HistoryPopulatedEvent>;

package/src/modules/history/value-objects/history-created-at.ts

@@ -1,6 +1,6 @@
 import * as tools from "@bgord/tools";
-import type * as z from "zod/v4";
+import type * as v from "valibot";
 
 export const HistoryCreatedAt = tools.TimestampValue;
 
-export type HistoryCreatedAtType = z.infer<typeof HistoryCreatedAt>;
+export type HistoryCreatedAtType = v.InferOutput<typeof HistoryCreatedAt>;

package/src/modules/history/value-objects/history-operation.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 
 export const HistoryOperationError = {
   Type: "history.operation.type",
@@ -6,7 +6,8 @@ export const HistoryOperationError = {
   TooLong: "history.operation.too.long",
 };
 
-export const HistoryOperation = z
-  .string(HistoryOperationError.Type)
-  .min(1, HistoryOperationError.Empty)
-  .max(128, HistoryOperationError.TooLong);
+export const HistoryOperation = v.pipe(
+  v.string(HistoryOperationError.Type),
+  v.minLength(1, HistoryOperationError.Empty),
+  v.maxLength(128, HistoryOperationError.TooLong),
+);

package/src/modules/history/value-objects/history-payload.ts

@@ -1,15 +1,21 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 
-export const HistoryPayload = z.record(z.string(), z.any());
+export const HistoryPayload = v.record(v.string(), v.unknown());
 
 export const HistoryPayloadParsedError = {
   NotSerializable: "history.payload.parsed.not.serializable",
 };
 
-export const HistoryPayloadParsed = HistoryPayload.transform((value) => {
-  try {
-    return JSON.stringify(value);
-  } catch {
-    throw new Error(HistoryPayloadParsedError.NotSerializable);
-  }
-});
+// Stryker disable BlockStatement
+export const HistoryPayloadParsed = v.pipe(
+  HistoryPayload,
+  v.check((value) => {
+    try {
+      JSON.stringify(value);
+      return true;
+    } catch {
+      return false;
+    }
+  }, HistoryPayloadParsedError.NotSerializable),
+  v.transform((value) => JSON.stringify(value)),
+);

package/src/modules/history/value-objects/history-subject.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 
 export const HistorySubjectError = {
   Type: "history.subject.type",
@@ -6,9 +6,10 @@ export const HistorySubjectError = {
   TooLong: "history.subject.too.long",
 };
 
-export const HistorySubject = z
-  .string(HistorySubjectError.Type)
-  .min(1, HistorySubjectError.Empty)
-  .max(128, HistorySubjectError.TooLong);
+export const HistorySubject = v.pipe(
+  v.string(HistorySubjectError.Type),
+  v.minLength(1, HistorySubjectError.Empty),
+  v.maxLength(128, HistorySubjectError.TooLong),
+);
 
-export type HistorySubjectType = z.infer<typeof HistorySubject>;
+export type HistorySubjectType = v.InferOutput<typeof HistorySubject>;