@bgord/tools 0.15.2 → 0.16.0

package/src/file-path-absolute-schema.vo.ts

@@ -2,14 +2,21 @@ 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" as const;
+export const AbsFilePathMustStartWithSlashError = "abs_file_path_must_start_with_slash" as const;
+export const AbsFilePathBackslashForbiddenError = "abs_file_path_backslash_forbidden" as const;
+export const AbsFilePathMissingFilenameError = "abs_file_path_missing_filename" as const;
+
 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);
@@ -20,3 +27,5 @@ export const FilePathAbsoluteSchema = z
 
     return { directory, filename };
   });
+
+export type FilePathAbsoluteType = z.infer<typeof FilePathAbsoluteSchema>;

package/src/file-path-relative-schema.vo.ts

@@ -2,14 +2,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" as const;
+export const RelFilePathMustNotStartWithSlashError = "rel_file_path_must_not_start_with_slash" as const;
+export const RelFilePathBackslashForbiddenError = "rel_file_path_backslash_forbidden" as const;
+export const RelFilePathRequiresDirectoryError = "rel_file_path_requires_directory" as const;
+
 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);
@@ -20,3 +25,5 @@ export const FilePathRelativeSchema = z
 
     return { directory, filename };
   });
+
+export type FilePathRelativeType = z.infer<typeof FilePathRelativeSchema>;

package/src/file-path.vo.ts

@@ -10,21 +10,23 @@ export class FilePathRelative {
     private readonly filename: Filename,
   ) {}
 
-  static fromParts(directoryCandidate: string, filename: Filename) {
+  static fromParts(directoryCandidate: string, filename: Filename): FilePathRelative {
     const directory = DirectoryPathRelativeSchema.parse(directoryCandidate);
+
     return new FilePathRelative(directory, filename);
   }
 
-  static fromPartsSafe(directory: DirectoryPathRelativeType, filename: Filename) {
+  static fromPartsSafe(directory: DirectoryPathRelativeType, filename: Filename): FilePathRelative {
     return new FilePathRelative(directory, filename);
   }
 
   static fromString(pathCandidate: string): FilePathRelative {
-    const { directory, filename } = FilePathRelativeSchema.parse(pathCandidate);
-    return new FilePathRelative(directory, filename);
+    const parsed = FilePathRelativeSchema.parse(pathCandidate);
+
+    return new FilePathRelative(parsed.directory, parsed.filename);
   }
 
-  get() {
+  get(): string {
     return `${this.directory}/${this.filename.get()}`;
   }
 
@@ -55,22 +57,24 @@ export class FilePathAbsolute {
     private readonly filename: Filename,
   ) {}
 
-  static fromParts(directoryCandidate: string, filename: Filename) {
+  static fromParts(directoryCandidate: string, filename: Filename): FilePathAbsolute {
     const directory = DirectoryPathAbsoluteSchema.parse(directoryCandidate);
+
     return new FilePathAbsolute(directory, filename);
   }
 
-  static fromPartsSafe(directory: DirectoryPathAbsoluteType, filename: Filename) {
+  static fromPartsSafe(directory: DirectoryPathAbsoluteType, filename: Filename): FilePathAbsolute {
     return new FilePathAbsolute(directory, filename);
   }
 
   static fromString(pathCandidate: string): FilePathAbsolute {
-    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 === ("/" as DirectoryPathAbsoluteType)) return `/${this.filename.get()}`;
+  get(): string {
+    if (this.directory === "/") return `/${this.filename.get()}`;
     return `${this.directory}/${this.filename.get()}`;
   }
 

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

@@ -1,19 +1,24 @@
 import { z } from "zod/v4";
-import { BasenameSchema } from "./basename.vo";
-import { ExtensionSchema } from "./extension.vo";
+import { Basename } from "./basename.vo";
+import { Extension } from "./extension.vo";
 
-export const FilenameFromStringSchema = z
-  .string()
+export const FilenameTypeError = "filename.not.string" as const;
+export const FilenameInvalidError = "filename.invalid" as const;
+
+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 };
   });
-export type FilenameFromString = z.infer<typeof FilenameFromStringSchema>;
+
+export type FilenameFromStringType = z.infer<typeof FilenameFromString>;

package/src/filename-suffix.vo.ts

@@ -1,9 +1,13 @@
 import { z } from "zod/v4";
 
-export const FilenameSuffixSchema = z
-  .string()
+export const FilenameSuffixTypeError = "suffix.not.string" as const;
+export const FilenameSuffixTooLongError = "suffix_too_long" as const;
+
+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");
-export type FilenameSuffixSchemaType = z.infer<typeof FilenameSuffixSchema>;
+
+export type FilenameSuffixType = z.infer<typeof FilenameSuffix>;

package/src/filename.vo.ts

@@ -1,7 +1,7 @@
-import { BasenameSchema, type BasenameType } from "./basename.vo";
-import { ExtensionSchema, type ExtensionType } from "./extension.vo";
-import { FilenameFromStringSchema } from "./filename-from-string.vo";
-import { FilenameSuffixSchema, type FilenameSuffixSchemaType } from "./filename-suffix.vo";
+import { Basename, type BasenameType } from "./basename.vo";
+import { Extension, type ExtensionType } from "./extension.vo";
+import { FilenameFromString } from "./filename-from-string.vo";
+import { FilenameSuffix, type FilenameSuffixType } from "./filename-suffix.vo";
 
 export class Filename {
   private constructor(
@@ -9,21 +9,20 @@ export class Filename {
     private readonly extension: ExtensionType,
   ) {}
 
-  static fromParts(basename: string, extension: string) {
-    return new Filename(BasenameSchema.parse(basename), ExtensionSchema.parse(extension));
+  static fromParts(basename: string, extension: string): Filename {
+    return new Filename(Basename.parse(basename), Extension.parse(extension));
   }
 
-  static fromPartsSafe(basename: BasenameType, extension: ExtensionType) {
+  static fromPartsSafe(basename: BasenameType, extension: ExtensionType): Filename {
     return new Filename(basename, extension);
   }
 
-  static fromString(candidate: string) {
-    const { basename, extension } = FilenameFromStringSchema.parse(candidate);
-
+  static fromString(candidate: string): Filename {
+    const { basename, extension } = FilenameFromString.parse(candidate);
     return new Filename(basename, extension);
   }
 
-  get() {
+  get(): string {
     return `${this.basename}.${this.extension}`;
   }
 
@@ -44,14 +43,14 @@ export class Filename {
   }
 
   withSuffix(candidate: string): Filename {
-    const suffix = FilenameSuffixSchema.parse(candidate);
-    const basename = BasenameSchema.parse(`${this.basename}${suffix}`);
+    const suffix = FilenameSuffix.parse(candidate);
+    const basename = Basename.parse(`${this.basename}${suffix}`);
 
     return new Filename(basename, this.extension);
   }
 
-  withSuffixSafe(suffix: FilenameSuffixSchemaType): Filename {
-    const basename = BasenameSchema.parse(`${this.basename}${suffix}`);
+  withSuffixSafe(suffix: FilenameSuffixType): Filename {
+    const basename = Basename.parse(`${this.basename}${suffix}`);
 
     return new Filename(basename, this.extension);
   }

package/src/height.vo.ts

@@ -2,14 +2,24 @@ import { z } from "zod/v4";
 import { RoundToDecimal, RoundToNearest } from "./rounding.adapter";
 import type { RoundingPort } from "./rounding.port";
 
-const FiniteNumericValue = z.number().refine(Number.isFinite, { message: "Expected a finite number" });
-const NonNegativeNumericValue = FiniteNumericValue.min(0, { message: "Must be greater than or equal to 0" });
-const NonNegativeIntegerMillimeters = FiniteNumericValue.int().min(0, {
-  message: "Millimeters must be an integer greater than or equal to 0",
-});
-const NonNegativeIntegerValue = FiniteNumericValue.int().min(0, {
-  message: "Value must be an integer greater than or equal to 0",
-});
+const NonFiniteNumberError = { error: "number.non_finite" } as const;
+const NumberNegativeError = { error: "number.negative" } as const;
+const MillimetersIntegerNonNegativeError = { error: "millimeters.integer_non_negative" } as const;
+const IntegerNonNegativeError = { error: "integer.non_negative" } as const;
+
+const HeightFiniteNumber = z.number(NonFiniteNumberError).refine(Number.isFinite, NonFiniteNumberError);
+
+const HeightNonNegativeQuantity = HeightFiniteNumber.min(0, NumberNegativeError);
+
+const HeightCanonicalMillimeters = HeightFiniteNumber.int(MillimetersIntegerNonNegativeError).min(
+  0,
+  MillimetersIntegerNonNegativeError,
+);
+
+const HeightRoundedWholeInches = HeightFiniteNumber.int(IntegerNonNegativeError).min(
+  0,
+  IntegerNonNegativeError,
+);
 
 export enum HeightUnit {
   cm = "cm",
@@ -24,88 +34,96 @@ export class Height {
   private constructor(private readonly millimeters: number) {}
 
   static fromCentimeters(centimeters: number, rounding: RoundingPort = new RoundToNearest()): Height {
-    NonNegativeNumericValue.parse(centimeters);
-    const mmFloat = centimeters * Height.MILLIMETERS_PER_CENTIMETER;
-    const mmRounded = rounding.round(mmFloat);
-    NonNegativeIntegerMillimeters.parse(mmRounded);
-    return new Height(mmRounded);
+    const validatedCentimeters = HeightNonNegativeQuantity.parse(centimeters);
+    const millimetersFloat = validatedCentimeters * Height.MILLIMETERS_PER_CENTIMETER;
+    const millimetersRounded = rounding.round(millimetersFloat);
+    const validatedMillimeters = HeightCanonicalMillimeters.parse(millimetersRounded);
+
+    return new Height(validatedMillimeters);
   }
 
   static fromFeetInches(feet: number, inches = 0, rounding: RoundingPort = new RoundToNearest()): Height {
-    NonNegativeNumericValue.parse(feet);
-    NonNegativeNumericValue.parse(inches);
-    const totalInches = feet * Height.INCHES_PER_FOOT + inches;
-    const mmFloat = totalInches * Height.MILLIMETERS_PER_INCH;
-    const mmRounded = rounding.round(mmFloat);
-    NonNegativeIntegerMillimeters.parse(mmRounded);
-    return new Height(mmRounded);
+    const validatedFeet = HeightNonNegativeQuantity.parse(feet);
+    const validatedInches = HeightNonNegativeQuantity.parse(inches);
+    const totalInches = validatedFeet * Height.INCHES_PER_FOOT + validatedInches;
+    const millimetersFloat = totalInches * Height.MILLIMETERS_PER_INCH;
+    const millimetersRounded = rounding.round(millimetersFloat);
+    const validatedMillimeters = HeightCanonicalMillimeters.parse(millimetersRounded);
+
+    return new Height(validatedMillimeters);
   }
 
   static fromMillimeters(millimeters: number, rounding: RoundingPort = new RoundToNearest()): Height {
-    NonNegativeNumericValue.parse(millimeters);
-    const mmRounded = rounding.round(millimeters);
-    NonNegativeIntegerMillimeters.parse(mmRounded);
-    return new Height(mmRounded);
+    const validatedMillimetersInput = HeightNonNegativeQuantity.parse(millimeters);
+    const millimetersRounded = rounding.round(validatedMillimetersInput);
+    const validatedMillimeters = HeightCanonicalMillimeters.parse(millimetersRounded);
+
+    return new Height(validatedMillimeters);
   }
 
   static zero(): Height {
     return new Height(0);
   }
 
+  get(): number {
+    return this.millimeters;
+  }
+
   toMillimeters(): number {
     return this.millimeters;
   }
 
   toCentimeters(rounding?: RoundingPort): number {
-    const cm = this.millimeters / Height.MILLIMETERS_PER_CENTIMETER;
-    return rounding ? rounding.round(cm) : cm;
+    const centimeters = this.millimeters / Height.MILLIMETERS_PER_CENTIMETER;
+
+    if (rounding) return rounding.round(centimeters);
+    return centimeters;
   }
 
-  toFeetInches(rounding: RoundingPort = new RoundToNearest()): {
-    feet: number;
-    inches: number;
-  } {
+  toFeetInches(rounding: RoundingPort = new RoundToNearest()): { feet: number; inches: number } {
     const totalInchesFloat = this.millimeters / Height.MILLIMETERS_PER_INCH;
     const totalInchesRounded = rounding.round(totalInchesFloat);
-    const integerInches = NonNegativeIntegerValue.parse(totalInchesRounded);
+    const totalWholeInches = HeightRoundedWholeInches.parse(totalInchesRounded);
 
-    const feet = (integerInches - (integerInches % Height.INCHES_PER_FOOT)) / Height.INCHES_PER_FOOT;
-    const inches = integerInches % Height.INCHES_PER_FOOT;
+    const feet = Math.floor(totalWholeInches / Height.INCHES_PER_FOOT);
+    const inches = totalWholeInches % Height.INCHES_PER_FOOT;
 
     return { feet, inches };
   }
 
   format(unit: HeightUnit, rounding?: RoundingPort): string {
-    return {
-      [HeightUnit.cm]: () => {
-        const chosen = rounding ?? new RoundToDecimal(1);
+    if (unit === HeightUnit.cm) {
+      const chosen = rounding ?? new RoundToDecimal(1);
+      const value = this.toCentimeters(chosen);
 
-        return `${this.toCentimeters(chosen)} cm`;
-      },
-      [HeightUnit.ft_in]: () => {
-        const chosen = rounding ?? new RoundToNearest();
-        const { feet, inches } = this.toFeetInches(chosen);
+      return `${value} cm`;
+    }
+
+    const chosen = rounding ?? new RoundToNearest();
+    const parts = this.toFeetInches(chosen);
+
+    return `${parts.feet}′${parts.inches}″`;
+  }
 
-        return `${feet}′${inches}″`;
-      },
-    }[unit]();
+  toString(): string {
+    return this.format(HeightUnit.cm, new RoundToDecimal(1));
   }
 
-  equals(other: Height): boolean {
-    return this.millimeters === other.millimeters;
+  equals(another: Height): boolean {
+    return this.millimeters === another.millimeters;
   }
 
-  compare(other: Height): -1 | 0 | 1 {
-    if (this.equals(other)) return 0;
-    return this.millimeters < other.millimeters ? -1 : 1;
+  compare(another: Height): -1 | 0 | 1 {
+    if (this.equals(another)) return 0;
+    return this.millimeters < another.millimeters ? -1 : 1;
   }
 
-  greaterThan(other: Height): boolean {
-    return this.millimeters > other.millimeters;
+  greaterThan(another: Height): boolean {
+    return this.millimeters > another.millimeters;
   }
 
-  lessThan(other: Height): boolean {
-    return this.millimeters < other.millimeters;
+  lessThan(another: Height): boolean {
+    return this.millimeters < another.millimeters;
   }
 
   isZero(): boolean {

package/src/index.ts

@@ -53,7 +53,6 @@ export * from "./rounding.adapter";
 export * from "./rounding.port";
 export * from "./simple-linear-regression.service";
 export * from "./size.vo";
-export * from "./stepper.service";
 export * from "./stopwatch.service";
 export * from "./streak-calculator.service";
 export * from "./sum.service";

package/src/mime.vo.ts

@@ -1,10 +1,13 @@
 import * as mime from "mime-types";
-import { ExtensionSchema, type ExtensionType } from "./extension.vo";
+import { Extension, type ExtensionType } from "./extension.vo";
 
 export type MimeRawType = string;
 type MimeTypeType = string;
 type MimeSubtypeType = string;
 
+export const InvalidMimeErrorMessage = "invalid.mime" as const;
+export const NotAcceptedMimeErrorMessage = "mime.not.accepted" as const;
+
 export class Mime {
   readonly raw: MimeRawType;
   readonly type: MimeTypeType;
@@ -29,29 +32,29 @@ export class Mime {
     if (this.raw === another.raw) return true;
 
     const typeMatches = this.type === another.type || this.type === "*";
-    if (!typeMatches) return false;
 
+    if (!typeMatches) return false;
     return this.subtype === another.subtype || this.subtype === "*";
   }
 
   toExtension(): ExtensionType {
-    return ExtensionSchema.parse(mime.extension(this.raw));
+    return Extension.parse(mime.extension(this.raw));
   }
 }
 
 export class InvalidMimeError extends Error {
   constructor() {
-    super();
+    super(InvalidMimeErrorMessage);
     Object.setPrototypeOf(this, InvalidMimeError.prototype);
   }
 }
 
 export class NotAcceptedMimeError extends Error {
   mime: MimeRawType;
-  constructor(mime: MimeRawType) {
-    super();
+  constructor(mimeValue: MimeRawType) {
+    super(NotAcceptedMimeErrorMessage);
     Object.setPrototypeOf(this, NotAcceptedMimeError.prototype);
-    this.mime = mime;
+    this.mime = mimeValue;
   }
 }
 

package/src/month-iso-id.vo.ts

@@ -1,25 +1,15 @@
 import { z } from "zod/v4";
 
-export const MonthIsoId = z
-  .string()
-  .regex(/^\d{4}-\d{2}$/)
-  .refine(
-    (value) => {
-      const [y, m] = value.split("-");
-
-      const year = Number(y);
-      const month = Number(m);
+export const MonthIsoIdError = { error: "month-iso-id.invalid" } as const;
 
-      return (
-        y.length === 4 &&
-        m.length === 2 &&
-        Number.isInteger(year) &&
-        Number.isInteger(month) &&
-        month >= 1 &&
-        month <= 12
-      );
-    },
-    { message: "month-iso-id.invalid" },
-  );
+export const MonthIsoId = z
+  .string(MonthIsoIdError)
+  .regex(/^\d{4}-\d{2}$/, MonthIsoIdError)
+  .refine((value) => {
+    const year = Number(value.slice(0, 4));
+    const month = Number(value.slice(5, 7));
+
+    return Number.isInteger(year) && Number.isInteger(month) && month >= 1 && month <= 12;
+  }, MonthIsoIdError);
 
 export type MonthIsoIdType = z.infer<typeof MonthIsoId>;

package/src/month.vo.ts

@@ -1,4 +1,4 @@
-import { addMonths, endOfMonth, startOfMonth } from "date-fns";
+// src/month.vo.ts
 import { DateRange } from "./date-range.vo";
 import { MonthIsoId, type MonthIsoIdType } from "./month-iso-id.vo";
 import { Timestamp, type TimestampType } from "./timestamp.vo";
@@ -9,24 +9,24 @@ export class Month extends DateRange {
   }
 
   previous(): Month {
-    const shifted = addMonths(new Date(this.getStart()), -1).getTime();
-    return Month.fromTimestamp(Timestamp.parse(shifted));
+    return Month.fromTimestamp(Timestamp.parse(this.getStart() - 1));
   }
 
   next(): Month {
-    const shifted = addMonths(new Date(this.getStart()), 1).getTime();
-    return Month.fromTimestamp(Timestamp.parse(shifted));
+    return Month.fromTimestamp(Timestamp.parse(this.getEnd() + 1));
   }
 
   shift(count: number): Month {
-    const shifted = addMonths(new Date(this.getStart()), count).getTime();
-    return Month.fromTimestamp(Timestamp.parse(shifted));
+    const date = new Date(this.getStart());
+    date.setUTCMonth(date.getUTCMonth() + count);
+
+    return Month.fromTimestamp(Timestamp.parse(date.getTime()));
   }
 
   static fromTimestamp(timestamp: TimestampType): Month {
-    const start = Timestamp.parse(startOfMonth(timestamp).getTime());
-    const end = Timestamp.parse(endOfMonth(timestamp).getTime());
-    return new Month(start, end);
+    const isoMonth = new Date(timestamp).toISOString().slice(0, 7) as MonthIsoIdType;
+
+    return Month.fromIsoId(isoMonth);
   }
 
   static fromNow(now: TimestampType): Month {
@@ -34,8 +34,14 @@ export class Month extends DateRange {
   }
 
   static fromIsoId(iso: MonthIsoIdType): Month {
-    const [year, month] = MonthIsoId.parse(iso).split("-").map(Number);
-    const reference = new Date(Date.UTC(year, month - 1, 1));
-    return Month.fromTimestamp(Timestamp.parse(reference.getTime()));
+    const validated = MonthIsoId.parse(iso);
+    const year = Number(validated.slice(0, 4));
+    const monthIndex = Number(validated.slice(5, 7)) - 1;
+
+    const startUtc = Date.UTC(year, monthIndex, 1);
+    const nextStartUtc = Date.UTC(year, monthIndex + 1, 1);
+    const endUtc = nextStartUtc - 1;
+
+    return new Month(Timestamp.parse(startUtc), Timestamp.parse(endUtc));
   }
 }

package/src/object-key.vo.ts

@@ -1,16 +1,30 @@
 import { z } from "zod/v4";
 
+export const ObjectKeyMustNotStartWithSlashError = "obj_key_must_not_start_with_slash" as const;
+export const ObjectKeyBackslashForbiddenError = "obj_key_backslash_forbidden" as const;
+export const ObjectKeyControlCharsForbiddenError = "obj_key_control_chars_forbidden" as const;
+export const ObjectKeyEmptyError = "obj_key_empty" as const;
+export const ObjectKeyBadSegmentsError = "obj_key_bad_segments" as const;
+
+// biome-ignore lint: lint/suspicious/noControlCharactersInRegex
+const CONTROL_CHARS_REGEX = /[\u0000-\u001F\u007F]/;
+const SEGMENT_ALLOWED_REGEX = /^[a-z0-9._-]+$/;
+
 export const ObjectKey = z
   .string()
   .trim()
-  .refine((v) => !v.startsWith("/"), "obj_key_must_not_start_with_slash")
-  .refine((v) => !v.includes("\\"), "obj_key_backslash_forbidden")
-  // biome-ignore lint: lint/suspicious/noControlCharactersInRegex
-  .refine((v) => !/[\u0000-\u001F\u007F]/.test(v), "obj_key_control_chars_forbidden")
-  .refine((v) => v.length > 0, "obj_key_empty")
+  // fastest early exits first:
+  .refine((value) => value.length > 0, ObjectKeyEmptyError)
+  .refine((value) => !value.startsWith("/"), ObjectKeyMustNotStartWithSlashError)
+  .refine((value) => !value.includes("\\"), ObjectKeyBackslashForbiddenError)
+  .refine((value) => !CONTROL_CHARS_REGEX.test(value), ObjectKeyControlCharsForbiddenError)
   .refine(
-    (v) => v.split("/").every((s) => /^[a-z0-9._-]+$/.test(s) && s !== "." && s !== ".."),
-    "obj_key_bad_segments",
+    (value) =>
+      value
+        .split("/")
+        .every((segment) => SEGMENT_ALLOWED_REGEX.test(segment) && segment !== "." && segment !== ".."),
+    ObjectKeyBadSegmentsError,
   )
   .brand("object_key");
+
 export type ObjectKeyType = z.infer<typeof ObjectKey>;

package/src/outlier-detector.service.ts

@@ -15,6 +15,7 @@ export class OutlierDetector {
 
   isInlier(value: number): boolean {
     const score = this.zScore.calculate(value);
+
     return Math.abs(score) <= this.threshold;
   }
 }