@bgord/tools 1.3.24 → 1.4.1

package/dist/age-years.vo.d.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const AgeYearsError: {
     Type: string;
     Invalid: string;
@@ -7,5 +7,5 @@ export declare const AgeYearsConstraints: {
     min: number;
     max: number;
 };
-export declare const AgeYears: z.core.$ZodBranded<z.ZodNumber, "AgeYears", "out">;
-export type AgeYearsType = z.infer<typeof AgeYears>;
+export declare const AgeYears: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>, v.MaxValueAction<number, 130, string>, v.BrandAction<number, "AgeYears">]>;
+export type AgeYearsType = v.InferOutput<typeof AgeYears>;

package/dist/age-years.vo.js

@@ -1,11 +1,6 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const AgeYearsError = { Type: "age.years.type", Invalid: "age.years.invalid" };
 export const AgeYearsConstraints = { min: 0, max: 130 };
-// Stryker disable all
-export const AgeYears = z
-    // Stryker restore all
-    .number(AgeYearsError.Type)
-    .int(AgeYearsError.Type)
-    .min(0, AgeYearsError.Invalid)
-    .max(130, AgeYearsError.Invalid)
-    .brand("AgeYears");
+export const AgeYears = v.pipe(v.number(AgeYearsError.Type), v.integer(AgeYearsError.Type), v.minValue(0, AgeYearsError.Invalid), v.maxValue(130, AgeYearsError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("AgeYears"));

package/dist/age.vo.js

@@ -1,4 +1,5 @@
 import { differenceInYears } from "date-fns";
+import * as v from "valibot";
 import { AgeYears, AgeYearsConstraints } from "./age-years.vo";
 import { Timestamp } from "./timestamp.vo";
 export const AgeError = { FutureBirthdate: "age.future.birthdate" };
@@ -10,7 +11,7 @@ export class Age {
         this.value = value;
     }
     static fromValue(candidate) {
-        return new Age(AgeYears.parse(candidate));
+        return new Age(v.parse(AgeYears, candidate));
     }
     static fromValueSafe(candidate) {
         return new Age(candidate);

package/dist/api-key.vo.d.ts

@@ -1,8 +1,7 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const ApiKeyError: {
     Type: string;
-    Length: string;
     BadChars: string;
 };
-export declare const ApiKey: z.core.$ZodBranded<z.ZodString, "ApiKey", "out">;
-export type ApiKeyType = z.infer<typeof ApiKey>;
+export declare const ApiKey: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.RegexAction<string, string>, v.BrandAction<string, "ApiKey">]>;
+export type ApiKeyType = v.InferOutput<typeof ApiKey>;

package/dist/api-key.vo.js

@@ -1,11 +1,7 @@
-import * as z from "zod/v4";
-export const ApiKeyError = { Type: "api.key.type", Length: "api.key.length", BadChars: "api.key.bad.chars" };
+import * as v from "valibot";
+export const ApiKeyError = { Type: "api.key.type", BadChars: "api.key.bad.chars" };
 // 64 letters and digits allowed
 const API_KEY_CHARS = /^[a-zA-Z0-9]{64}$/;
-// Stryker disable all
-export const ApiKey = z
-    // Stryker disable all
-    .string(ApiKeyError.Type)
-    .length(64, ApiKeyError.Length)
-    .regex(API_KEY_CHARS, ApiKeyError.BadChars)
-    .brand("ApiKey");
+export const ApiKey = v.pipe(v.string(ApiKeyError.Type), v.regex(API_KEY_CHARS, ApiKeyError.BadChars), 
+// Stryker disable next-line StringLiteral
+v.brand("ApiKey"));

package/dist/basename.vo.d.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const BasenameError: {
     Type: string;
     Empty: string;
@@ -8,5 +8,5 @@ export declare const BasenameError: {
     TrailingDot: string;
     BadChars: string;
 };
-export declare const Basename: z.core.$ZodBranded<z.ZodString, "Basename", "out">;
-export type BasenameType = z.infer<typeof Basename>;
+export declare const Basename: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>, v.MaxLengthAction<string, 128, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.RegexAction<string, string>, v.BrandAction<string, "Basename">]>;
+export type BasenameType = v.InferOutput<typeof Basename>;

package/dist/basename.vo.js

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const BasenameError = {
     Type: "basename.type",
     Empty: "basename.empty",
@@ -11,17 +11,12 @@ export const BasenameError = {
 // Letters, digits, dots, underscores, and hyphens allowed
 const BASENAME_CHARS = /^[a-zA-Z0-9._-]+$/;
 const DOT_SEGMENTS = [".", ".."];
-// Stryker disable all
-export const Basename = z
-    // Stryker restore all
-    .string(BasenameError.Type)
-    .min(1, BasenameError.Empty)
-    .max(128, BasenameError.TooLong)
-    // Reject "." and ".." as a filename to avoid directory traversal
-    .refine((value) => !DOT_SEGMENTS.includes(value), BasenameError.DotSegments)
-    // Reject dotfiles like ".env"
-    .refine((value) => !value.startsWith("."), BasenameError.Dotfiles)
-    // Reject trailing dot like "picture." to avoid extension collision
-    .refine((value) => !value.endsWith("."), BasenameError.TrailingDot)
-    .regex(BASENAME_CHARS, BasenameError.BadChars)
-    .brand("Basename");
+export const Basename = v.pipe(v.string(BasenameError.Type), v.minLength(1, BasenameError.Empty), v.maxLength(128, BasenameError.TooLong), 
+// Reject "." and ".." as a filename to avoid directory traversal
+v.check((value) => !DOT_SEGMENTS.includes(value), BasenameError.DotSegments), 
+// Reject dotfiles like ".env"
+v.check((value) => !value.startsWith("."), BasenameError.Dotfiles), 
+// Reject trailing dot like "picture." to avoid extension collision
+v.check((value) => !value.endsWith("."), BasenameError.TrailingDot), v.regex(BASENAME_CHARS, BasenameError.BadChars), 
+// Stryker disable next-line StringLiteral
+v.brand("Basename"));

package/dist/day-iso-id.vo.d.ts

@@ -1,9 +1,9 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const DayIsoIdError: {
     Type: string;
     BadChars: string;
     InvalidDate: string;
 };
 export declare const DAY_ISO_ID_CHARS: RegExp;
-export declare const DayIsoId: z.core.$ZodBranded<z.ZodString, "DayIsoId", "out">;
-export type DayIsoIdType = z.infer<typeof DayIsoId>;
+export declare const DayIsoId: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.RegexAction<string, string>, v.CheckAction<string, string>, v.BrandAction<string, "DayIsoId">]>;
+export type DayIsoIdType = v.InferOutput<typeof DayIsoId>;

package/dist/day-iso-id.vo.js

@@ -1,5 +1,5 @@
 import { isValid, parseISO } from "date-fns";
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const DayIsoIdError = {
     Type: "day.iso.id.type",
     BadChars: "day.iso.id.bad.chars",
@@ -7,10 +7,6 @@ export const DayIsoIdError = {
 };
 // Four digits, hyphen, two digits, hyphen, two digits
 export const DAY_ISO_ID_CHARS = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/;
-// Stryker disable all
-export const DayIsoId = z
-    // Stryker restore all
-    .string(DayIsoIdError.Type)
-    .regex(DAY_ISO_ID_CHARS, DayIsoIdError.BadChars)
-    .refine((value) => isValid(parseISO(value)), DayIsoIdError.InvalidDate)
-    .brand("DayIsoId");
+export const DayIsoId = v.pipe(v.string(DayIsoIdError.Type), v.regex(DAY_ISO_ID_CHARS, DayIsoIdError.BadChars), v.check((value) => isValid(parseISO(value)), DayIsoIdError.InvalidDate), 
+// Stryker disable next-line StringLiteral
+v.brand("DayIsoId"));

package/dist/day.vo.d.ts

@@ -9,8 +9,8 @@ export declare class Day extends DateRange {
     static fromNow(now: Timestamp): Day;
     static fromIsoId(isoId: DayIsoIdType): Day;
     toIsoId(): DayIsoIdType;
-    next(): Day;
     previous(): Day;
+    next(): Day;
     shift(count: IntegerType): Day;
     toString(): string;
 }

package/dist/day.vo.js

@@ -1,4 +1,5 @@
 import { formatISO } from "date-fns";
+import * as v from "valibot";
 import { DateRange } from "./date-range.vo";
 import { DayIsoId } from "./day-iso-id.vo";
 import { Duration } from "./duration.service";
@@ -18,20 +19,20 @@ export class Day extends DateRange {
         return Day.fromTimestamp(now);
     }
     static fromIsoId(isoId) {
-        const [year, month, day] = DayIsoId.parse(isoId).split("-").map(Number);
+        const [year, month, day] = v.parse(DayIsoId, isoId).split("-").map(Number);
         const startUtc = Timestamp.fromNumber(Date.UTC(year, month - 1, day));
         const endUtc = startUtc.add(Duration.Days(1)).subtract(Duration.Ms(1));
         return new Day(startUtc, endUtc);
     }
     toIsoId() {
         const midday = this.getStart().add(Duration.Hours(12));
-        return DayIsoId.parse(formatISO(midday.ms, { representation: "date" }));
-    }
-    next() {
-        return this.shift(Integer.parse(1));
+        return v.parse(DayIsoId, formatISO(midday.ms, { representation: "date" }));
     }
     previous() {
-        return this.shift(Integer.parse(-1));
+        return this.shift(v.parse(Integer, -1));
+    }
+    next() {
+        return this.shift(v.parse(Integer, 1));
     }
     shift(count) {
         return Day.fromTimestamp(this.getStart().add(Duration.Days(count)));

package/dist/directory-path-absolute.vo.d.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const DirectoryPathAbsoluteError: {
     BadSegments: string;
     Empty: string;
@@ -8,5 +8,5 @@ export declare const DirectoryPathAbsoluteError: {
     Type: string;
 };
 export declare const DIRECTORY_PATH_ABSOLUTE_CHARS: RegExp;
-export declare const DirectoryPathAbsoluteSchema: z.core.$ZodBranded<z.ZodString, "DirectoryPathAbsoluteSchema", "out">;
-export type DirectoryPathAbsoluteType = z.infer<typeof DirectoryPathAbsoluteSchema>;
+export declare const DirectoryPathAbsoluteSchema: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>, v.MaxLengthAction<string, 512, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.BrandAction<string, "DirectoryPathAbsoluteSchema">]>;
+export type DirectoryPathAbsoluteType = v.InferOutput<typeof DirectoryPathAbsoluteSchema>;

package/dist/directory-path-absolute.vo.js

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const DirectoryPathAbsoluteError = {
     BadSegments: "directory.path.absolue.bad.segments",
     Empty: "directory.path.absolue.empty",
@@ -10,18 +10,11 @@ export const DirectoryPathAbsoluteError = {
 // Letters, digits, dots, underscores, and hyphens
 export const DIRECTORY_PATH_ABSOLUTE_CHARS = /^[a-zA-Z0-9._-]+$/;
 const DOT_SEGMENTS = [".", ".."];
-// Stryker disable all
-export const DirectoryPathAbsoluteSchema = z
-    // Stryker restore all
-    .string(DirectoryPathAbsoluteError.Type)
-    .min(1, DirectoryPathAbsoluteError.Empty)
-    .max(512, DirectoryPathAbsoluteError.TooLong)
-    .refine((value) => value.startsWith("/"), DirectoryPathAbsoluteError.LeadingSlash)
-    .refine((value) => (value === "/" ? true : !value.endsWith("/")), DirectoryPathAbsoluteError.TrailingSlash)
-    .refine((value) => {
+export const DirectoryPathAbsoluteSchema = v.pipe(v.string(DirectoryPathAbsoluteError.Type), v.minLength(1, DirectoryPathAbsoluteError.Empty), v.maxLength(512, DirectoryPathAbsoluteError.TooLong), v.check((value) => value.startsWith("/"), DirectoryPathAbsoluteError.LeadingSlash), v.check((value) => (value === "/" ? true : !value.endsWith("/")), DirectoryPathAbsoluteError.TrailingSlash), v.check((value) => {
     if (value === "/")
         return true;
     const segments = value.slice(1).split("/");
     return segments.every((segment) => DIRECTORY_PATH_ABSOLUTE_CHARS.test(segment) && !DOT_SEGMENTS.includes(segment));
-}, DirectoryPathAbsoluteError.BadSegments)
-    .brand("DirectoryPathAbsoluteSchema");
+}, DirectoryPathAbsoluteError.BadSegments), 
+// Stryker disable next-line StringLiteral
+v.brand("DirectoryPathAbsoluteSchema"));

package/dist/directory-path-relative.vo.d.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const DirectoryPathRelativeError: {
     BadSegments: string;
     Empty: string;
@@ -8,5 +8,5 @@ export declare const DirectoryPathRelativeError: {
     Type: string;
 };
 export declare const DIRECTORY_PATH_RELATIVE_CHARS: RegExp;
-export declare const DirectoryPathRelativeSchema: z.core.$ZodBranded<z.ZodString, "DirectoryPathRelativeSchema", "out">;
-export type DirectoryPathRelativeType = z.infer<typeof DirectoryPathRelativeSchema>;
+export declare const DirectoryPathRelativeSchema: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>, v.MaxLengthAction<string, 512, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.BrandAction<string, "DirectoryPathRelativeSchema">]>;
+export type DirectoryPathRelativeType = v.InferOutput<typeof DirectoryPathRelativeSchema>;

package/dist/directory-path-relative.vo.js

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const DirectoryPathRelativeError = {
     BadSegments: "directory.path.relative.bad.segments",
     Empty: "directory.path.relative.empty",
@@ -10,15 +10,8 @@ export const DirectoryPathRelativeError = {
 // Letters, digits, dots, underscores, and hyphens
 export const DIRECTORY_PATH_RELATIVE_CHARS = /^[A-Za-z0-9._-]+$/;
 const DOT_SEGMENTS = [".", ".."];
-// Stryker disable all
-export const DirectoryPathRelativeSchema = z
-    // Stryker restore all
-    .string(DirectoryPathRelativeError.Type)
-    .min(1, DirectoryPathRelativeError.Empty)
-    .max(512, DirectoryPathRelativeError.TooLong)
-    .refine((value) => !value.startsWith("/"), DirectoryPathRelativeError.LeadingSlash)
-    .refine((value) => !value.endsWith("/"), DirectoryPathRelativeError.TrailingSlash)
-    .refine((value) => value
+export const DirectoryPathRelativeSchema = v.pipe(v.string(DirectoryPathRelativeError.Type), v.minLength(1, DirectoryPathRelativeError.Empty), v.maxLength(512, DirectoryPathRelativeError.TooLong), v.check((value) => !value.startsWith("/"), DirectoryPathRelativeError.LeadingSlash), v.check((value) => !value.endsWith("/"), DirectoryPathRelativeError.TrailingSlash), v.check((value) => value
     .split("/")
-    .every((segment) => DIRECTORY_PATH_RELATIVE_CHARS.test(segment) && !DOT_SEGMENTS.includes(segment)), DirectoryPathRelativeError.BadSegments)
-    .brand("DirectoryPathRelativeSchema");
+    .every((segment) => DIRECTORY_PATH_RELATIVE_CHARS.test(segment) && !DOT_SEGMENTS.includes(segment)), DirectoryPathRelativeError.BadSegments), 
+// Stryker disable next-line StringLiteral
+v.brand("DirectoryPathRelativeSchema"));

package/dist/distance-value.vo.d.ts

@@ -1,7 +1,7 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const DistanceValueError: {
     Type: string;
     Invalid: string;
 };
-export declare const DistanceValue: z.core.$ZodBranded<z.ZodNumber, "DistanceValue", "out">;
-export type DistanceValueType = z.infer<typeof DistanceValue>;
+export declare const DistanceValue: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>, v.BrandAction<number, "DistanceValue">]>;
+export type DistanceValueType = v.InferOutput<typeof DistanceValue>;

package/dist/distance-value.vo.js

@@ -1,9 +1,5 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const DistanceValueError = { Type: "distance.value.type", Invalid: "distance.value.invalid" };
-// Stryker disable all
-export const DistanceValue = z
-    // Stryker restore all
-    .number(DistanceValueError.Type)
-    .int(DistanceValueError.Type)
-    .min(0, DistanceValueError.Invalid)
-    .brand("DistanceValue");
+export const DistanceValue = v.pipe(v.number(DistanceValueError.Type), v.integer(DistanceValueError.Type), v.minValue(0, DistanceValueError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("DistanceValue"));

package/dist/distance.vo.js

@@ -1,35 +1,36 @@
+import * as v from "valibot";
 import { DistanceValue } from "./distance-value.vo";
 import { RoundingToNearestStrategy } from "./rounding-to-nearest.strategy";
 export const DistanceError = { SubtractResultLessThanZero: "distance.subtract.result.less.than.zero" };
 export class Distance {
     value;
-    static ZERO = DistanceValue.parse(0);
+    static ZERO = v.parse(DistanceValue, 0);
     constructor(value) {
         this.value = value;
     }
     static fromMeters(candidate) {
-        return new Distance(DistanceValue.parse(candidate));
+        return new Distance(v.parse(DistanceValue, candidate));
     }
     static fromMetersSafe(candidate) {
         return new Distance(candidate);
     }
     static fromKilometers(candidate, rounding = new RoundingToNearestStrategy()) {
-        return new Distance(DistanceValue.parse(rounding.round(candidate * 1000)));
+        return new Distance(v.parse(DistanceValue, rounding.round(candidate * 1000)));
     }
     static fromMiles(candidate, rounding = new RoundingToNearestStrategy()) {
-        return new Distance(DistanceValue.parse(rounding.round(candidate * 1_609.344)));
+        return new Distance(v.parse(DistanceValue, rounding.round(candidate * 1_609.344)));
     }
     get() {
         return this.value;
     }
     add(distance) {
-        return new Distance(DistanceValue.parse(this.value + distance.get()));
+        return new Distance(v.parse(DistanceValue, this.value + distance.get()));
     }
     subtract(distance) {
         const result = this.value - distance.get();
         if (result < Distance.ZERO)
             throw new Error(DistanceError.SubtractResultLessThanZero);
-        return new Distance(DistanceValue.parse(result));
+        return new Distance(v.parse(DistanceValue, result));
     }
     equals(another) {
         return this.value === another.get();

package/dist/division-factor.vo.d.ts

@@ -1,7 +1,7 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const DivisionFactorError: {
     Type: string;
     Invalid: string;
 };
-export declare const DivisionFactor: z.core.$ZodBranded<z.ZodNumber, "DivisionFactor", "out">;
-export type DivisionFactorType = z.infer<typeof DivisionFactor>;
+export declare const DivisionFactor: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.GtValueAction<number, 0, string>, v.BrandAction<number, "DivisionFactor">]>;
+export type DivisionFactorType = v.InferOutput<typeof DivisionFactor>;

package/dist/division-factor.vo.js

@@ -1,8 +1,5 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const DivisionFactorError = { Type: "division.factor.type", Invalid: "division.factor.invalid" };
-// Stryker disable all
-export const DivisionFactor = z
-    // Stryker restore all
-    .number(DivisionFactorError.Type)
-    .gt(0, DivisionFactorError.Invalid)
-    .brand("DivisionFactor");
+export const DivisionFactor = v.pipe(v.number(DivisionFactorError.Type), v.gtValue(0, DivisionFactorError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("DivisionFactor"));

package/dist/duration-ms.vo.d.ts

@@ -1,6 +1,6 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const DurationMsError: {
     Invalid: string;
 };
-export declare const DurationMs: z.core.$ZodBranded<z.ZodNumber, "DurationMs", "out">;
-export type DurationMsType = z.infer<typeof DurationMs>;
+export declare const DurationMs: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.BrandAction<number, "DurationMs">]>;
+export type DurationMsType = v.InferOutput<typeof DurationMs>;

package/dist/duration-ms.vo.js

@@ -1,4 +1,5 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const DurationMsError = { Invalid: "duration.invalid" };
-// Stryker disable all
-export const DurationMs = z.number(DurationMsError.Invalid).int(DurationMsError.Invalid).brand("DurationMs");
+export const DurationMs = v.pipe(v.number(DurationMsError.Invalid), v.integer(DurationMsError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("DurationMs"));

package/dist/duration.service.js

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import { DurationMs } from "./duration-ms.vo";
 import { RoundingDecimalStrategy } from "./rounding-decimal.strategy";
 import { RoundingToNearestStrategy } from "./rounding-to-nearest.strategy";
@@ -12,7 +13,7 @@ export class Duration {
     static MS_IN_DAY = 24 * Duration.MS_IN_HOUR;
     static MS_IN_WEEK = 7 * Duration.MS_IN_DAY;
     constructor(candidateMs) {
-        this.internal = DurationMs.parse(candidateMs);
+        this.internal = v.parse(DurationMs, candidateMs);
     }
     static Weeks(value) {
         return new Duration(value * Duration.MS_IN_WEEK);

package/dist/email.vo.d.ts

@@ -1,6 +1,6 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const EmailError: {
     Invalid: string;
 };
-export declare const Email: z.core.$ZodBranded<z.ZodEmail, "Email", "out">;
-export type EmailType = z.infer<typeof Email>;
+export declare const Email: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.EmailAction<string, string>, v.BrandAction<string, "Email">]>;
+export type EmailType = v.InferOutput<typeof Email>;

package/dist/email.vo.js

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const EmailError = { Invalid: "email.invalid" };
-// Stryker disable all
-export const Email = z.email(EmailError.Invalid).brand("Email");
+// Stryker disable next-line StringLiteral
+export const Email = v.pipe(v.string(EmailError.Invalid), v.email(EmailError.Invalid), v.brand("Email"));

package/dist/etags.vo.js

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import { RevisionValue } from "./revision-value.vo";
 export class ETag {
     revision;
@@ -12,7 +13,7 @@ export class ETag {
         const candidate = Number(value);
         if (Number.isNaN(candidate))
             return null;
-        return new ETag(RevisionValue.parse(candidate));
+        return new ETag(v.parse(RevisionValue, candidate));
     }
 }
 export const WeakETagError = { Invalid: "weak.etag.invalid" };
@@ -31,6 +32,6 @@ export class WeakETag {
         const candidate = Number(value.split("W/")[1]);
         if (Number.isNaN(candidate))
             return null;
-        return new WeakETag(RevisionValue.parse(candidate));
+        return new WeakETag(v.parse(RevisionValue, candidate));
     }
 }

package/dist/extension.vo.d.ts

@@ -1,9 +1,9 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const ExtensionError: {
     Type: string;
     Empty: string;
     TooLong: string;
     BadChars: string;
 };
-export declare const Extension: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, "Extension", "out">;
-export type ExtensionType = z.infer<typeof Extension>;
+export declare const Extension: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.ToLowerCaseAction, v.TransformAction<string, string>, v.MinLengthAction<string, 2, string>, v.MaxLengthAction<string, 16, string>, v.CheckAction<string, string>, v.BrandAction<string, "Extension">]>;
+export type ExtensionType = v.InferOutput<typeof Extension>;

package/dist/extension.vo.js

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const ExtensionError = {
     Type: "extension.type",
     Empty: "extension.empty",
@@ -8,14 +8,8 @@ export const ExtensionError = {
 // Lowercase letters and digits allowed
 const EXTENSION_WHITELIST = /^[a-z0-9]+$/;
 const LEADING_DOT_FILE = /^\./;
-// Stryker disable all
-export const Extension = z
-    // Stryker restore all
-    .string(ExtensionError.Type)
-    .toLowerCase()
-    .min(2, ExtensionError.Empty)
-    .max(16, ExtensionError.TooLong)
-    // Transform ".png" -> "png"
-    .transform((value) => value.replace(LEADING_DOT_FILE, ""))
-    .refine((value) => EXTENSION_WHITELIST.test(value), ExtensionError.BadChars)
-    .brand("Extension");
+export const Extension = v.pipe(v.string(ExtensionError.Type), v.toLowerCase(), 
+// Transform ".png" -> "png"
+v.transform((value) => value.replace(LEADING_DOT_FILE, "")), v.minLength(2, ExtensionError.Empty), v.maxLength(16, ExtensionError.TooLong), v.check((value) => EXTENSION_WHITELIST.test(value), ExtensionError.BadChars), 
+// Stryker disable next-line StringLiteral
+v.brand("Extension"));

package/dist/feature-flag-value.vo.d.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export declare const FeatureFlagValueError: {
     Invalid: string;
 };
@@ -6,5 +6,5 @@ export declare enum FeatureFlagEnum {
     yes = "yes",
     no = "no"
 }
-export declare const FeatureFlagValue: z.ZodEnum<typeof FeatureFlagEnum>;
-export type FeatureFlagValueType = z.infer<typeof FeatureFlagValue>;
+export declare const FeatureFlagValue: v.PicklistSchema<FeatureFlagEnum[], string>;
+export type FeatureFlagValueType = v.InferOutput<typeof FeatureFlagValue>;

package/dist/feature-flag-value.vo.js

@@ -1,8 +1,8 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const FeatureFlagValueError = { Invalid: "feature.flag.value.invalid" };
 export var FeatureFlagEnum;
 (function (FeatureFlagEnum) {
     FeatureFlagEnum["yes"] = "yes";
     FeatureFlagEnum["no"] = "no";
 })(FeatureFlagEnum || (FeatureFlagEnum = {}));
-export const FeatureFlagValue = z.enum(FeatureFlagEnum, FeatureFlagValueError.Invalid);
+export const FeatureFlagValue = v.picklist(Object.values(FeatureFlagEnum), FeatureFlagValueError.Invalid);

package/dist/file-path-absolute-schema.vo.d.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 import { Filename } from "./filename.vo";
 export declare const FilePathAbsoluteSchemaError: {
     Type: string;
@@ -7,8 +7,11 @@ export declare const FilePathAbsoluteSchemaError: {
     BackslashForbidden: string;
     Empty: string;
 };
-export declare const FilePathAbsoluteSchema: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<{
-    directory: string & z.core.$brand<"DirectoryPathAbsoluteSchema">;
+export declare const FilePathAbsoluteSchema: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.TransformAction<string, {
+    directory: string & v.Brand<"DirectoryPathAbsoluteSchema">;
     filename: Filename;
-}, string>>, "FilePathAbsoluteSchema", "out">;
-export type FilePathAbsoluteType = z.infer<typeof FilePathAbsoluteSchema>;
+}>, v.BrandAction<{
+    directory: string & v.Brand<"DirectoryPathAbsoluteSchema">;
+    filename: Filename;
+}, "FilePathAbsoluteSchema">]>;
+export type FilePathAbsoluteType = v.InferOutput<typeof FilePathAbsoluteSchema>;

package/dist/file-path-absolute-schema.vo.js

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 import { DirectoryPathAbsoluteSchema } from "./directory-path-absolute.vo";
 import { Filename } from "./filename.vo";
 export const FilePathAbsoluteSchemaError = {
@@ -8,20 +8,13 @@ export const FilePathAbsoluteSchemaError = {
     BackslashForbidden: "file.path.absolute.backslash.forbidden",
     Empty: "file.path.absolute.empty",
 };
-// Stryker disable all
-export const FilePathAbsoluteSchema = z
-    // Stryker restore all
-    .string(FilePathAbsoluteSchemaError.Type)
-    .min(1, FilePathAbsoluteSchemaError.Empty)
-    .refine((value) => value.startsWith("/"), FilePathAbsoluteSchemaError.LeadingSlash)
-    .refine((value) => !value.endsWith("/"), FilePathAbsoluteSchemaError.TrailingSlash)
-    .refine((value) => !value.includes("\\"), FilePathAbsoluteSchemaError.BackslashForbidden)
-    .transform((normalized) => {
+export const FilePathAbsoluteSchema = v.pipe(v.string(FilePathAbsoluteSchemaError.Type), v.minLength(1, FilePathAbsoluteSchemaError.Empty), v.check((value) => value.startsWith("/"), FilePathAbsoluteSchemaError.LeadingSlash), v.check((value) => !value.endsWith("/"), FilePathAbsoluteSchemaError.TrailingSlash), v.check((value) => !value.includes("\\"), FilePathAbsoluteSchemaError.BackslashForbidden), v.transform((normalized) => {
     const index = normalized.lastIndexOf("/");
     const directoryCandidate = index === 0 ? "/" : normalized.slice(0, index);
     const filenameCandidate = normalized.slice(index + 1);
-    const directory = DirectoryPathAbsoluteSchema.parse(directoryCandidate);
+    const directory = v.parse(DirectoryPathAbsoluteSchema, directoryCandidate);
     const filename = Filename.fromString(filenameCandidate);
     return { directory, filename };
-})
-    .brand("FilePathAbsoluteSchema");
+}), 
+// Stryker disable next-line StringLiteral
+v.brand("FilePathAbsoluteSchema"));

package/dist/file-path-relative-schema.vo.d.ts

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 import { Filename } from "./filename.vo";
 export declare const FilePathRelativeSchemaError: {
     Type: string;
@@ -7,8 +7,11 @@ export declare const FilePathRelativeSchemaError: {
     RequiresDirectory: string;
     Empty: string;
 };
-export declare const FilePathRelativeSchema: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<{
-    directory: string & z.core.$brand<"DirectoryPathRelativeSchema">;
+export declare const FilePathRelativeSchema: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.TransformAction<string, {
+    directory: string & v.Brand<"DirectoryPathRelativeSchema">;
     filename: Filename;
-}, string>>, "FilePathRelativeSchema", "out">;
-export type FilePathRelativeType = z.infer<typeof FilePathRelativeSchema>;
+}>, v.BrandAction<{
+    directory: string & v.Brand<"DirectoryPathRelativeSchema">;
+    filename: Filename;
+}, "FilePathRelativeSchema">]>;
+export type FilePathRelativeType = v.InferOutput<typeof FilePathRelativeSchema>;