@bgord/tools 0.15.1 → 0.16.0

package/dist/basename.vo.d.ts

@@ -1,3 +1,12 @@
 import { z } from "zod/v4";
-export declare const BasenameSchema: z.core.$ZodBranded<z.ZodString, "basename">;
-export type BasenameType = z.infer<typeof BasenameSchema>;
+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 Basename: z.core.$ZodBranded<z.ZodString, "Basename">;
+export type BasenameType = z.infer<typeof Basename>;

package/dist/basename.vo.js

@@ -1,16 +1,25 @@
 import { z } from "zod/v4";
-export const BasenameSchema = z
-    .string()
+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 Basename = z
+    .string(BasenameTypeError)
     .trim()
-    .min(1, "basename_empty")
-    .max(128, "basename_too_long")
-    .refine((s) => !/[/\\]/.test(s), "basename_slashes_forbidden")
+    .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((s) => !/[\u0000-\u001F\u007F]/.test(s), "basename_control_chars_forbidden")
-    // check dot-segments FIRST so "." / ".." get the intended error
-    .refine((s) => s !== "." && s !== "..", "basename_dot_segments_forbidden")
-    // then disallow any other dotfile (".env", ".gitignore", etc.)
-    .refine((s) => !s.startsWith("."), "basename_dotfiles_forbidden")
-    .refine((s) => !s.endsWith("."), "basename_trailing_dot_forbidden")
-    .regex(/^[A-Za-z0-9._-]+$/, "basename_bad_chars")
-    .brand("basename");
+    .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)
+    .brand("Basename");

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

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

package/dist/date-calculator.service.js

@@ -1,16 +1,15 @@
 import { Time } from "./time.service";
+import { Timestamp } from "./timestamp.vo";
 export class DateCalculator {
     static getStartOfDayTsInTz(config) {
-        const startOfDayUTC = new Date();
-        startOfDayUTC.setUTCHours(0, 0, 0, 0);
-        const startOfDayInTimeZone = startOfDayUTC.getTime() + config.timeZoneOffsetMs;
-        const timeSinceNewDayInTimeZoneRelativeToUtcStartOfDay = (config.now - startOfDayInTimeZone) % Time.Days(1).ms;
-        if (timeSinceNewDayInTimeZoneRelativeToUtcStartOfDay >= Time.Days(1).ms) {
-            return config.now - timeSinceNewDayInTimeZoneRelativeToUtcStartOfDay + Time.Days(1).ms;
-        }
-        if (timeSinceNewDayInTimeZoneRelativeToUtcStartOfDay >= 0) {
-            return config.now - timeSinceNewDayInTimeZoneRelativeToUtcStartOfDay;
-        }
-        return config.now - timeSinceNewDayInTimeZoneRelativeToUtcStartOfDay - Time.Days(1).ms;
+        const dayMs = Time.Days(1).ms;
+        // UTC midnight for the UTC date of `now`
+        const utcMidnight = Math.floor(config.now / dayMs) * dayMs;
+        // Candidate start of the local day (in UTC), anchored to the same UTC date
+        let start = utcMidnight + config.timeZoneOffsetMs;
+        // If the candidate is in the future relative to `now`, it means local midnight was "yesterday" in UTC.
+        if (start > config.now)
+            start -= dayMs;
+        return Timestamp.parse(start);
     }
 }

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

@@ -1,4 +1,5 @@
 import type { TimestampType } from "./timestamp.vo";
+export declare const DateRangeInvalidError: "invalid.date.range";
 export declare class DateRange {
     private readonly start;
     private readonly end;

package/dist/date-range.vo.js

@@ -1,3 +1,4 @@
+export const DateRangeInvalidError = "invalid.date.range";
 export class DateRange {
     start;
     end;
@@ -5,7 +6,7 @@ export class DateRange {
         this.start = start;
         this.end = end;
         if (start > end)
-            throw new Error("Invalid date range");
+            throw new Error(DateRangeInvalidError);
     }
     getStart() {
         return this.start;

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

@@ -1,3 +1,6 @@
 import { z } from "zod/v4";
+export declare const DayIsoIdError: {
+    readonly error: "invalid.day.iso.id";
+};
 export declare const DayIsoId: z.ZodString;
 export type DayIsoIdType = z.infer<typeof DayIsoId>;

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

@@ -1,10 +1,10 @@
 import { isValid, parseISO } from "date-fns";
 import { z } from "zod/v4";
+export const DayIsoIdError = { error: "invalid.day.iso.id" };
 export const DayIsoId = z
-    .string()
-    // 4-digit year, 2-digit month, 2-digit day
-    .regex(/^\d{4}-\d{2}-\d{2}$/)
+    .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);
-}, { message: "day-iso-id.invalid" });
+}, DayIsoIdError);

package/dist/day.vo.js

@@ -1,4 +1,3 @@
-import { addDays, endOfDay, startOfDay } from "date-fns";
 import { DateRange } from "./date-range.vo";
 import { DayIsoId } from "./day-iso-id.vo";
 import { Time } from "./time.service";
@@ -8,31 +7,34 @@ export class Day extends DateRange {
         super(start, end);
     }
     toIsoId() {
-        return new Date(this.getStart() + Time.Hours(12).ms).toISOString().slice(0, 10);
+        const midday = this.getStart() + Time.Hours(12).ms;
+        return new Date(midday).toISOString().slice(0, 10);
     }
     previous() {
-        const shifted = addDays(new Date(this.getStart()), -1).getTime();
+        const shifted = this.getStart() - Time.Days(1).ms;
         return Day.fromTimestamp(Timestamp.parse(shifted));
     }
     next() {
-        const shifted = addDays(new Date(this.getStart()), 1).getTime();
+        const shifted = this.getStart() + Time.Days(1).ms;
         return Day.fromTimestamp(Timestamp.parse(shifted));
     }
     shift(count) {
-        const shifted = addDays(new Date(this.getStart()), count).getTime();
+        const shifted = this.getStart() + count * Time.Days(1).ms;
         return Day.fromTimestamp(Timestamp.parse(shifted));
     }
     static fromTimestamp(timestamp) {
-        const start = Timestamp.parse(startOfDay(timestamp).getTime());
-        const end = Timestamp.parse(endOfDay(timestamp).getTime());
-        return new Day(start, end);
+        const date = new Date(timestamp);
+        const startUtc = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+        const endUtc = startUtc + Time.Days(1).ms - 1;
+        return new Day(Timestamp.parse(startUtc), Timestamp.parse(endUtc));
     }
     static fromNow(now) {
         return Day.fromTimestamp(now);
     }
     static fromIsoId(isoId) {
         const [year, month, day] = DayIsoId.parse(isoId).split("-").map(Number);
-        const reference = new Date(Date.UTC(year, month - 1, day));
-        return Day.fromTimestamp(Timestamp.parse(reference.getTime()));
+        const startUtc = Date.UTC(year, month - 1, day);
+        const endUtc = startUtc + Time.Days(1).ms - 1;
+        return new Day(Timestamp.parse(startUtc), Timestamp.parse(endUtc));
     }
 }

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

@@ -1,3 +1,8 @@
 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 type DirectoryPathAbsoluteType = z.infer<typeof DirectoryPathAbsoluteSchema>;

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

@@ -1,11 +1,17 @@
 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 DirectoryPathAbsoluteSchema = z
-    .string()
+    .string(AbsDirTypeError)
     .trim()
-    .refine((value) => value.startsWith("/"), "abs_dir_must_start_with_slash")
-    .refine((value) => !value.includes("\\"), "abs_dir_backslash_forbidden")
+    .refine((value) => value.startsWith("/"), AbsDirMustStartWithSlashError)
+    .refine((value) => !value.includes("\\"), AbsDirBackslashForbiddenError)
     // biome-ignore lint: lint/suspicious/noControlCharactersInRegex
-    .refine((value) => !/[\u0000-\u001F\u007F]/.test(value), "abs_dir_control_chars_forbidden")
+    .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))
     .refine((value) => {
@@ -13,5 +19,5 @@ export const DirectoryPathAbsoluteSchema = z
         return true;
     const segments = value.slice(1).split("/");
     return segments.every((segment) => segment.length > 0 && /^[A-Za-z0-9._-]+$/.test(segment) && segment !== "." && segment !== "..");
-}, "abs_dir_bad_segments")
+}, AbsDirBadSegmentsError)
     .brand("directory_path_absolute");

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

@@ -1,3 +1,9 @@
 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 type DirectoryPathRelativeType = z.infer<typeof DirectoryPathRelativeSchema>;

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

@@ -1,15 +1,21 @@
 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 DirectoryPathRelativeSchema = z
-    .string()
+    .string(RelDirTypeError)
     .trim()
-    .refine((value) => !value.startsWith("/"), "rel_dir_must_not_start_with_slash")
-    .refine((value) => !value.includes("\\"), "rel_dir_backslash_forbidden")
+    .refine((value) => !value.startsWith("/"), RelDirMustNotStartWithSlashError)
+    .refine((value) => !value.includes("\\"), RelDirBackslashForbiddenError)
     // biome-ignore lint: lint/suspicious/noControlCharactersInRegex
-    .refine((value) => !/[\u0000-\u001F\u007F]/.test(value), "rel_dir_control_chars_forbidden")
+    .refine((value) => !/[\u0000-\u001F\u007F]/.test(value), RelDirControlCharsForbiddenError)
     .transform((value) => value.replace(/\/{2,}/g, "/"))
     .transform((value) => value.replace(/^\/+|\/+$/g, ""))
-    .refine((value) => value.length > 0, "rel_dir_empty")
+    .refine((value) => value.length > 0, RelDirEmptyError)
     .refine((value) => value
     .split("/")
-    .every((segment) => /^[A-Za-z0-9._-]+$/.test(segment) && segment !== "." && segment !== ".."), "rel_dir_bad_segments")
+    .every((segment) => /^[A-Za-z0-9._-]+$/.test(segment) && segment !== "." && segment !== ".."), RelDirBadSegmentsError)
     .brand("directory_path_relative");

package/dist/dll.service.js

@@ -7,21 +7,19 @@ export class Node {
     }
     forward(n) {
         let currentNode = this;
-        for (let i = 0; i < n; i++) {
-            if (currentNode === null) {
-                return currentNode;
-            }
+        let steps = n;
+        while (steps > 0 && currentNode) {
             currentNode = currentNode.next;
+            steps -= 1;
         }
         return currentNode;
     }
     backward(n) {
         let currentNode = this;
-        for (let i = 0; i < n; i++) {
-            if (currentNode === null) {
-                return currentNode;
-            }
+        let steps = n;
+        while (steps > 0 && currentNode) {
             currentNode = currentNode.prev;
+            steps -= 1;
         }
         return currentNode;
     }
@@ -44,30 +42,28 @@ export class DoublyLinkedList {
         return this.tail;
     }
     append(node) {
-        if (this.head === null || this.tail === null) {
-            this.size++;
+        if (this.tail === null) {
             this.head = node;
             this.tail = node;
         }
         else {
-            this.size++;
             this.tail.next = node;
             node.prev = this.tail;
             this.tail = node;
         }
+        this.size += 1;
     }
     prepend(node) {
-        if (this.head === null || this.tail === null) {
-            this.size++;
+        if (this.head === null) {
             this.head = node;
             this.tail = node;
         }
         else {
-            this.size++;
             node.next = this.head;
             this.head.prev = node;
             this.head = node;
         }
+        this.size += 1;
     }
     clear() {
         this.size = 0;
@@ -87,43 +83,53 @@ export class DoublyLinkedList {
         else {
             this.tail = node.prev;
         }
-        this.size--;
+        this.size -= 1;
         node.prev = null;
         node.next = null;
     }
     insertAfter(node, target) {
         if (target === this.tail) {
             this.append(node);
+            return;
         }
-        else {
-            this.size++;
-            node.prev = target;
-            node.next = target.next;
-            // biome-ignore lint: lint/style/noNonNullAssertion
-            target.next.prev = node;
-            target.next = node;
+        const nextNode = target.next;
+        this.size += 1;
+        node.prev = target;
+        node.next = nextNode;
+        if (nextNode) {
+            nextNode.prev = node;
         }
+        target.next = node;
     }
     insertBefore(node, target) {
         if (target === this.head) {
             this.prepend(node);
+            return;
         }
-        else {
-            this.size++;
-            node.next = target;
-            node.prev = target.prev;
-            // biome-ignore lint: lint/style/noNonNullAssertion
-            target.prev.next = node;
-            target.prev = node;
+        const prevNode = target.prev;
+        this.size += 1;
+        node.next = target;
+        node.prev = prevNode;
+        if (prevNode) {
+            prevNode.next = node;
         }
+        target.prev = node;
     }
     find(callback) {
-        return Array.from(this).find(callback) ?? null;
+        let current = this.head;
+        while (current) {
+            if (callback(current))
+                return current;
+            current = current.next;
+        }
+        return null;
     }
     reverse() {
         [this.head, this.tail] = [this.tail, this.head];
         for (const node of this) {
-            [node.prev, node.next] = [node.next, node.prev];
+            const originalNext = node.next;
+            node.next = node.prev;
+            node.prev = originalNext;
         }
     }
     toArray() {

package/dist/extension.vo.d.ts

@@ -1,3 +1,7 @@
 import { z } from "zod/v4";
-export declare const ExtensionSchema: z.core.$ZodBranded<z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodTransform<string, string>>, z.ZodString>, "extension">;
-export type ExtensionType = z.infer<typeof ExtensionSchema>;
+export declare const ExtensionTypeError: "extension.not.string";
+export declare const ExtensionEmptyError: "extension.empty";
+export declare const ExtensionTooLongError: "extension.too.long";
+export declare const ExtensionBadCharsError: "extension.bad.chars";
+export declare const Extension: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, "Extension">;
+export type ExtensionType = z.infer<typeof Extension>;

package/dist/extension.vo.js

@@ -1,12 +1,14 @@
 import { z } from "zod/v4";
-export const ExtensionSchema = z
-    .string()
+export const ExtensionTypeError = "extension.not.string";
+export const ExtensionEmptyError = "extension.empty";
+export const ExtensionTooLongError = "extension.too.long";
+export const ExtensionBadCharsError = "extension.bad.chars";
+export const Extension = z
+    .string(ExtensionTypeError)
     .trim()
+    .toLowerCase()
     .transform((value) => (value.startsWith(".") ? value.slice(1) : value))
-    .transform((value) => value.toLowerCase())
-    .pipe(z
-    .string()
-    .min(1, "extension_empty")
-    .max(16, "extension_too_long")
-    .regex(/^[a-z0-9]+$/, "extension_bad_chars"))
-    .brand("extension");
+    .refine((value) => value.length >= 1, ExtensionEmptyError)
+    .refine((value) => value.length <= 16, ExtensionTooLongError)
+    .refine((value) => /^[a-z0-9]+$/.test(value), ExtensionBadCharsError)
+    .brand("Extension");

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

@@ -1,6 +1,11 @@
 import { z } from "zod/v4";
 import { Filename } from "./filename.vo";
+export declare const AbsFilePathTypeError: "abs.file.path.not.string";
+export declare const AbsFilePathMustStartWithSlashError: "abs_file_path_must_start_with_slash";
+export declare const AbsFilePathBackslashForbiddenError: "abs_file_path_backslash_forbidden";
+export declare const AbsFilePathMissingFilenameError: "abs_file_path_missing_filename";
 export declare const FilePathAbsoluteSchema: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodTransform<string, string>>, z.ZodTransform<{
     directory: string & z.core.$brand<"directory_path_absolute">;
     filename: Filename;
 }, string>>;
+export type FilePathAbsoluteType = z.infer<typeof FilePathAbsoluteSchema>;

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

@@ -1,14 +1,20 @@
 import { z } from "zod/v4";
 import { DirectoryPathAbsoluteSchema } from "./directory-path-absolute.vo";
 import { Filename } from "./filename.vo";
+export const AbsFilePathTypeError = "abs.file.path.not.string";
+export const AbsFilePathMustStartWithSlashError = "abs_file_path_must_start_with_slash";
+export const AbsFilePathBackslashForbiddenError = "abs_file_path_backslash_forbidden";
+export const AbsFilePathMissingFilenameError = "abs_file_path_missing_filename";
 export const FilePathAbsoluteSchema = z
-    .string()
+    .string(AbsFilePathTypeError)
     .trim()
-    .refine((value) => value.startsWith("/"), "abs_file_path_must_start_with_slash")
-    .refine((value) => !value.includes("\\"), "abs_file_path_backslash_forbidden")
-    .transform((value) => value.replace(/\/{2,}/g, "/")) // collapse //
-    .transform((value) => (value !== "/" && value.endsWith("/") ? value.slice(0, -1) : value)) // keep "/" as-is
-    .refine((value) => value !== "/", "abs_file_path_missing_filename")
+    .refine((value) => value.startsWith("/"), AbsFilePathMustStartWithSlashError)
+    .refine((value) => !value.includes("\\"), AbsFilePathBackslashForbiddenError)
+    // collapse duplicate slashes
+    .transform((value) => value.replace(/\/{2,}/g, "/"))
+    // keep "/" as-is; otherwise remove a trailing slash
+    .transform((value) => (value !== "/" && value.endsWith("/") ? value.slice(0, -1) : value))
+    .refine((value) => value !== "/", AbsFilePathMissingFilenameError)
     .transform((normalized) => {
     const lastSlashIndex = normalized.lastIndexOf("/");
     const directoryCandidate = lastSlashIndex === 0 ? "/" : normalized.slice(0, lastSlashIndex);

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

@@ -1,6 +1,11 @@
 import { z } from "zod/v4";
 import { Filename } from "./filename.vo";
-export declare const FilePathRelativeSchema: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodTransform<string, string>>, z.ZodTransform<{
+export declare const RelFilePathTypeError: "rel.file.path.not.string";
+export declare const RelFilePathMustNotStartWithSlashError: "rel_file_path_must_not_start_with_slash";
+export declare const RelFilePathBackslashForbiddenError: "rel_file_path_backslash_forbidden";
+export declare const RelFilePathRequiresDirectoryError: "rel_file_path_requires_directory";
+export declare const FilePathRelativeSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodTransform<{
     directory: string & z.core.$brand<"directory_path_relative">;
     filename: Filename;
 }, string>>;
+export type FilePathRelativeType = z.infer<typeof FilePathRelativeSchema>;

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

@@ -1,14 +1,18 @@
 import { z } from "zod/v4";
 import { DirectoryPathRelativeSchema } from "./directory-path-relative.vo";
 import { Filename } from "./filename.vo";
+export const RelFilePathTypeError = "rel.file.path.not.string";
+export const RelFilePathMustNotStartWithSlashError = "rel_file_path_must_not_start_with_slash";
+export const RelFilePathBackslashForbiddenError = "rel_file_path_backslash_forbidden";
+export const RelFilePathRequiresDirectoryError = "rel_file_path_requires_directory";
 export const FilePathRelativeSchema = z
-    .string()
+    .string(RelFilePathTypeError)
     .trim()
-    .refine((value) => !value.startsWith("/"), "rel_file_path_must_not_start_with_slash")
-    .refine((value) => !value.includes("\\"), "rel_file_path_backslash_forbidden")
-    .transform((value) => value.replace(/\/{2,}/g, "/")) // collapse //
-    .transform((value) => value.replace(/^\/+|\/+$/g, "")) // trim leading/trailing slashes
-    .refine((value) => value.includes("/"), "rel_file_path_requires_directory")
+    .refine((value) => !value.startsWith("/"), RelFilePathMustNotStartWithSlashError)
+    .refine((value) => !value.includes("\\"), RelFilePathBackslashForbiddenError)
+    // collapse duplicate slashes, then trim leading/trailing slashes
+    .transform((value) => value.replace(/\/{2,}/g, "/").replace(/^\/+|\/+$/g, ""))
+    .refine((value) => value.includes("/"), RelFilePathRequiresDirectoryError)
     .transform((normalized) => {
     const lastSlashIndex = normalized.lastIndexOf("/");
     const directoryCandidate = normalized.slice(0, lastSlashIndex);

package/dist/file-path.vo.js

@@ -17,8 +17,8 @@ export class FilePathRelative {
         return new FilePathRelative(directory, filename);
     }
     static fromString(pathCandidate) {
-        const { directory, filename } = FilePathRelativeSchema.parse(pathCandidate);
-        return new FilePathRelative(directory, filename);
+        const parsed = FilePathRelativeSchema.parse(pathCandidate);
+        return new FilePathRelative(parsed.directory, parsed.filename);
     }
     get() {
         return `${this.directory}/${this.filename.get()}`;
@@ -54,8 +54,8 @@ export class FilePathAbsolute {
         return new FilePathAbsolute(directory, filename);
     }
     static fromString(pathCandidate) {
-        const { directory, filename } = FilePathAbsoluteSchema.parse(pathCandidate);
-        return new FilePathAbsolute(directory, filename);
+        const parsed = FilePathAbsoluteSchema.parse(pathCandidate);
+        return new FilePathAbsolute(parsed.directory, parsed.filename);
     }
     get() {
         if (this.directory === "/")

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

@@ -1,6 +1,8 @@
 import { z } from "zod/v4";
-export declare const FilenameFromStringSchema: z.ZodPipe<z.ZodString, z.ZodTransform<{
-    basename: string & z.core.$brand<"basename">;
-    extension: string & z.core.$brand<"extension">;
+export declare const FilenameTypeError: "filename.not.string";
+export declare const FilenameInvalidError: "filename.invalid";
+export declare const FilenameFromString: z.ZodPipe<z.ZodString, z.ZodTransform<{
+    basename: string & z.core.$brand<"Basename">;
+    extension: string & z.core.$brand<"Extension">;
 }, string>>;
-export type FilenameFromString = z.infer<typeof FilenameFromStringSchema>;
+export type FilenameFromStringType = z.infer<typeof FilenameFromString>;

package/dist/filename-from-string.vo.js

@@ -1,17 +1,18 @@
 import { z } from "zod/v4";
-import { BasenameSchema } from "./basename.vo";
-import { ExtensionSchema } from "./extension.vo";
-export const FilenameFromStringSchema = z
-    .string()
+import { Basename } from "./basename.vo";
+import { Extension } from "./extension.vo";
+export const FilenameTypeError = "filename.not.string";
+export const FilenameInvalidError = "filename.invalid";
+export const FilenameFromString = z
+    .string(FilenameTypeError)
     .trim()
-    .refine((string) => {
-    const index = string.lastIndexOf(".");
-    return index > 0 && index < string.length - 1;
-}, "filename_invalid")
-    // split and validate parts using existing schemas
-    .transform((string) => {
-    const index = string.lastIndexOf(".");
-    const base = BasenameSchema.parse(string.slice(0, index));
-    const extension = ExtensionSchema.parse(string.slice(index + 1));
-    return { basename: base, extension: extension };
+    .refine((value) => {
+    const index = value.lastIndexOf(".");
+    return index > 0 && index < value.length - 1;
+}, FilenameInvalidError)
+    .transform((value) => {
+    const index = value.lastIndexOf(".");
+    const basename = Basename.parse(value.slice(0, index));
+    const extension = Extension.parse(value.slice(index + 1));
+    return { basename, extension };
 });

package/dist/filename-suffix.vo.d.ts

@@ -1,3 +1,5 @@
 import { z } from "zod/v4";
-export declare const FilenameSuffixSchema: z.core.$ZodBranded<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>, "basename_suffix">;
-export type FilenameSuffixSchemaType = z.infer<typeof FilenameSuffixSchema>;
+export declare const FilenameSuffixTypeError: "suffix.not.string";
+export declare const FilenameSuffixTooLongError: "suffix_too_long";
+export declare const FilenameSuffix: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, "basename_suffix">;
+export type FilenameSuffixType = z.infer<typeof FilenameSuffix>;

package/dist/filename-suffix.vo.js

@@ -1,7 +1,9 @@
 import { z } from "zod/v4";
-export const FilenameSuffixSchema = z
-    .string()
+export const FilenameSuffixTypeError = "suffix.not.string";
+export const FilenameSuffixTooLongError = "suffix_too_long";
+export const FilenameSuffix = z
+    .string(FilenameSuffixTypeError)
     .trim()
     .transform((value) => value.replace(/[^A-Za-z0-9_-]/g, ""))
-    .pipe(z.string().max(32, "suffix_too_long"))
+    .refine((value) => value.length <= 32, FilenameSuffixTooLongError)
     .brand("basename_suffix");