@bgord/tools 0.17.2 → 1.0.0

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

@@ -0,0 +1,6 @@
+import { z } from "zod/v4";
+export declare const DurationMsError: {
+    readonly Invalid: "duration.invalid";
+};
+export declare const DurationMs: z.core.$ZodBranded<z.ZodNumber, "DurationMs">;
+export type DurationMsType = z.infer<typeof DurationMs>;

package/dist/duration-ms.vo.js

@@ -0,0 +1,3 @@
+import { z } from "zod/v4";
+export const DurationMsError = { Invalid: "duration.invalid" };
+export const DurationMs = z.number(DurationMsError.Invalid).int(DurationMsError.Invalid).brand("DurationMs");

package/dist/duration.service.d.ts

@@ -1,13 +1,7 @@
-import { z } from "zod/v4";
-import { type TimestampType } from "./timestamp.vo";
-export declare const DurationMsError: {
-    readonly error: "duration.invalid";
-};
-export declare const DurationMsSchema: z.core.$ZodBranded<z.ZodNumber, "DurationMs">;
-export type DurationMsType = z.infer<typeof DurationMsSchema>;
+import { type DurationMsType } from "./duration-ms.vo";
 export declare class Duration {
     private static readonly rounding;
-    private readonly valueMs;
+    private readonly internal;
     private static readonly MS_IN_SECOND;
     private static readonly MS_IN_MINUTE;
     private static readonly MS_IN_HOUR;
@@ -29,9 +23,3 @@ export declare class Duration {
     add(another: Duration): Duration;
     subtract(another: Duration): Duration;
 }
-export declare const Time: {
-    Now(now: TimestampType): {
-        Add(duration: Duration): TimestampType;
-        Minus(duration: Duration): TimestampType;
-    };
-};

package/dist/duration.service.js

@@ -1,21 +1,14 @@
-import { z } from "zod/v4";
+import { DurationMs } from "./duration-ms.vo";
 import { RoundToDecimal } from "./rounding.adapter";
-import { Timestamp } from "./timestamp.vo";
-export const DurationMsError = { error: "duration.invalid" };
-export const DurationMsSchema = z
-    .number(DurationMsError)
-    .int(DurationMsError)
-    .refine(Number.isFinite, DurationMsError)
-    .brand("DurationMs");
 export class Duration {
     static rounding = new RoundToDecimal(2);
-    valueMs;
+    internal;
     static MS_IN_SECOND = 1_000;
-    static MS_IN_MINUTE = 60_000;
-    static MS_IN_HOUR = 3_600_000;
-    static MS_IN_DAY = 86_400_000;
+    static MS_IN_MINUTE = 60 * Duration.MS_IN_SECOND;
+    static MS_IN_HOUR = 60 * Duration.MS_IN_MINUTE;
+    static MS_IN_DAY = 24 * Duration.MS_IN_HOUR;
     constructor(candidateMs) {
-        this.valueMs = DurationMsSchema.parse(candidateMs);
+        this.internal = DurationMs.parse(candidateMs);
     }
     static Days(value) {
         return new Duration(value * Duration.MS_IN_DAY);
@@ -33,45 +26,33 @@ export class Duration {
         return new Duration(value);
     }
     get days() {
-        return Duration.rounding.round(this.valueMs / Duration.MS_IN_DAY);
+        return Duration.rounding.round(this.internal / Duration.MS_IN_DAY);
     }
     get hours() {
-        return Duration.rounding.round(this.valueMs / Duration.MS_IN_HOUR);
+        return Duration.rounding.round(this.internal / Duration.MS_IN_HOUR);
     }
     get minutes() {
-        return Duration.rounding.round(this.valueMs / Duration.MS_IN_MINUTE);
+        return Duration.rounding.round(this.internal / Duration.MS_IN_MINUTE);
     }
     get seconds() {
-        return Duration.rounding.round(this.valueMs / Duration.MS_IN_SECOND);
+        return Duration.rounding.round(this.internal / Duration.MS_IN_SECOND);
     }
     get ms() {
-        return this.valueMs;
+        return this.internal;
     }
     isLongerThan(another) {
-        return this.valueMs > another.valueMs;
+        return this.internal > another.internal;
     }
     isShorterThan(another) {
-        return this.valueMs < another.valueMs;
+        return this.internal < another.internal;
     }
     equals(other) {
-        return this.valueMs === other.valueMs;
+        return this.internal === other.internal;
     }
     add(another) {
-        return Duration.Ms(this.valueMs + another.valueMs);
+        return Duration.Ms(this.internal + another.internal);
     }
     subtract(another) {
-        return Duration.Ms(this.valueMs - another.valueMs);
+        return Duration.Ms(this.internal - another.internal);
     }
 }
-export const Time = {
-    Now(now) {
-        return {
-            Add(duration) {
-                return Timestamp.parse(now + duration.ms);
-            },
-            Minus(duration) {
-                return Timestamp.parse(now - duration.ms);
-            },
-        };
-    },
-};

package/dist/email-mask.service.d.ts

@@ -1,8 +1,3 @@
-import { z } from "zod/v4";
-export declare const Email: z.core.$ZodBranded<z.ZodEmail, "Email">;
-export type EmailType = z.infer<typeof Email>;
-type EmailMaskedType = string;
 export declare class EmailMask {
-    static censor(email: EmailType): EmailMaskedType;
+    static censor(email: string): string;
 }
-export {};

package/dist/email-mask.service.js

@@ -1,14 +1,12 @@
-import { z } from "zod/v4";
-export const Email = z.email().brand("Email");
 export class EmailMask {
     static censor(email) {
-        const [beforeAt, afterAt] = email.split("@");
-        const local = beforeAt;
-        const domain = afterAt;
-        if (local.length <= 2) {
+        const [local, domain] = email.split("@");
+        if (local.length <= 2)
             return `${"*".repeat(local.length)}@${domain}`;
-        }
-        const censoredLocal = `${local.at(0)}${"*".repeat(local.length - 2)}${local.at(-1)}`;
+        const firstCharacter = local.at(0);
+        const censoredPart = "*".repeat(local.length - 2);
+        const lastCharacter = local.at(-1);
+        const censoredLocal = `${firstCharacter}${censoredPart}${lastCharacter}`;
         return `${censoredLocal}@${domain}`;
     }
 }

package/dist/etags.vo.d.ts

@@ -1,6 +1,4 @@
-import { z } from "zod/v4";
-declare const RevisionValue: z.ZodNumber;
-type RevisionValueType = z.infer<typeof RevisionValue>;
+import { type RevisionValueType } from "./revision-value.vo";
 type ETagValueType = string;
 export declare class ETag {
     readonly revision: RevisionValueType;
@@ -11,6 +9,9 @@ export declare class ETag {
     static fromHeader(value?: ETagValueType): ETag | null;
 }
 export type WeakETagValueType = string;
+export declare const WeakETagError: {
+    readonly Invalid: "weak.etag.invalid";
+};
 export declare class WeakETag {
     readonly revision: RevisionValueType;
     static HEADER_NAME: string;

package/dist/etags.vo.js

@@ -1,5 +1,4 @@
-import { z } from "zod/v4";
-const RevisionValue = z.number().int().min(0);
+import { RevisionValue } from "./revision-value.vo";
 export class ETag {
     revision;
     static HEADER_NAME = "ETag";
@@ -18,6 +17,7 @@ export class ETag {
         return new ETag(RevisionValue.parse(candidate));
     }
 }
+export const WeakETagError = { Invalid: "weak.etag.invalid" };
 export class WeakETag {
     revision;
     static HEADER_NAME = "ETag";
@@ -29,7 +29,7 @@ export class WeakETag {
     }
     static fromHeader(value) {
         if (!value?.startsWith("W/"))
-            throw Error("Invalid WeakETag");
+            throw new Error(WeakETagError.Invalid);
         const candidate = Number(value.split("W/")[1]);
         if (Number.isNaN(candidate))
             return null;

package/dist/extension.vo.d.ts

@@ -1,7 +1,9 @@
 import { z } from "zod/v4";
-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 ExtensionError: {
+    readonly Type: "extension.type";
+    readonly Empty: "extension.empty";
+    readonly TooLong: "extension.too.long";
+    readonly BadChars: "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,14 +1,19 @@
 import { z } from "zod/v4";
-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 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 = z
-    .string(ExtensionTypeError)
-    .trim()
+    .string(ExtensionError.Type)
     .toLowerCase()
-    .transform((value) => (value.startsWith(".") ? value.slice(1) : value))
-    .refine((value) => value.length >= 1, ExtensionEmptyError)
-    .refine((value) => value.length <= 16, ExtensionTooLongError)
-    .refine((value) => /^[a-z0-9]+$/.test(value), ExtensionBadCharsError)
+    .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");

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

@@ -0,0 +1,10 @@
+import { z } from "zod/v4";
+export declare const FeatureFlagValueError: {
+    readonly Invalid: "feature.flag.value.invalid";
+};
+export declare enum FeatureFlagEnum {
+    yes = "yes",
+    no = "no"
+}
+export declare const FeatureFlagValue: z.ZodEnum<typeof FeatureFlagEnum>;
+export type FeatureFlagValueType = z.infer<typeof FeatureFlagValue>;

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

@@ -0,0 +1,8 @@
+import { z } from "zod/v4";
+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);

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

@@ -1,10 +1,4 @@
-import { z } from "zod/v4";
-export declare enum FeatureFlagEnum {
-    yes = "yes",
-    no = "no"
-}
-export declare const FeatureFlagValue: z.ZodEnum<typeof FeatureFlagEnum>;
-export type FeatureFlagValueType = z.infer<typeof FeatureFlagValue>;
+import { type FeatureFlagValueType } from "./feature-flag-value.vo";
 export declare class FeatureFlag {
     static isEnabled(flag: FeatureFlagValueType): boolean;
     static isDisabled(flag: FeatureFlagValueType): boolean;

package/dist/feature-flag.vo.js

@@ -1,10 +1,4 @@
-import { z } from "zod/v4";
-export var FeatureFlagEnum;
-(function (FeatureFlagEnum) {
-    FeatureFlagEnum["yes"] = "yes";
-    FeatureFlagEnum["no"] = "no";
-})(FeatureFlagEnum || (FeatureFlagEnum = {}));
-export const FeatureFlagValue = z.enum(FeatureFlagEnum);
+import { FeatureFlagEnum } from "./feature-flag-value.vo";
 export class FeatureFlag {
     static isEnabled(flag) {
         return flag === FeatureFlagEnum.yes;

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

@@ -1,11 +1,14 @@
 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">;
+export declare const FilePathAbsoluteSchemaError: {
+    readonly Type: "file.path.absolute.type";
+    readonly LeadingSlash: "file.path.absolute.leading.slash";
+    readonly TrailingSlash: "file.path.absolute.trailing.slash";
+    readonly BackslashForbidden: "file.path.absolute.backslash.forbidden";
+    readonly Empty: "file.path.absolute.empty";
+};
+export declare const FilePathAbsoluteSchema: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<{
+    directory: string & z.core.$brand<"DirectoryPathAbsoluteSchema">;
     filename: Filename;
-}, string>>;
+}, string>>, "FilePathAbsoluteSchema">;
 export type FilePathAbsoluteType = z.infer<typeof FilePathAbsoluteSchema>;

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

@@ -1,25 +1,25 @@
 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 FilePathAbsoluteSchemaError = {
+    Type: "file.path.absolute.type",
+    LeadingSlash: "file.path.absolute.leading.slash",
+    TrailingSlash: "file.path.absolute.trailing.slash",
+    BackslashForbidden: "file.path.absolute.backslash.forbidden",
+    Empty: "file.path.absolute.empty",
+};
 export const FilePathAbsoluteSchema = z
-    .string(AbsFilePathTypeError)
-    .trim()
-    .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)
+    .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) => {
-    const lastSlashIndex = normalized.lastIndexOf("/");
-    const directoryCandidate = lastSlashIndex === 0 ? "/" : normalized.slice(0, lastSlashIndex);
-    const filenameCandidate = normalized.slice(lastSlashIndex + 1);
+    const index = normalized.lastIndexOf("/");
+    const directoryCandidate = index === 0 ? "/" : normalized.slice(0, index);
+    const filenameCandidate = normalized.slice(index + 1);
     const directory = DirectoryPathAbsoluteSchema.parse(directoryCandidate);
     const filename = Filename.fromString(filenameCandidate);
     return { directory, filename };
-});
+})
+    .brand("FilePathAbsoluteSchema");

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

@@ -1,11 +1,14 @@
 import { z } from "zod/v4";
 import { Filename } from "./filename.vo";
-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">;
+export declare const FilePathRelativeSchemaError: {
+    readonly Type: "file.path.relative.type";
+    readonly LeadingSlash: "file.path.relative.leading.slash";
+    readonly BackslashForbidden: "file.path.relative.backslash.forbidden";
+    readonly RequiresDirectory: "file.path.relative.requires.directory";
+    readonly Empty: "file.path.relative.empty";
+};
+export declare const FilePathRelativeSchema: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<{
+    directory: string & z.core.$brand<"DirectoryPathRelativeSchema">;
     filename: Filename;
-}, string>>;
+}, string>>, "FilePathRelativeSchema">;
 export type FilePathRelativeType = z.infer<typeof FilePathRelativeSchema>;

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

@@ -1,18 +1,19 @@
 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 FilePathRelativeSchemaError = {
+    Type: "file.path.relative.type",
+    LeadingSlash: "file.path.relative.leading.slash",
+    BackslashForbidden: "file.path.relative.backslash.forbidden",
+    RequiresDirectory: "file.path.relative.requires.directory",
+    Empty: "file.path.relative.empty",
+};
 export const FilePathRelativeSchema = z
-    .string(RelFilePathTypeError)
-    .trim()
-    .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)
+    .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) => {
     const lastSlashIndex = normalized.lastIndexOf("/");
     const directoryCandidate = normalized.slice(0, lastSlashIndex);
@@ -20,4 +21,5 @@ export const FilePathRelativeSchema = z
     const directory = DirectoryPathRelativeSchema.parse(directoryCandidate);
     const filename = Filename.fromString(filenameCandidate);
     return { directory, filename };
-});
+})
+    .brand("FilePathRelativeSchema");

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

@@ -7,11 +7,11 @@ export declare class FilePathRelative {
     private constructor();
     static fromParts(directoryCandidate: string, filename: Filename): FilePathRelative;
     static fromPartsSafe(directory: DirectoryPathRelativeType, filename: Filename): FilePathRelative;
-    static fromString(pathCandidate: string): FilePathRelative;
+    static fromString(candidate: string): FilePathRelative;
     get(): string;
     getDirectory(): DirectoryPathRelativeType;
     getFilename(): Filename;
-    withDirectoryRelative(newDirectory: DirectoryPathRelativeType): FilePathRelative;
+    withDirectory(newDirectory: DirectoryPathRelativeType): FilePathRelative;
     withFilename(newFilename: Filename): FilePathRelative;
     toAbsolute(newDirectory: DirectoryPathAbsoluteType): FilePathAbsolute;
 }
@@ -21,11 +21,11 @@ export declare class FilePathAbsolute {
     private constructor();
     static fromParts(directoryCandidate: string, filename: Filename): FilePathAbsolute;
     static fromPartsSafe(directory: DirectoryPathAbsoluteType, filename: Filename): FilePathAbsolute;
-    static fromString(pathCandidate: string): FilePathAbsolute;
+    static fromString(candidate: string): FilePathAbsolute;
     get(): string;
     getDirectory(): DirectoryPathAbsoluteType;
     getFilename(): Filename;
-    withDirectoryAbsolute(newDirectory: DirectoryPathAbsoluteType): FilePathAbsolute;
+    withDirectory(newDirectory: DirectoryPathAbsoluteType): FilePathAbsolute;
     withFilename(newFilename: Filename): FilePathAbsolute;
     toRelative(newDirectory: DirectoryPathRelativeType): FilePathRelative;
 }

package/dist/file-path.vo.js

@@ -16,9 +16,9 @@ export class FilePathRelative {
     static fromPartsSafe(directory, filename) {
         return new FilePathRelative(directory, filename);
     }
-    static fromString(pathCandidate) {
-        const parsed = FilePathRelativeSchema.parse(pathCandidate);
-        return new FilePathRelative(parsed.directory, parsed.filename);
+    static fromString(candidate) {
+        const schema = FilePathRelativeSchema.parse(candidate);
+        return new FilePathRelative(schema.directory, schema.filename);
     }
     get() {
         return `${this.directory}/${this.filename.get()}`;
@@ -29,7 +29,7 @@ export class FilePathRelative {
     getFilename() {
         return this.filename;
     }
-    withDirectoryRelative(newDirectory) {
+    withDirectory(newDirectory) {
         return new FilePathRelative(newDirectory, this.filename);
     }
     withFilename(newFilename) {
@@ -53,9 +53,9 @@ export class FilePathAbsolute {
     static fromPartsSafe(directory, filename) {
         return new FilePathAbsolute(directory, filename);
     }
-    static fromString(pathCandidate) {
-        const parsed = FilePathAbsoluteSchema.parse(pathCandidate);
-        return new FilePathAbsolute(parsed.directory, parsed.filename);
+    static fromString(candidate) {
+        const schema = FilePathAbsoluteSchema.parse(candidate);
+        return new FilePathAbsolute(schema.directory, schema.filename);
     }
     get() {
         if (this.directory === "/")
@@ -68,7 +68,7 @@ export class FilePathAbsolute {
     getFilename() {
         return this.filename;
     }
-    withDirectoryAbsolute(newDirectory) {
+    withDirectory(newDirectory) {
         return new FilePathAbsolute(newDirectory, this.filename);
     }
     withFilename(newFilename) {

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

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

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

@@ -1,15 +1,17 @@
 import { z } from "zod/v4";
 import { Basename } from "./basename.vo";
 import { Extension } from "./extension.vo";
-export const FilenameTypeError = "filename.not.string";
-export const FilenameInvalidError = "filename.invalid";
+export const FilenameFromStringError = {
+    Type: "filename.from.string.type",
+    Invalid: "filename.from.string.Invalid",
+};
+// .+ at least one character, advances to the last dot
+// .
+// .+ at least one character
+const DOT_WITH_SIDES = /^.+\..+$/;
 export const FilenameFromString = z
-    .string(FilenameTypeError)
-    .trim()
-    .refine((value) => {
-    const index = value.lastIndexOf(".");
-    return index > 0 && index < value.length - 1;
-}, FilenameInvalidError)
+    .string(FilenameFromStringError.Type)
+    .regex(DOT_WITH_SIDES, FilenameFromStringError.Invalid)
     .transform((value) => {
     const index = value.lastIndexOf(".");
     const basename = Basename.parse(value.slice(0, index));

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

@@ -1,5 +1,9 @@
 import { z } from "zod/v4";
-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 declare const FilenameSuffixError: {
+    readonly Type: "suffix.type";
+    readonly Empty: "suffix.empty";
+    readonly TooLong: "suffix.too.long";
+    readonly BadChars: "suffix.bad.chars";
+};
+export declare const FilenameSuffix: z.core.$ZodBranded<z.ZodString, "FilenameSuffix">;
 export type FilenameSuffixType = z.infer<typeof FilenameSuffix>;

package/dist/filename-suffix.vo.js

@@ -1,9 +1,15 @@
 import { z } from "zod/v4";
-export const FilenameSuffixTypeError = "suffix.not.string";
-export const FilenameSuffixTooLongError = "suffix_too_long";
+export const FilenameSuffixError = {
+    Type: "suffix.type",
+    Empty: "suffix.empty",
+    TooLong: "suffix.too.long",
+    BadChars: "suffix.bad.chars",
+};
+// Letters, digits, underscores, and hyphens allowed
+const FILENAME_SUFFIX_WHITELIST = /^[a-zA-Z0-9_-]+$/;
 export const FilenameSuffix = z
-    .string(FilenameSuffixTypeError)
-    .trim()
-    .transform((value) => value.replace(/[^A-Za-z0-9_-]/g, ""))
-    .refine((value) => value.length <= 32, FilenameSuffixTooLongError)
-    .brand("basename_suffix");
+    .string(FilenameSuffixError.Type)
+    .min(1, FilenameSuffixError.Empty)
+    .max(32, FilenameSuffixError.TooLong)
+    .regex(FILENAME_SUFFIX_WHITELIST, FilenameSuffixError.BadChars)
+    .brand("FilenameSuffix");

package/dist/filename.vo.d.ts

@@ -15,4 +15,6 @@ export declare class Filename {
     withBasename(basename: BasenameType): Filename;
     withSuffix(candidate: string): Filename;
     withSuffixSafe(suffix: FilenameSuffixType): Filename;
+    toString(): string;
+    toJSON(): string;
 }

package/dist/filename.vo.js

@@ -16,8 +16,8 @@ export class Filename {
         return new Filename(basename, extension);
     }
     static fromString(candidate) {
-        const { basename, extension } = FilenameFromString.parse(candidate);
-        return new Filename(basename, extension);
+        const filename = FilenameFromString.parse(candidate);
+        return new Filename(filename.basename, filename.extension);
     }
     get() {
         return `${this.basename}.${this.extension}`;
@@ -43,4 +43,10 @@ export class Filename {
         const basename = Basename.parse(`${this.basename}${suffix}`);
         return new Filename(basename, this.extension);
     }
+    toString() {
+        return this.get();
+    }
+    toJSON() {
+        return this.get();
+    }
 }

package/dist/height-milimiters.vo.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod/v4";
+export declare const HeightMillimetersError: {
+    readonly Type: "height.millimeters.type";
+    readonly Invalid: "height.millimeters.invalid";
+};
+export declare const HeightMillimeters: z.core.$ZodBranded<z.ZodNumber, "HeightMillimeters">;

package/dist/height-milimiters.vo.js

@@ -0,0 +1,10 @@
+import { z } from "zod/v4";
+export const HeightMillimetersError = {
+    Type: "height.millimeters.type",
+    Invalid: "height.millimeters.invalid",
+};
+export const HeightMillimeters = z
+    .number(HeightMillimetersError.Type)
+    .int(HeightMillimetersError.Type)
+    .min(0, HeightMillimetersError.Invalid)
+    .brand("HeightMillimeters");