@bgord/bun 1.14.7 → 1.15.1

package/src/modules/preferences/commands/SET_USER_LANGUAGE_COMMAND.ts

@@ -1,14 +1,14 @@
 import * as tools from "@bgord/tools";
-import * as z from "zod/v4";
+import * as v from "valibot";
 import { CommandEnvelopeSchema } from "../../../command-envelope";
 import { UUID } from "../../../uuid.vo";
 
 export const SET_USER_LANGUAGE_COMMAND = "SET_USER_LANGUAGE_COMMAND";
 
-export const SetUserLanguageCommand = z.object({
+export const SetUserLanguageCommand = v.object({
   ...CommandEnvelopeSchema,
-  name: z.literal(SET_USER_LANGUAGE_COMMAND),
-  payload: z.object({ language: tools.Language, userId: UUID }),
+  name: v.literal(SET_USER_LANGUAGE_COMMAND),
+  payload: v.object({ language: tools.Language, userId: UUID }),
 });
 
-export type SetUserLanguageCommandType = z.infer<typeof SetUserLanguageCommand>;
+export type SetUserLanguageCommandType = v.InferOutput<typeof SetUserLanguageCommand>;

package/src/modules/preferences/events/USER_LANGUAGE_SET_EVENT.ts

@@ -1,14 +1,14 @@
 import * as tools from "@bgord/tools";
-import * as z from "zod/v4";
+import * as v from "valibot";
 import { EventEnvelopeSchema } from "../../../event-envelope";
 import { UUID } from "../../../uuid.vo";
 
 export const USER_LANGUAGE_SET_EVENT = "USER_LANGUAGE_SET_EVENT";
 
-export const UserLanguageSetEvent = z.object({
+export const UserLanguageSetEvent = v.object({
   ...EventEnvelopeSchema,
-  name: z.literal(USER_LANGUAGE_SET_EVENT),
-  payload: z.object({ userId: UUID, language: tools.Language }),
+  name: v.literal(USER_LANGUAGE_SET_EVENT),
+  payload: v.object({ userId: UUID, language: tools.Language }),
 });
 
-export type UserLanguageSetEventType = z.infer<typeof UserLanguageSetEvent>;
+export type UserLanguageSetEventType = v.InferOutput<typeof UserLanguageSetEvent>;

package/src/modules/system/events/HOUR_HAS_PASSED_EVENT.ts

@@ -1,13 +1,13 @@
 import * as tools from "@bgord/tools";
-import * as z from "zod/v4";
+import * as v from "valibot";
 import { EventEnvelopeSchema } from "../../../event-envelope";
 
 export const HOUR_HAS_PASSED_EVENT = "HOUR_HAS_PASSED_EVENT";
 
-export const HourHasPassedEvent = z.object({
+export const HourHasPassedEvent = v.object({
   ...EventEnvelopeSchema,
-  name: z.literal(HOUR_HAS_PASSED_EVENT),
-  payload: z.object({ timestamp: tools.TimestampValue }),
+  name: v.literal(HOUR_HAS_PASSED_EVENT),
+  payload: v.object({ timestamp: tools.TimestampValue }),
 });
 
-export type HourHasPassedEventType = z.infer<typeof HourHasPassedEvent>;
+export type HourHasPassedEventType = v.InferOutput<typeof HourHasPassedEvent>;

package/src/modules/system/events/MINUTE_HAS_PASSED_EVENT.ts

@@ -1,13 +1,13 @@
 import * as tools from "@bgord/tools";
-import * as z from "zod/v4";
+import * as v from "valibot";
 import { EventEnvelopeSchema } from "../../../event-envelope";
 
 export const MINUTE_HAS_PASSED_EVENT = "MINUTE_HAS_PASSED_EVENT";
 
-export const MinuteHasPassedEvent = z.object({
+export const MinuteHasPassedEvent = v.object({
   ...EventEnvelopeSchema,
-  name: z.literal(MINUTE_HAS_PASSED_EVENT),
-  payload: z.object({ timestamp: tools.TimestampValue }),
+  name: v.literal(MINUTE_HAS_PASSED_EVENT),
+  payload: v.object({ timestamp: tools.TimestampValue }),
 });
 
-export type MinuteHasPassedEventType = z.infer<typeof MinuteHasPassedEvent>;
+export type MinuteHasPassedEventType = v.InferOutput<typeof MinuteHasPassedEvent>;

package/src/modules/system/events/SECURITY_VIOLATION_DETECTED_EVENT.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 import { ClientIp } from "../../../client-ip.vo";
 import { ClientUserAgent } from "../../../client-user-agent.vo";
 import { EventEnvelopeSchema } from "../../../event-envelope";
@@ -8,16 +8,16 @@ import { UUID } from "../../../uuid.vo";
 
 export const SECURITY_VIOLATION_DETECTED_EVENT = "SECURITY_VIOLATION_DETECTED_EVENT";
 
-export const SecurityViolationDetectedEvent = z.object({
+export const SecurityViolationDetectedEvent = v.object({
   ...EventEnvelopeSchema,
-  name: z.literal(SECURITY_VIOLATION_DETECTED_EVENT),
-  payload: z.object({
+  name: v.literal(SECURITY_VIOLATION_DETECTED_EVENT),
+  payload: v.object({
     rule: SecurityRuleName,
-    client: z.object({ ip: ClientIp.optional(), ua: ClientUserAgent.optional() }),
-    userId: UUID.or(z.undefined()),
+    client: v.object({ ip: v.optional(ClientIp), ua: v.optional(ClientUserAgent) }),
+    userId: v.optional(UUID),
     countermeasure: SecurityCountermeasureName,
-    action: z.string(),
+    action: v.string(),
   }),
 });
 
-export type SecurityViolationDetectedEventType = z.infer<typeof SecurityViolationDetectedEvent>;
+export type SecurityViolationDetectedEventType = v.InferOutput<typeof SecurityViolationDetectedEvent>;

package/src/modules/system/services/passage-of-time-hourly.service.ts

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import type { ClockPort } from "../../../clock.port";
 import { createEventEnvelope } from "../../../event-envelope";
 import type { EventStorePort } from "../../../event-store.port";
@@ -24,7 +25,7 @@ export class PassageOfTimeHourly implements UnitOfWork {
   label = "PassageOfTime";
 
   async process() {
-    const event = HourHasPassedEvent.parse({
+    const event = v.parse(HourHasPassedEvent, {
       ...createEventEnvelope("passage_of_time", this.deps),
       name: HOUR_HAS_PASSED_EVENT,
       payload: { timestamp: this.deps.Clock.now().ms },

package/src/modules/system/services/passage-of-time-minute.service.ts

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import type { ClockPort } from "../../../clock.port";
 import { createEventEnvelope } from "../../../event-envelope";
 import type { EventStorePort } from "../../../event-store.port";
@@ -24,7 +25,7 @@ export class PassageOfTimeMinute implements UnitOfWork {
   label = "PassageOfTime";
 
   async process() {
-    const event = MinuteHasPassedEvent.parse({
+    const event = v.parse(MinuteHasPassedEvent, {
       ...createEventEnvelope("passage_of_time", this.deps),
       name: MINUTE_HAS_PASSED_EVENT,
       payload: { timestamp: this.deps.Clock.now().ms },

package/src/node-env.vo.ts

@@ -1,12 +1,6 @@
-import * as z from "zod/v4";
-
 export enum NodeEnvironmentEnum {
   local = "local",
   test = "test",
   staging = "staging",
   production = "production",
 }
-
-export const NodeEnvironmentError = { Invalid: "node.environment.invalid" } as const;
-
-export const NodeEnvironment = z.enum(NodeEnvironmentEnum, NodeEnvironmentError.Invalid);

package/src/nonce-provider-crypto.adapter.ts

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import type { NonceProviderPort } from "./nonce-provider.port";
 import { NonceValue, type NonceValueType } from "./nonce-value.vo";
 
@@ -6,6 +7,6 @@ export class NonceProviderCryptoAdapter implements NonceProviderPort {
     const buffer = new Uint8Array(8);
     crypto.getRandomValues(buffer);
 
-    return NonceValue.parse(buffer.toHex());
+    return v.parse(NonceValue, buffer.toHex());
   }
 }

package/src/nonce-provider-noop.adapter.ts

@@ -1,8 +1,9 @@
+import * as v from "valibot";
 import type { NonceProviderPort } from "./nonce-provider.port";
 import { NonceValue, type NonceValueType } from "./nonce-value.vo";
 
 export class NonceProviderNoopAdapter implements NonceProviderPort {
   generate(): NonceValueType {
-    return NonceValue.parse("0000000000000000");
+    return v.parse(NonceValue, "0000000000000000");
   }
 }

package/src/nonce-value.vo.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 
 export const NonceValueError = {
   Type: "nonce.value.type",
@@ -8,11 +8,11 @@ export const NonceValueError = {
 // 16 hex chars allowed
 const CHARS_WHITELIST = /^[a-fA-F0-9]{16}$/;
 
-// Stryker disable all
-export const NonceValue = z
-  // Stryker restore all
-  .string(NonceValueError.Type)
-  .regex(CHARS_WHITELIST, NonceValueError.InvalidHex)
-  .brand("NonceValue");
+export const NonceValue = v.pipe(
+  v.string(NonceValueError.Type),
+  v.regex(CHARS_WHITELIST, NonceValueError.InvalidHex),
+  // Stryker disable next-line StringLiteral
+  v.brand("NonceValue"),
+);
 
-export type NonceValueType = z.infer<typeof NonceValue>;
+export type NonceValueType = v.InferOutput<typeof NonceValue>;

package/src/port.vo.ts

@@ -1,14 +1,16 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 
 export const PortError = { Type: "port.type", Invalid: "port.invalid" } as const;
 
-// Stryker disable all
-export const Port = z.coerce
-  // Stryker restore all
-  .number(PortError.Type)
-  .int(PortError.Type)
-  .min(0, PortError.Invalid)
-  .max(99999, PortError.Invalid)
-  .brand("Port");
+export const Port = v.pipe(
+  v.unknown(),
+  v.transform(Number),
+  v.number(PortError.Type),
+  v.integer(PortError.Type),
+  v.minValue(0, PortError.Invalid),
+  v.maxValue(99999, PortError.Invalid),
+  // Stryker disable next-line StringLiteral
+  v.brand("Port"),
+);
 
-export type PortType = z.infer<typeof Port>;
+export type PortType = v.InferOutput<typeof Port>;

package/src/prerequisite-verifier-outside-connectivity.adapter.ts

@@ -1,4 +1,5 @@
 import * as tools from "@bgord/tools";
+import * as v from "valibot";
 import {
   PrerequisiteVerification,
   type PrerequisiteVerificationResult,
@@ -6,7 +7,7 @@ import {
 } from "./prerequisite-verifier.port";
 
 export class PrerequisiteVerifierOutsideConnectivityAdapter implements PrerequisiteVerifierPort {
-  private static readonly URL = tools.UrlWithoutSlash.parse("https://google.com");
+  private static readonly URL = v.parse(tools.UrlWithoutSlash, "https://google.com");
 
   async verify(): Promise<PrerequisiteVerificationResult> {
     try {

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

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

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

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

package/src/redactor-error-cause-depth-limit.strategy.ts

@@ -12,11 +12,11 @@ export class RedactorErrorCauseDepthLimit implements RedactorStrategy {
     // Stryker restore all
     if (!ErrorNormalizer.isNormalizedError(input.error)) return input;
 
-    return { ...input, error: this.limit(input.error, tools.IntegerNonNegative.parse(0)) };
+    return { ...input, error: this.limit(input.error, tools.Int.nonNegative(0)) };
   }
 
   private limit(error: NormalizedError, depth: tools.IntegerNonNegativeType): NormalizedError {
     if (!error.cause || depth >= this.max) return { ...error, cause: undefined };
-    return { ...error, cause: this.limit(error.cause, tools.IntegerNonNegative.parse(depth + 1)) };
+    return { ...error, cause: this.limit(error.cause, tools.Int.nonNegative(depth + 1)) };
   }
 }

package/src/redactor-metadata-compact-array.strategy.ts

@@ -6,7 +6,7 @@ import type { RedactorStrategy } from "./redactor.strategy";
 type RedactorMetadataCompactArrayOptions = { maxItems?: tools.IntegerPositiveType };
 
 export class RedactorMetadataCompactArray implements RedactorStrategy {
-  private static readonly DEFAULT_MAX_ITEMS = tools.IntegerPositive.parse(20);
+  private static readonly DEFAULT_MAX_ITEMS = tools.Int.positive(20);
 
   private readonly maxItems: tools.IntegerPositiveType;
 

package/src/redactor-metadata-compact-object.strategy.ts

@@ -6,7 +6,7 @@ import type { RedactorStrategy } from "./redactor.strategy";
 type RedactorMetadataCompactObjectOptions = { maxKeys?: tools.IntegerPositiveType };
 
 export class RedactorMetadataCompactObject implements RedactorStrategy {
-  private static readonly DEFAULT_MAX_KEYS = tools.IntegerPositive.parse(20);
+  private static readonly DEFAULT_MAX_KEYS = tools.Int.positive(20);
 
   private readonly maxKeys: tools.IntegerPositiveType;
 

package/src/remote-file-storage-disk.adapter.ts

@@ -1,4 +1,5 @@
 import * as tools from "@bgord/tools";
+import * as v from "valibot";
 import type { DirectoryEnsurerPort } from "./directory-ensurer.port";
 import type { FileCleanerPort } from "./file-cleaner.port";
 import type { FileCopierPort } from "./file-copier.port";
@@ -31,7 +32,7 @@ export class RemoteFileStorageDiskAdapter implements RemoteFileStoragePort {
     const parts = key.split("/");
     const filename = tools.Filename.fromString(parts.pop() as string);
 
-    const directory = tools.DirectoryPathAbsoluteSchema.parse(`${this.config.root}/${parts.join("/")}`);
+    const directory = v.parse(tools.DirectoryPathAbsoluteSchema, `${this.config.root}/${parts.join("/")}`);
 
     return tools.FilePathAbsolute.fromPartsSafe(directory, filename);
   }

package/src/retry-backoff-exponential.strategy.ts

@@ -1,10 +1,11 @@
 import * as tools from "@bgord/tools";
+import * as v from "valibot";
 import type { RetryBackoffStrategy } from "./retry-backoff.strategy";
 
 export class RetryBackoffExponentialStrategy implements RetryBackoffStrategy {
   constructor(private readonly delay: tools.Duration) {}
 
   next(attempt: tools.IntegerPositiveType): tools.Duration {
-    return this.delay.times(tools.MultiplicationFactor.parse(2 ** (attempt - 1)));
+    return this.delay.times(v.parse(tools.MultiplicationFactor, 2 ** (attempt - 1)));
   }
 }

package/src/retry-backoff-fibonacci.strategy.ts

@@ -1,11 +1,12 @@
 import * as tools from "@bgord/tools";
+import * as v from "valibot";
 import type { RetryBackoffStrategy } from "./retry-backoff.strategy";
 
 export class RetryBackoffFibonacciStrategy implements RetryBackoffStrategy {
   constructor(private readonly delay: tools.Duration) {}
 
   next(attempt: tools.IntegerPositiveType): tools.Duration {
-    return this.delay.times(tools.MultiplicationFactor.parse(this.fibonacci(attempt)));
+    return this.delay.times(v.parse(tools.MultiplicationFactor, this.fibonacci(attempt)));
   }
 
   private fibonacci(n: number): number {

package/src/retry-backoff-linear.strategy.ts

@@ -1,10 +1,11 @@
 import * as tools from "@bgord/tools";
+import * as v from "valibot";
 import type { RetryBackoffStrategy } from "./retry-backoff.strategy";
 
 export class RetryBackoffLinearStrategy implements RetryBackoffStrategy {
   constructor(private readonly delay: tools.Duration) {}
 
   next(attempt: tools.IntegerPositiveType): tools.Duration {
-    return this.delay.times(tools.MultiplicationFactor.parse(attempt));
+    return this.delay.times(v.parse(tools.MultiplicationFactor, attempt));
   }
 }

package/src/retry.service.ts

@@ -27,8 +27,7 @@ export class Retry {
         lastError = error;
 
         if (attempt === config.max || (config.when && !config.when(error))) break;
-
-        await this.deps.Sleeper.wait(config.backoff.next(tools.IntegerPositive.parse(attempt)));
+        await this.deps.Sleeper.wait(config.backoff.next(tools.Int.positive(attempt)));
       }
     }
 

package/src/security-countermeasure-ban.strategy.ts

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import type { ClockPort } from "./clock.port";
 import { CorrelationStorage } from "./correlation-storage.service";
 import { createEventEnvelope } from "./event-envelope";
@@ -50,7 +51,7 @@ export class SecurityCountermeasureBanStrategy implements SecurityCountermeasure
       metadata: context,
     });
 
-    const event = SecurityViolationDetectedEvent.parse({
+    const event = v.parse(SecurityViolationDetectedEvent, {
       ...createEventEnvelope("security", this.deps),
       name: SECURITY_VIOLATION_DETECTED_EVENT,
       payload: { action: action.kind, ...context },
@@ -62,6 +63,6 @@ export class SecurityCountermeasureBanStrategy implements SecurityCountermeasure
   }
 
   get name(): SecurityCountermeasureNameType {
-    return SecurityCountermeasureName.parse("ban");
+    return v.parse(SecurityCountermeasureName, "ban");
   }
 }

package/src/security-countermeasure-mirage.strategy.ts

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import { CorrelationStorage } from "./correlation-storage.service";
 import type { LoggerPort } from "./logger.port";
 import type { SecurityContext } from "./security-context.vo";
@@ -29,6 +30,6 @@ export class SecurityCountermeasureMirageStrategy implements SecurityCountermeas
   }
 
   get name(): SecurityCountermeasureNameType {
-    return SecurityCountermeasureName.parse("mirage");
+    return v.parse(SecurityCountermeasureName, "mirage");
   }
 }

package/src/security-countermeasure-name.vo.ts

@@ -1,22 +1,18 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 
 export const SecurityCountermeasureNameError = {
   Type: "security.countermeasure.name.type",
-  Empty: "security.countermeasure.name.empty",
-  TooLong: "security.countermeasure.name.too.long",
   BadChars: "security.countermeasure.name.bad.chars",
 };
 
 // One to sixty four letters, digits, or underscores
 const CHARS_WHITELIST = /^[a-zA-Z0-9_]{1,64}$/;
 
-// Stryker disable all
-export const SecurityCountermeasureName = z
-  // Stryker restore all
-  .string(SecurityCountermeasureNameError.Type)
-  .min(1, SecurityCountermeasureNameError.Empty)
-  .max(64, SecurityCountermeasureNameError.TooLong)
-  .regex(CHARS_WHITELIST, SecurityCountermeasureNameError.BadChars)
-  .brand("SecurityCountermeasureName");
+export const SecurityCountermeasureName = v.pipe(
+  v.string(SecurityCountermeasureNameError.Type),
+  v.regex(CHARS_WHITELIST, SecurityCountermeasureNameError.BadChars),
+  // Stryker disable next-line StringLiteral
+  v.brand("SecurityCountermeasureName"),
+);
 
-export type SecurityCountermeasureNameType = z.infer<typeof SecurityCountermeasureName>;
+export type SecurityCountermeasureNameType = v.InferOutput<typeof SecurityCountermeasureName>;

package/src/security-countermeasure-noop.strategy.ts

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import type { SecurityAction, SecurityCountermeasureStrategy } from "./security-countermeasure.strategy";
 import {
   SecurityCountermeasureName,
@@ -10,6 +11,6 @@ export class SecurityCountermeasureNoopStrategy implements SecurityCountermeasur
   }
 
   get name(): SecurityCountermeasureNameType {
-    return SecurityCountermeasureName.parse("noop");
+    return v.parse(SecurityCountermeasureName, "noop");
   }
 }

package/src/security-countermeasure-report.strategy.ts

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import { CorrelationStorage } from "./correlation-storage.service";
 import type { LoggerPort } from "./logger.port";
 import type { SecurityContext } from "./security-context.vo";
@@ -25,6 +26,6 @@ export class SecurityCountermeasureReportStrategy implements SecurityCountermeas
   }
 
   get name(): SecurityCountermeasureNameType {
-    return SecurityCountermeasureName.parse("report");
+    return v.parse(SecurityCountermeasureName, "report");
   }
 }

package/src/security-countermeasure-tarpit.strategy.ts

@@ -1,4 +1,5 @@
 import type * as tools from "@bgord/tools";
+import * as v from "valibot";
 import { CorrelationStorage } from "./correlation-storage.service";
 import type { LoggerPort } from "./logger.port";
 import type { SecurityContext } from "./security-context.vo";
@@ -30,6 +31,6 @@ export class SecurityCountermeasureTarpitStrategy implements SecurityCountermeas
   }
 
   get name(): SecurityCountermeasureNameType {
-    return SecurityCountermeasureName.parse("tarpit");
+    return v.parse(SecurityCountermeasureName, "tarpit");
   }
 }

package/src/security-rule-and.strategy.ts

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import type { RequestContext } from "./request-context.port";
 import type { SecurityRuleStrategy } from "./security-rule.strategy";
 import { SecurityRuleName, type SecurityRuleNameType } from "./security-rule-name.vo";
@@ -20,6 +21,6 @@ export class SecurityRuleAndStrategy implements SecurityRuleStrategy {
   }
 
   get name(): SecurityRuleNameType {
-    return SecurityRuleName.parse(`and_${this.rules.map((rule) => rule.name).join("_")}`);
+    return v.parse(SecurityRuleName, `and_${this.rules.map((rule) => rule.name).join("_")}`);
   }
 }

package/src/security-rule-bait-routes.strategy.ts

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import type { HasRequestPath } from "./request-context.port";
 import type { SecurityRuleStrategy } from "./security-rule.strategy";
 import { SecurityRuleName, type SecurityRuleNameType } from "./security-rule-name.vo";
@@ -10,6 +11,6 @@ export class SecurityRuleBaitRoutesStrategy implements SecurityRuleStrategy {
   }
 
   get name(): SecurityRuleNameType {
-    return SecurityRuleName.parse("bait_routes");
+    return v.parse(SecurityRuleName, "bait_routes");
   }
 }

package/src/security-rule-fail.strategy.ts

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import type { SecurityRuleStrategy } from "./security-rule.strategy";
 import { SecurityRuleName, type SecurityRuleNameType } from "./security-rule-name.vo";
 
@@ -7,6 +8,6 @@ export class SecurityRuleFailStrategy implements SecurityRuleStrategy {
   }
 
   get name(): SecurityRuleNameType {
-    return SecurityRuleName.parse("fail");
+    return v.parse(SecurityRuleName, "fail");
   }
 }

package/src/security-rule-honey-pot-field.strategy.ts

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import type { HasRequestJSON } from "./request-context.port";
 import type { SecurityRuleStrategy } from "./security-rule.strategy";
 import { SecurityRuleName, type SecurityRuleNameType } from "./security-rule-name.vo";
@@ -14,6 +15,6 @@ export class SecurityRuleHoneyPotFieldStrategy implements SecurityRuleStrategy {
   }
 
   get name(): SecurityRuleNameType {
-    return SecurityRuleName.parse("honey_pot_field");
+    return v.parse(SecurityRuleName, "honey_pot_field");
   }
 }

package/src/security-rule-name.vo.ts

@@ -1,22 +1,18 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 
 export const SecurityRuleNameError = {
   Type: "security.rule.name.type",
-  Empty: "security.rule.name.empty",
-  TooLong: "security.rule.name.too.long",
   BadChars: "security.rule.name.bad.chars",
 };
 
-// One to sixty four letters, digits, or underscores
+// One to five hundred twelve letters, digits, or underscores
 const CHARS_WHITELIST = /^[a-zA-Z0-9_]{1,512}$/;
 
-// Stryker disable all
-export const SecurityRuleName = z
-  // Stryker restore all
-  .string(SecurityRuleNameError.Type)
-  .min(1, SecurityRuleNameError.Empty)
-  .max(512, SecurityRuleNameError.TooLong)
-  .regex(CHARS_WHITELIST, SecurityRuleNameError.BadChars)
-  .brand("SecurityRuleName");
+export const SecurityRuleName = v.pipe(
+  v.string(SecurityRuleNameError.Type),
+  v.regex(CHARS_WHITELIST, SecurityRuleNameError.BadChars),
+  // Stryker disable next-line StringLiteral
+  v.brand("SecurityRuleName"),
+);
 
-export type SecurityRuleNameType = z.infer<typeof SecurityRuleName>;
+export type SecurityRuleNameType = v.InferOutput<typeof SecurityRuleName>;

package/src/security-rule-or.strategy.ts

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import type { RequestContext } from "./request-context.port";
 import type { SecurityRuleStrategy } from "./security-rule.strategy";
 import { SecurityRuleName, type SecurityRuleNameType } from "./security-rule-name.vo";
@@ -20,6 +21,6 @@ export class SecurityRuleOrStrategy implements SecurityRuleStrategy {
   }
 
   get name(): SecurityRuleNameType {
-    return SecurityRuleName.parse(`or_${this.rules.map((rule) => rule.name).join("_")}`);
+    return v.parse(SecurityRuleName, `or_${this.rules.map((rule) => rule.name).join("_")}`);
   }
 }

package/src/security-rule-pass.strategy.ts

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import type { SecurityRuleStrategy } from "./security-rule.strategy";
 import { SecurityRuleName, type SecurityRuleNameType } from "./security-rule-name.vo";
 
@@ -7,6 +8,6 @@ export class SecurityRulePassStrategy implements SecurityRuleStrategy {
   }
 
   get name(): SecurityRuleNameType {
-    return SecurityRuleName.parse("pass");
+    return v.parse(SecurityRuleName, "pass");
   }
 }