@bgord/tools 1.3.24 → 1.4.0

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

@@ -0,0 +1,11 @@
+import * as v from "valibot";
+export declare const AgeYearsError: {
+    Type: string;
+    Invalid: string;
+};
+export declare const AgeYearsConstraints: {
+    min: number;
+    max: number;
+};
+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/src/age-years.vo.js

@@ -0,0 +1,6 @@
+import * as v from "valibot";
+export const AgeYearsError = { Type: "age.years.type", Invalid: "age.years.invalid" };
+export const AgeYearsConstraints = { min: 0, max: 130 };
+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 → src/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/src/api-key.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const ApiKeyError: {
+    Type: string;
+    BadChars: string;
+};
+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/src/api-key.vo.js

@@ -0,0 +1,7 @@
+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}$/;
+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/src/basename.vo.d.ts

@@ -0,0 +1,12 @@
+import * as v from "valibot";
+export declare const BasenameError: {
+    Type: string;
+    Empty: string;
+    TooLong: string;
+    DotSegments: string;
+    Dotfiles: string;
+    TrailingDot: string;
+    BadChars: string;
+};
+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/src/basename.vo.js

@@ -0,0 +1,22 @@
+import * as v from "valibot";
+export const BasenameError = {
+    Type: "basename.type",
+    Empty: "basename.empty",
+    TooLong: "basename.too.long",
+    DotSegments: "basename.dot.segments",
+    Dotfiles: "basename.dotfiles",
+    TrailingDot: "basename.trailing.dot",
+    BadChars: "basename.bad.chars",
+};
+// Letters, digits, dots, underscores, and hyphens allowed
+const BASENAME_CHARS = /^[a-zA-Z0-9._-]+$/;
+const DOT_SEGMENTS = [".", ".."];
+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/src/day-iso-id.vo.d.ts

@@ -0,0 +1,9 @@
+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: 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 → src/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.js → src/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/src/directory-path-absolute.vo.d.ts

@@ -0,0 +1,12 @@
+import * as v from "valibot";
+export declare const DirectoryPathAbsoluteError: {
+    BadSegments: string;
+    Empty: string;
+    LeadingSlash: string;
+    TooLong: string;
+    TrailingSlash: string;
+    Type: string;
+};
+export declare const DIRECTORY_PATH_ABSOLUTE_CHARS: RegExp;
+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 → src/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/src/directory-path-relative.vo.d.ts

@@ -0,0 +1,12 @@
+import * as v from "valibot";
+export declare const DirectoryPathRelativeError: {
+    BadSegments: string;
+    Empty: string;
+    LeadingSlash: string;
+    TooLong: string;
+    TrailingSlash: string;
+    Type: string;
+};
+export declare const DIRECTORY_PATH_RELATIVE_CHARS: RegExp;
+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 → src/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/src/distance-value.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const DistanceValueError: {
+    Type: string;
+    Invalid: string;
+};
+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/src/distance-value.vo.js

@@ -0,0 +1,5 @@
+import * as v from "valibot";
+export const DistanceValueError = { Type: "distance.value.type", Invalid: "distance.value.invalid" };
+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 → src/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/src/division-factor.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const DivisionFactorError: {
+    Type: string;
+    Invalid: string;
+};
+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/src/division-factor.vo.js

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

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

@@ -0,0 +1,6 @@
+import * as v from "valibot";
+export declare const DurationMsError: {
+    Invalid: string;
+};
+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/src/duration-ms.vo.js

@@ -0,0 +1,5 @@
+import * as v from "valibot";
+export const DurationMsError = { Invalid: "duration.invalid" };
+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 → src/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/src/email.vo.d.ts

@@ -0,0 +1,6 @@
+import * as v from "valibot";
+export declare const EmailError: {
+    Invalid: string;
+};
+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/src/email.vo.js

@@ -0,0 +1,4 @@
+import * as v from "valibot";
+export const EmailError = { Invalid: "email.invalid" };
+// 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 → src/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/src/extension.vo.d.ts

@@ -0,0 +1,9 @@
+import * as v from "valibot";
+export declare const ExtensionError: {
+    Type: string;
+    Empty: string;
+    TooLong: string;
+    BadChars: string;
+};
+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/src/extension.vo.js

@@ -0,0 +1,15 @@
+import * as v from "valibot";
+export const ExtensionError = {
+    Type: "extension.type",
+    Empty: "extension.empty",
+    TooLong: "extension.too.long",
+    BadChars: "extension.bad.chars",
+};
+// Lowercase letters and digits allowed
+const EXTENSION_WHITELIST = /^[a-z0-9]+$/;
+const LEADING_DOT_FILE = /^\./;
+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/src/feature-flag-value.vo.d.ts

@@ -0,0 +1,10 @@
+import * as v from "valibot";
+export declare const FeatureFlagValueError: {
+    Invalid: string;
+};
+export declare enum FeatureFlagEnum {
+    yes = "yes",
+    no = "no"
+}
+export declare const FeatureFlagValue: v.PicklistSchema<FeatureFlagEnum[], string>;
+export type FeatureFlagValueType = v.InferOutput<typeof FeatureFlagValue>;

package/dist/{feature-flag-value.vo.js → src/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/src/file-path-absolute-schema.vo.d.ts

@@ -0,0 +1,17 @@
+import * as v from "valibot";
+import { Filename } from "./filename.vo";
+export declare const FilePathAbsoluteSchemaError: {
+    Type: string;
+    LeadingSlash: string;
+    TrailingSlash: string;
+    BackslashForbidden: string;
+    Empty: string;
+};
+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;
+}>, 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 → src/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/src/file-path-relative-schema.vo.d.ts

@@ -0,0 +1,17 @@
+import * as v from "valibot";
+import { Filename } from "./filename.vo";
+export declare const FilePathRelativeSchemaError: {
+    Type: string;
+    LeadingSlash: string;
+    BackslashForbidden: string;
+    RequiresDirectory: string;
+    Empty: string;
+};
+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;
+}>, v.BrandAction<{
+    directory: string & v.Brand<"DirectoryPathRelativeSchema">;
+    filename: Filename;
+}, "FilePathRelativeSchema">]>;
+export type FilePathRelativeType = v.InferOutput<typeof FilePathRelativeSchema>;

package/dist/{file-path-relative-schema.vo.js → src/file-path-relative-schema.vo.js}

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

package/dist/{file-path.vo.js → src/file-path.vo.js}

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import { DirectoryPathAbsoluteSchema } from "./directory-path-absolute.vo";
 import { DirectoryPathRelativeSchema } from "./directory-path-relative.vo";
 import { FilePathAbsoluteSchema } from "./file-path-absolute-schema.vo";
@@ -10,14 +11,14 @@ export class FilePathRelative {
         this.filename = filename;
     }
     static fromParts(directoryCandidate, filename) {
-        const directory = DirectoryPathRelativeSchema.parse(directoryCandidate);
+        const directory = v.parse(DirectoryPathRelativeSchema, directoryCandidate);
         return new FilePathRelative(directory, filename);
     }
     static fromPartsSafe(directory, filename) {
         return new FilePathRelative(directory, filename);
     }
     static fromString(candidate) {
-        const schema = FilePathRelativeSchema.parse(candidate);
+        const schema = v.parse(FilePathRelativeSchema, candidate);
         return new FilePathRelative(schema.directory, schema.filename);
     }
     get() {
@@ -47,14 +48,14 @@ export class FilePathAbsolute {
         this.filename = filename;
     }
     static fromParts(directoryCandidate, filename) {
-        const directory = DirectoryPathAbsoluteSchema.parse(directoryCandidate);
+        const directory = v.parse(DirectoryPathAbsoluteSchema, directoryCandidate);
         return new FilePathAbsolute(directory, filename);
     }
     static fromPartsSafe(directory, filename) {
         return new FilePathAbsolute(directory, filename);
     }
     static fromString(candidate) {
-        const schema = FilePathAbsoluteSchema.parse(candidate);
+        const schema = v.parse(FilePathAbsoluteSchema, candidate);
         return new FilePathAbsolute(schema.directory, schema.filename);
     }
     get() {

package/dist/src/filename-affix.vo.d.ts

@@ -0,0 +1,13 @@
+import * as v from "valibot";
+export declare enum FilenameAffixStrategy {
+    prefix = "prefix",
+    suffix = "suffix"
+}
+export declare const FilenameAffixError: {
+    Type: string;
+    Empty: string;
+    TooLong: string;
+    BadChars: string;
+};
+export declare const FilenameAffix: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>, v.MaxLengthAction<string, 32, string>, v.RegexAction<string, string>, v.BrandAction<string, "FilenameAffix">]>;
+export type FilenameAffixType = v.InferOutput<typeof FilenameAffix>;

package/dist/{filename-affix.vo.js → src/filename-affix.vo.js}

@@ -1,4 +1,4 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export var FilenameAffixStrategy;
 (function (FilenameAffixStrategy) {
     FilenameAffixStrategy["prefix"] = "prefix";
@@ -12,11 +12,6 @@ export const FilenameAffixError = {
 };
 // Letters, digits, underscores, and hyphens allowed
 const FILENAME_AFFIX_WHITELIST = /^[a-zA-Z0-9_-]+$/;
-// Stryker disable all
-export const FilenameAffix = z
-    // Stryker restore all
-    .string(FilenameAffixError.Type)
-    .min(1, FilenameAffixError.Empty)
-    .max(32, FilenameAffixError.TooLong)
-    .regex(FILENAME_AFFIX_WHITELIST, FilenameAffixError.BadChars)
-    .brand("FilenameAffix");
+export const FilenameAffix = v.pipe(v.string(FilenameAffixError.Type), v.minLength(1, FilenameAffixError.Empty), v.maxLength(32, FilenameAffixError.TooLong), v.regex(FILENAME_AFFIX_WHITELIST, FilenameAffixError.BadChars), 
+// Stryker disable next-line StringLiteral
+v.brand("FilenameAffix"));

package/dist/src/filename-from-string.vo.d.ts

@@ -0,0 +1,10 @@
+import * as v from "valibot";
+export declare const FilenameFromStringError: {
+    Type: string;
+    Invalid: string;
+};
+export declare const FilenameFromString: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.RegexAction<string, string>, v.TransformAction<string, {
+    basename: string & v.Brand<"Basename">;
+    extension: string & v.Brand<"Extension">;
+}>]>;
+export type FilenameFromStringType = v.InferOutput<typeof FilenameFromString>;