@bgord/tools 0.17.2 → 1.0.0

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

@@ -0,0 +1,11 @@
+import { z } from "zod/v4";
+export declare const AgeYearsError: {
+    readonly Type: "age.years.type";
+    readonly Invalid: "age.years.invalid";
+};
+export declare const AgeYearsConstraints: {
+    min: number;
+    max: number;
+};
+export declare const AgeYears: z.core.$ZodBranded<z.ZodNumber, "AgeYears">;
+export type AgeYearsType = z.infer<typeof AgeYears>;

package/dist/age-years.vo.js

@@ -0,0 +1,9 @@
+import { z } from "zod/v4";
+export const AgeYearsError = { Type: "age.years.type", Invalid: "age.years.invalid" };
+export const AgeYearsConstraints = { min: 1, max: 130 };
+export const AgeYears = z
+    .number(AgeYearsError.Type)
+    .int(AgeYearsError.Type)
+    .min(1, AgeYearsError.Invalid)
+    .max(130, AgeYearsError.Invalid)
+    .brand("AgeYears");

package/dist/age.vo.d.ts

@@ -1,31 +1,26 @@
-import { z } from "zod/v4";
 import type { TimestampType } from "./timestamp.vo";
-export declare const AgeValueError: {
-    readonly error: "invalid.age";
+export declare const AgeError: {
+    readonly FutureBirthdate: "age.future.birthdate";
 };
-export declare const InvalidBirthdateInFutureError: "invalid.birthdate_in_future";
-export declare const InvalidBirthdateError: "invalid.birthdate";
 export declare class Age {
     private readonly value;
-    static readonly MIN = 1;
-    static readonly MAX = 130;
-    static readonly AgeValue: z.core.$ZodBranded<z.ZodNumber, "AgeValue">;
+    static readonly MIN: number;
+    static readonly MAX: number;
     private constructor();
-    get(): number;
-    compare(other: Age): -1 | 0 | 1;
-    equals(other: Age): boolean;
-    isOlderThan(other: Age): boolean;
-    isYoungerThan(other: Age): boolean;
-    isAdult(minimumAge: Age): boolean;
     static fromValue(candidate: number): Age;
     static fromBirthdateEpochMs(params: {
         birthdate: TimestampType;
         now: TimestampType;
     }): Age;
-    static fromBirthdate(params: {
+    static fromBirthdate(candidate: {
         birthdate: string;
         now: TimestampType;
     }): Age;
-    toJSON(): number;
+    get(): number;
+    equals(other: Age): boolean;
+    isOlderThan(other: Age): boolean;
+    isYoungerThan(other: Age): boolean;
+    isAdult(minimumAge: Age): boolean;
     toString(): string;
+    toJSON(): number;
 }

package/dist/age.vo.js

@@ -1,27 +1,30 @@
 import { differenceInYears } from "date-fns";
-import { z } from "zod/v4";
-export const AgeValueError = { error: "invalid.age" };
-export const InvalidBirthdateInFutureError = "invalid.birthdate_in_future";
-export const InvalidBirthdateError = "invalid.birthdate";
+import { AgeYears, AgeYearsConstraints } from "./age-years.vo";
+export const AgeError = { FutureBirthdate: "age.future.birthdate" };
 export class Age {
     value;
-    static MIN = 1;
-    static MAX = 130;
-    static AgeValue = z
-        .number(AgeValueError)
-        .int(AgeValueError)
-        .min(Age.MIN, AgeValueError)
-        .max(Age.MAX, AgeValueError)
-        .brand("AgeValue");
+    static MIN = AgeYearsConstraints.min;
+    static MAX = AgeYearsConstraints.max;
     constructor(value) {
         this.value = value;
     }
+    static fromValue(candidate) {
+        return new Age(AgeYears.parse(candidate));
+    }
+    static fromBirthdateEpochMs(params) {
+        if (params.birthdate > params.now)
+            throw new Error(AgeError.FutureBirthdate);
+        return Age.fromValue(differenceInYears(params.now, params.birthdate));
+    }
+    static fromBirthdate(candidate) {
+        const birthdateMs = new Date(candidate.birthdate).getTime();
+        if (birthdateMs > candidate.now)
+            throw new Error(AgeError.FutureBirthdate);
+        return Age.fromValue(differenceInYears(candidate.now, birthdateMs));
+    }
     get() {
         return this.value;
     }
-    compare(other) {
-        return this.value === other.value ? 0 : this.value < other.value ? -1 : 1;
-    }
     equals(other) {
         return this.value === other.value;
     }
@@ -34,24 +37,10 @@ export class Age {
     isAdult(minimumAge) {
         return this.value >= minimumAge.value;
     }
-    static fromValue(candidate) {
-        return new Age(Age.AgeValue.parse(candidate));
-    }
-    static fromBirthdateEpochMs(params) {
-        if (params.birthdate > params.now)
-            throw new Error(InvalidBirthdateInFutureError);
-        return Age.fromValue(differenceInYears(params.now, params.birthdate));
-    }
-    static fromBirthdate(params) {
-        const birthdateMs = new Date(params.birthdate).getTime();
-        if (birthdateMs > params.now)
-            throw new Error(InvalidBirthdateInFutureError);
-        return Age.fromValue(differenceInYears(params.now, birthdateMs));
+    toString() {
+        return this.value.toString();
     }
     toJSON() {
         return this.get();
     }
-    toString() {
-        return String(this.value);
-    }
 }

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

@@ -1,6 +1,8 @@
 import { z } from "zod/v4";
 export declare const ApiKeyError: {
-    error: string;
+    readonly Type: "api.key.type";
+    readonly Length: "api.key.length";
+    readonly BadChars: "api.key.bad.chars";
 };
 export declare const ApiKey: z.core.$ZodBranded<z.ZodString, "ApiKey">;
 export type ApiKeyType = z.infer<typeof ApiKey>;

package/dist/api-key.vo.js

@@ -1,8 +1,13 @@
 import { z } from "zod/v4";
-export const ApiKeyError = { error: "invalid.api.key" };
+export const ApiKeyError = {
+    Type: "api.key.type",
+    Length: "api.key.length",
+    BadChars: "api.key.bad.chars",
+};
+// 64 letters and digits allowed
+const API_KEY_CHARS = /^[a-zA-Z0-9]{64}$/;
 export const ApiKey = z
-    .string(ApiKeyError)
-    .trim()
-    .length(64, ApiKeyError)
-    .regex(/^[0-9a-zA-Z]{64}$/i, ApiKeyError)
+    .string(ApiKeyError.Type)
+    .length(64, ApiKeyError.Length)
+    .regex(API_KEY_CHARS, ApiKeyError.BadChars)
     .brand("ApiKey");

package/dist/basename.vo.d.ts

@@ -1,12 +1,12 @@
 import { z } from "zod/v4";
-export declare const BasenameTypeError: "basename.not.string";
-export declare const BasenameEmptyError: "basename.empty";
-export declare const BasenameTooLongError: "basename.too.long";
-export declare const BasenameSlashesForbiddenError: "basename.slashes.forbidden";
-export declare const BasenameControlCharsForbiddenError: "basename.control.chars.forbidden";
-export declare const BasenameDotSegmentsForbiddenError: "basename.dot.segments.forbidden";
-export declare const BasenameDotfilesForbiddenError: "basename.dotfiles.forbidden";
-export declare const BasenameTrailingDotForbiddenError: "basename.trailing.dot.forbidden";
-export declare const BasenameBadCharsError: "basename.bad.chars";
+export declare const BasenameError: {
+    readonly Type: "basename.type";
+    readonly Empty: "basename.empty";
+    readonly TooLong: "basename.too.long";
+    readonly DotSegments: "basename.dot.segments";
+    readonly Dotfiles: "basename.dotfiles";
+    readonly TrailingDot: "basename.trailing.dot";
+    readonly BadChars: "basename.bad.chars";
+};
 export declare const Basename: z.core.$ZodBranded<z.ZodString, "Basename">;
 export type BasenameType = z.infer<typeof Basename>;

package/dist/basename.vo.js

@@ -1,25 +1,25 @@
 import { z } from "zod/v4";
-export const BasenameTypeError = "basename.not.string";
-export const BasenameEmptyError = "basename.empty";
-export const BasenameTooLongError = "basename.too.long";
-export const BasenameSlashesForbiddenError = "basename.slashes.forbidden";
-export const BasenameControlCharsForbiddenError = "basename.control.chars.forbidden";
-export const BasenameDotSegmentsForbiddenError = "basename.dot.segments.forbidden";
-export const BasenameDotfilesForbiddenError = "basename.dotfiles.forbidden";
-export const BasenameTrailingDotForbiddenError = "basename.trailing.dot.forbidden";
-export const BasenameBadCharsError = "basename.bad.chars";
+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 = z
-    .string(BasenameTypeError)
-    .trim()
-    .min(1, BasenameEmptyError)
-    .max(128, BasenameTooLongError)
-    .refine((s) => !/[/\\]/.test(s), BasenameSlashesForbiddenError)
-    // dot-related checks: dot-segments first for specific errors…
-    // biome-ignore lint: lint/suspicious/noControlCharactersInRegex
-    .refine((value) => !/[\u0000-\u001F\u007F]/.test(value), BasenameControlCharsForbiddenError)
-    .refine((value) => value !== "." && value !== "..", BasenameDotSegmentsForbiddenError)
-    // …then any other dotfile
-    .refine((value) => !value.startsWith("."), BasenameDotfilesForbiddenError)
-    .refine((value) => !value.endsWith("."), BasenameTrailingDotForbiddenError)
-    .regex(/^[A-Za-z0-9._-]+$/, BasenameBadCharsError)
+    .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");

package/dist/clock.vo.d.ts

@@ -1,6 +1,8 @@
 import { type ClockFormatter } from "./clock-format.service";
 import { Hour } from "./hour.vo";
+import type { HourSchemaType } from "./hour-schema.vo";
 import { Minute } from "./minute.vo";
+import type { MinuteSchemaType } from "./minute-schema.vo";
 import type { TimestampType } from "./timestamp.vo";
 export declare class Clock {
     private readonly hour;
@@ -9,12 +11,16 @@ export declare class Clock {
     constructor(hour: Hour, minute: Minute, formatter?: ClockFormatter);
     static fromEpochMs(timestamp: TimestampType, formatter?: ClockFormatter): Clock;
     get(): {
-        hour: number;
-        minute: number;
+        hour: HourSchemaType;
+        minute: MinuteSchemaType;
     };
-    format(formatter?: ClockFormatter): string;
-    toString(): string;
+    format(): string;
     equals(another: Clock): boolean;
     isAfter(another: Clock): boolean;
     isBefore(another: Clock): boolean;
+    toString(): string;
+    toJSON(): {
+        hour: HourSchemaType;
+        minute: MinuteSchemaType;
+    };
 }

package/dist/clock.vo.js

@@ -18,28 +18,26 @@ export class Clock {
     get() {
         return { hour: this.hour.get(), minute: this.minute.get() };
     }
-    format(formatter) {
-        const chosen = formatter ?? this.formatter;
-        return chosen(this.hour, this.minute);
-    }
-    toString() {
-        return this.format();
+    format() {
+        return this.formatter(this.hour, this.minute);
     }
     equals(another) {
         return this.hour.get() === another.hour.get() && this.minute.get() === another.minute.get();
     }
     isAfter(another) {
-        const thisHour = this.hour.get();
-        const otherHour = another.hour.get();
-        if (thisHour !== otherHour)
-            return thisHour > otherHour;
+        if (this.hour.get() !== another.hour.get())
+            return this.hour.get() > another.hour.get();
         return this.minute.get() > another.minute.get();
     }
     isBefore(another) {
-        const thisHour = this.hour.get();
-        const otherHour = another.hour.get();
-        if (thisHour !== otherHour)
-            return thisHour < otherHour;
+        if (this.hour.get() !== another.hour.get())
+            return this.hour.get() < another.hour.get();
         return this.minute.get() < another.minute.get();
     }
+    toString() {
+        return this.format();
+    }
+    toJSON() {
+        return this.get();
+    }
 }

package/dist/date-calculator.service.d.ts

@@ -1,7 +1,8 @@
+import type { TimeZoneOffsetValueType } from "./time-zone-offset-value.vo";
 import { type TimestampType } from "./timestamp.vo";
 type GetStartOfDayTsInTzConfigType = {
     now: TimestampType;
-    timeZoneOffsetMs: number;
+    timeZoneOffsetMs: TimeZoneOffsetValueType;
 };
 export declare class DateCalculator {
     static getStartOfDayTsInTz(config: GetStartOfDayTsInTzConfigType): TimestampType;

package/dist/date-formatter.service.d.ts

@@ -1,10 +1,9 @@
 import { format } from "date-fns";
-type FormattedDateType = string;
 type DateFormattersInputType = Parameters<typeof format>[0];
 export declare class DateFormatters {
-    static datetime(date: DateFormattersInputType): FormattedDateType;
-    static date(date: DateFormattersInputType): FormattedDateType;
-    static monthDay(date: DateFormattersInputType): FormattedDateType;
+    static datetime(date: DateFormattersInputType): string;
+    static date(date: DateFormattersInputType): string;
+    static monthDay(date: DateFormattersInputType): string;
     static relative(date: DateFormattersInputType): string;
 }
 export {};

package/dist/date-range.vo.d.ts

@@ -1,5 +1,7 @@
 import type { TimestampType } from "./timestamp.vo";
-export declare const DateRangeInvalidError: "invalid.date.range";
+export declare const DateRangeError: {
+    readonly Invalid: "date.range.invalid";
+};
 export declare class DateRange {
     private readonly start;
     private readonly end;
@@ -9,4 +11,8 @@ export declare class DateRange {
     toRange(): [TimestampType, TimestampType];
     contains(timestamp: TimestampType): boolean;
     equals(other: DateRange): boolean;
+    toJSON(): {
+        start: number;
+        end: number;
+    };
 }

package/dist/date-range.vo.js

@@ -1,4 +1,4 @@
-export const DateRangeInvalidError = "invalid.date.range";
+export const DateRangeError = { Invalid: "date.range.invalid" };
 export class DateRange {
     start;
     end;
@@ -6,7 +6,7 @@ export class DateRange {
         this.start = start;
         this.end = end;
         if (start > end)
-            throw new Error(DateRangeInvalidError);
+            throw new Error(DateRangeError.Invalid);
     }
     getStart() {
         return this.start;
@@ -23,4 +23,7 @@ export class DateRange {
     equals(other) {
         return this.start === other.start && this.end === other.end;
     }
+    toJSON() {
+        return { start: this.getStart(), end: this.getEnd() };
+    }
 }

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

@@ -1,6 +1,9 @@
 import { z } from "zod/v4";
 export declare const DayIsoIdError: {
-    readonly error: "invalid.day.iso.id";
+    readonly Type: "day.iso.id.type";
+    readonly BadChars: "day.iso.id.bad.chars";
+    readonly InvalidDate: "day.iso.id.invalid.date";
 };
-export declare const DayIsoId: z.ZodString;
+export declare const DAY_ISO_ID_CHARS: RegExp;
+export declare const DayIsoId: z.core.$ZodBranded<z.ZodString, "DayIsoId">;
 export type DayIsoIdType = z.infer<typeof DayIsoId>;

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

@@ -1,10 +1,14 @@
 import { isValid, parseISO } from "date-fns";
 import { z } from "zod/v4";
-export const DayIsoIdError = { error: "invalid.day.iso.id" };
+export const DayIsoIdError = {
+    Type: "day.iso.id.type",
+    BadChars: "day.iso.id.bad.chars",
+    InvalidDate: "day.iso.id.invalid.date",
+};
+// Four digits, hyphen, two digits, hyphen, two digits
+export const DAY_ISO_ID_CHARS = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/;
 export const DayIsoId = z
-    .string(DayIsoIdError)
-    .regex(/^\d{4}-\d{2}-\d{2}$/, DayIsoIdError)
-    .refine((value) => {
-    const date = parseISO(value);
-    return isValid(date) && value === date.toISOString().slice(0, 10);
-}, DayIsoIdError);
+    .string(DayIsoIdError.Type)
+    .regex(DAY_ISO_ID_CHARS, DayIsoIdError.BadChars)
+    .refine((value) => isValid(parseISO(value)), DayIsoIdError.InvalidDate)
+    .brand("DayIsoId");

package/dist/day.vo.d.ts

@@ -3,11 +3,12 @@ import { type DayIsoIdType } from "./day-iso-id.vo";
 import { type TimestampType } from "./timestamp.vo";
 export declare class Day extends DateRange {
     private constructor();
+    static fromTimestamp(timestamp: TimestampType): Day;
+    static fromNow(now: TimestampType): Day;
+    static fromIsoId(isoId: DayIsoIdType): Day;
     toIsoId(): DayIsoIdType;
     previous(): Day;
     next(): Day;
     shift(count: number): Day;
-    static fromTimestamp(timestamp: TimestampType): Day;
-    static fromNow(now: TimestampType): Day;
-    static fromIsoId(isoId: DayIsoIdType): Day;
+    toString(): string;
 }

package/dist/day.vo.js

@@ -1,3 +1,4 @@
+import { formatISO } from "date-fns";
 import { DateRange } from "./date-range.vo";
 import { DayIsoId } from "./day-iso-id.vo";
 import { Duration } from "./duration.service";
@@ -6,22 +7,6 @@ export class Day extends DateRange {
     constructor(start, end) {
         super(start, end);
     }
-    toIsoId() {
-        const midday = this.getStart() + Duration.Hours(12).ms;
-        return new Date(midday).toISOString().slice(0, 10);
-    }
-    previous() {
-        const shifted = this.getStart() - Duration.Days(1).ms;
-        return Day.fromTimestamp(Timestamp.parse(shifted));
-    }
-    next() {
-        const shifted = this.getStart() + Duration.Days(1).ms;
-        return Day.fromTimestamp(Timestamp.parse(shifted));
-    }
-    shift(count) {
-        const shifted = this.getStart() + count * Duration.Days(1).ms;
-        return Day.fromTimestamp(Timestamp.parse(shifted));
-    }
     static fromTimestamp(timestamp) {
         const date = new Date(timestamp);
         const startUtc = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
@@ -37,4 +22,21 @@ export class Day extends DateRange {
         const endUtc = startUtc + Duration.Days(1).ms - 1;
         return new Day(Timestamp.parse(startUtc), Timestamp.parse(endUtc));
     }
+    toIsoId() {
+        const midday = this.getStart() + Duration.Hours(12).ms;
+        return DayIsoId.parse(formatISO(midday, { representation: "date" }));
+    }
+    previous() {
+        return this.shift(-1);
+    }
+    next() {
+        return this.shift(1);
+    }
+    shift(count) {
+        const timestamp = this.getStart() + count * Duration.Days(1).ms;
+        return Day.fromTimestamp(Timestamp.parse(timestamp));
+    }
+    toString() {
+        return this.toIsoId();
+    }
 }

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

@@ -1,8 +1,12 @@
 import { z } from "zod/v4";
-export declare const AbsDirTypeError: "abs_dir.not.string";
-export declare const AbsDirMustStartWithSlashError: "abs_dir_must_start_with_slash";
-export declare const AbsDirBackslashForbiddenError: "abs_dir_backslash_forbidden";
-export declare const AbsDirControlCharsForbiddenError: "abs_dir_control_chars_forbidden";
-export declare const AbsDirBadSegmentsError: "abs_dir_bad_segments";
-export declare const DirectoryPathAbsoluteSchema: z.core.$ZodBranded<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodTransform<string, string>>, "directory_path_absolute">;
+export declare const DirectoryPathAbsoluteError: {
+    readonly BadSegments: "directory.path.absolue.bad.segments";
+    readonly Empty: "directory.path.absolue.empty";
+    readonly LeadingSlash: "directory.path.absolue.leading.slash";
+    readonly TooLong: "directory.path.absolue.too.long";
+    readonly TrailingSlash: "directory.path.absolue.trailing.slash";
+    readonly Type: "directory.path.absolue.type";
+};
+export declare const DIRECTORY_PATH_ABSOLUTE_CHARS: RegExp;
+export declare const DirectoryPathAbsoluteSchema: z.core.$ZodBranded<z.ZodString, "DirectoryPathAbsoluteSchema">;
 export type DirectoryPathAbsoluteType = z.infer<typeof DirectoryPathAbsoluteSchema>;

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

@@ -1,23 +1,25 @@
 import { z } from "zod/v4";
-export const AbsDirTypeError = "abs_dir.not.string";
-export const AbsDirMustStartWithSlashError = "abs_dir_must_start_with_slash";
-export const AbsDirBackslashForbiddenError = "abs_dir_backslash_forbidden";
-export const AbsDirControlCharsForbiddenError = "abs_dir_control_chars_forbidden";
-export const AbsDirBadSegmentsError = "abs_dir_bad_segments";
+export const DirectoryPathAbsoluteError = {
+    BadSegments: "directory.path.absolue.bad.segments",
+    Empty: "directory.path.absolue.empty",
+    LeadingSlash: "directory.path.absolue.leading.slash",
+    TooLong: "directory.path.absolue.too.long",
+    TrailingSlash: "directory.path.absolue.trailing.slash",
+    Type: "directory.path.absolue.type",
+};
+// Letters, digits, dots, underscores, and hyphens
+export const DIRECTORY_PATH_ABSOLUTE_CHARS = /^[a-zA-Z0-9._-]+$/;
+const DOT_SEGMENTS = [".", ".."];
 export const DirectoryPathAbsoluteSchema = z
-    .string(AbsDirTypeError)
-    .trim()
-    .refine((value) => value.startsWith("/"), AbsDirMustStartWithSlashError)
-    .refine((value) => !value.includes("\\"), AbsDirBackslashForbiddenError)
-    // biome-ignore lint: lint/suspicious/noControlCharactersInRegex
-    .refine((value) => !/[\u0000-\u001F\u007F]/.test(value), AbsDirControlCharsForbiddenError)
-    // collapse duplicate slashes, then drop trailing slash unless it's the root "/"
-    .transform((value) => value.replace(/\/{2,}/g, "/"))
-    .transform((value) => (value !== "/" && value.endsWith("/") ? value.slice(0, -1) : value))
+    .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) => {
     if (value === "/")
         return true;
     const segments = value.slice(1).split("/");
-    return segments.every((segment) => segment.length > 0 && /^[A-Za-z0-9._-]+$/.test(segment) && segment !== "." && segment !== "..");
-}, AbsDirBadSegmentsError)
-    .brand("directory_path_absolute");
+    return segments.every((segment) => DIRECTORY_PATH_ABSOLUTE_CHARS.test(segment) && !DOT_SEGMENTS.includes(segment));
+}, DirectoryPathAbsoluteError.BadSegments)
+    .brand("DirectoryPathAbsoluteSchema");

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

@@ -1,9 +1,12 @@
 import { z } from "zod/v4";
-export declare const RelDirTypeError: "rel_dir.not.string";
-export declare const RelDirMustNotStartWithSlashError: "rel_dir_must_not_start_with_slash";
-export declare const RelDirBackslashForbiddenError: "rel_dir_backslash_forbidden";
-export declare const RelDirControlCharsForbiddenError: "rel_dir_control_chars_forbidden";
-export declare const RelDirEmptyError: "rel_dir_empty";
-export declare const RelDirBadSegmentsError: "rel_dir_bad_segments";
-export declare const DirectoryPathRelativeSchema: z.core.$ZodBranded<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodTransform<string, string>>, "directory_path_relative">;
+export declare const DirectoryPathRelativeError: {
+    readonly BadSegments: "directory.path.relative.bad.segments";
+    readonly Empty: "directory.path.relative.empty";
+    readonly LeadingSlash: "directory.path.relative.leading.slash";
+    readonly TooLong: "directory.path.absolue.too.long";
+    readonly TrailingSlash: "directory.path.absolue.trailing.slash";
+    readonly Type: "directory.path.relative.not.type";
+};
+export declare const DIRECTORY_PATH_RELATIVE_CHARS: RegExp;
+export declare const DirectoryPathRelativeSchema: z.core.$ZodBranded<z.ZodString, "DirectoryPathRelativeSchema">;
 export type DirectoryPathRelativeType = z.infer<typeof DirectoryPathRelativeSchema>;

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

@@ -1,21 +1,22 @@
 import { z } from "zod/v4";
-export const RelDirTypeError = "rel_dir.not.string";
-export const RelDirMustNotStartWithSlashError = "rel_dir_must_not_start_with_slash";
-export const RelDirBackslashForbiddenError = "rel_dir_backslash_forbidden";
-export const RelDirControlCharsForbiddenError = "rel_dir_control_chars_forbidden";
-export const RelDirEmptyError = "rel_dir_empty";
-export const RelDirBadSegmentsError = "rel_dir_bad_segments";
+export const DirectoryPathRelativeError = {
+    BadSegments: "directory.path.relative.bad.segments",
+    Empty: "directory.path.relative.empty",
+    LeadingSlash: "directory.path.relative.leading.slash",
+    TooLong: "directory.path.absolue.too.long",
+    TrailingSlash: "directory.path.absolue.trailing.slash",
+    Type: "directory.path.relative.not.type",
+};
+// Letters, digits, dots, underscores, and hyphens
+export const DIRECTORY_PATH_RELATIVE_CHARS = /^[A-Za-z0-9._-]+$/;
+const DOT_SEGMENTS = [".", ".."];
 export const DirectoryPathRelativeSchema = z
-    .string(RelDirTypeError)
-    .trim()
-    .refine((value) => !value.startsWith("/"), RelDirMustNotStartWithSlashError)
-    .refine((value) => !value.includes("\\"), RelDirBackslashForbiddenError)
-    // biome-ignore lint: lint/suspicious/noControlCharactersInRegex
-    .refine((value) => !/[\u0000-\u001F\u007F]/.test(value), RelDirControlCharsForbiddenError)
-    .transform((value) => value.replace(/\/{2,}/g, "/"))
-    .transform((value) => value.replace(/^\/+|\/+$/g, ""))
-    .refine((value) => value.length > 0, RelDirEmptyError)
+    .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
     .split("/")
-    .every((segment) => /^[A-Za-z0-9._-]+$/.test(segment) && segment !== "." && segment !== ".."), RelDirBadSegmentsError)
-    .brand("directory_path_relative");
+    .every((segment) => DIRECTORY_PATH_RELATIVE_CHARS.test(segment) && !DOT_SEGMENTS.includes(segment)), DirectoryPathRelativeError.BadSegments)
+    .brand("DirectoryPathRelativeSchema");

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

@@ -0,0 +1,7 @@
+import { z } from "zod/v4";
+export declare const DivisionFactorError: {
+    readonly Type: "division.factor.type";
+    readonly Invalid: "division.factor.invalid";
+};
+export declare const DivisionFactor: z.core.$ZodBranded<z.ZodNumber, "DivisionFactor">;
+export type DivisionFactorType = z.infer<typeof DivisionFactor>;

package/dist/division-factor.vo.js

@@ -0,0 +1,9 @@
+import { z } from "zod/v4";
+export const DivisionFactorError = {
+    Type: "division.factor.type",
+    Invalid: "division.factor.invalid",
+};
+export const DivisionFactor = z
+    .number(DivisionFactorError.Type)
+    .gt(0, DivisionFactorError.Invalid)
+    .brand("DivisionFactor");