@bgord/tools 0.17.2 → 1.0.1

package/src/age.vo.ts

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

package/src/api-key.vo.ts

@@ -1,12 +1,18 @@
 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",
+} as const;
+
+// 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");
 
 export type ApiKeyType = z.infer<typeof ApiKey>;

package/src/basename.vo.ts

@@ -1,29 +1,31 @@
 import { z } from "zod/v4";
 
-export const BasenameTypeError = "basename.not.string" as const;
-export const BasenameEmptyError = "basename.empty" as const;
-export const BasenameTooLongError = "basename.too.long" as const;
-export const BasenameSlashesForbiddenError = "basename.slashes.forbidden" as const;
-export const BasenameControlCharsForbiddenError = "basename.control.chars.forbidden" as const;
-export const BasenameDotSegmentsForbiddenError = "basename.dot.segments.forbidden" as const;
-export const BasenameDotfilesForbiddenError = "basename.dotfiles.forbidden" as const;
-export const BasenameTrailingDotForbiddenError = "basename.trailing.dot.forbidden" as const;
-export const BasenameBadCharsError = "basename.bad.chars" as const;
+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",
+} as const;
+
+// 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");
 
 export type BasenameType = z.infer<typeof Basename>;

package/src/clock.vo.ts

@@ -1,6 +1,8 @@
 import { type ClockFormatter, ClockFormatters } 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 class Clock {
@@ -11,7 +13,7 @@ export class Clock {
     private readonly minute: Minute,
     formatter?: ClockFormatter,
   ) {
-    this.formatter = (formatter as ClockFormatter) ?? ClockFormatters.TWENTY_FOUR_HOURS;
+    this.formatter = formatter ?? ClockFormatters.TWENTY_FOUR_HOURS;
   }
 
   static fromEpochMs(timestamp: TimestampType, formatter?: ClockFormatter): Clock {
@@ -21,17 +23,12 @@ export class Clock {
     return new Clock(hour, minute, formatter);
   }
 
-  get(): { hour: number; minute: number } {
+  get(): { hour: HourSchemaType; minute: MinuteSchemaType } {
     return { hour: this.hour.get(), minute: this.minute.get() };
   }
 
-  format(formatter?: ClockFormatter): string {
-    const chosen = formatter ?? this.formatter;
-    return chosen(this.hour, this.minute);
-  }
-
-  toString(): string {
-    return this.format();
+  format(): string {
+    return this.formatter(this.hour, this.minute);
   }
 
   equals(another: Clock): boolean {
@@ -39,18 +36,20 @@ export class Clock {
   }
 
   isAfter(another: Clock): boolean {
-    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: Clock): boolean {
-    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(): string {
+    return this.format();
+  }
+
+  toJSON(): { hour: HourSchemaType; minute: MinuteSchemaType } {
+    return this.get();
+  }
 }

package/src/date-calculator.service.ts

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

package/src/date-formatter.service.ts

@@ -1,22 +1,21 @@
 import { format, formatDistanceToNow } from "date-fns";
 
-type FormattedDateType = string;
 type DateFormattersInputType = Parameters<typeof format>[0];
 
 export class DateFormatters {
-  static datetime(date: DateFormattersInputType): FormattedDateType {
+  static datetime(date: DateFormattersInputType): string {
     return format(date, "yyyy/MM/dd HH:mm");
   }
 
-  static date(date: DateFormattersInputType): FormattedDateType {
+  static date(date: DateFormattersInputType): string {
     return format(date, "yyyy/MM/dd");
   }
 
-  static monthDay(date: DateFormattersInputType): FormattedDateType {
+  static monthDay(date: DateFormattersInputType): string {
     return format(date, "MM/dd");
   }
 
-  static relative(date: DateFormattersInputType) {
+  static relative(date: DateFormattersInputType): string {
     return formatDistanceToNow(date, { addSuffix: true });
   }
 }

package/src/date-range.vo.ts

@@ -1,13 +1,13 @@
 import type { TimestampType } from "./timestamp.vo";
 
-export const DateRangeInvalidError = "invalid.date.range" as const;
+export const DateRangeError = { Invalid: "date.range.invalid" } as const;
 
 export class DateRange {
   constructor(
     private readonly start: TimestampType,
     private readonly end: TimestampType,
   ) {
-    if (start > end) throw new Error(DateRangeInvalidError);
+    if (start > end) throw new Error(DateRangeError.Invalid);
   }
 
   getStart(): TimestampType {
@@ -29,4 +29,8 @@ export class DateRange {
   equals(other: DateRange): boolean {
     return this.start === other.start && this.end === other.end;
   }
+
+  toJSON(): { start: number; end: number } {
+    return { start: this.getStart(), end: this.getEnd() };
+  }
 }

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

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

package/src/day.vo.ts

@@ -1,3 +1,4 @@
+import { formatISO } from "date-fns";
 import { DateRange } from "./date-range.vo";
 import { DayIsoId, type DayIsoIdType } from "./day-iso-id.vo";
 import { Duration } from "./duration.service";
@@ -8,32 +9,9 @@ export class Day extends DateRange {
     super(start, end);
   }
 
-  toIsoId(): DayIsoIdType {
-    const midday = this.getStart() + Duration.Hours(12).ms;
-
-    return new Date(midday).toISOString().slice(0, 10) as DayIsoIdType;
-  }
-
-  previous(): Day {
-    const shifted = this.getStart() - Duration.Days(1).ms;
-
-    return Day.fromTimestamp(Timestamp.parse(shifted));
-  }
-
-  next(): Day {
-    const shifted = this.getStart() + Duration.Days(1).ms;
-
-    return Day.fromTimestamp(Timestamp.parse(shifted));
-  }
-
-  shift(count: number): Day {
-    const shifted = this.getStart() + count * Duration.Days(1).ms;
-
-    return Day.fromTimestamp(Timestamp.parse(shifted));
-  }
-
   static fromTimestamp(timestamp: TimestampType): Day {
     const date = new Date(timestamp);
+
     const startUtc = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
     const endUtc = startUtc + Duration.Days(1).ms - 1;
 
@@ -46,9 +24,34 @@ export class Day extends DateRange {
 
   static fromIsoId(isoId: DayIsoIdType): Day {
     const [year, month, day] = DayIsoId.parse(isoId).split("-").map(Number);
+
     const startUtc = Date.UTC(year, month - 1, day);
     const endUtc = startUtc + Duration.Days(1).ms - 1;
 
     return new Day(Timestamp.parse(startUtc), Timestamp.parse(endUtc));
   }
+
+  toIsoId(): DayIsoIdType {
+    const midday = this.getStart() + Duration.Hours(12).ms;
+
+    return DayIsoId.parse(formatISO(midday, { representation: "date" }));
+  }
+
+  previous(): Day {
+    return this.shift(-1);
+  }
+
+  next(): Day {
+    return this.shift(1);
+  }
+
+  shift(count: number): Day {
+    const timestamp = this.getStart() + count * Duration.Days(1).ms;
+
+    return Day.fromTimestamp(Timestamp.parse(timestamp));
+  }
+
+  toString(): string {
+    return this.toIsoId();
+  }
 }

package/src/directory-path-absolute.vo.ts

@@ -1,29 +1,34 @@
 import { z } from "zod/v4";
 
-export const AbsDirTypeError = "abs_dir.not.string" as const;
-export const AbsDirMustStartWithSlashError = "abs_dir_must_start_with_slash" as const;
-export const AbsDirBackslashForbiddenError = "abs_dir_backslash_forbidden" as const;
-export const AbsDirControlCharsForbiddenError = "abs_dir_control_chars_forbidden" as const;
-export const AbsDirBadSegmentsError = "abs_dir_bad_segments" as const;
+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",
+} as const;
+
+// 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 !== "..",
+      (segment) => DIRECTORY_PATH_ABSOLUTE_CHARS.test(segment) && !DOT_SEGMENTS.includes(segment),
     );
-  }, AbsDirBadSegmentsError)
-  .brand("directory_path_absolute");
+  }, DirectoryPathAbsoluteError.BadSegments)
+  .brand("DirectoryPathAbsoluteSchema");
 
 export type DirectoryPathAbsoluteType = z.infer<typeof DirectoryPathAbsoluteSchema>;

package/src/directory-path-relative.vo.ts

@@ -1,29 +1,32 @@
 import { z } from "zod/v4";
 
-export const RelDirTypeError = "rel_dir.not.string" as const;
-export const RelDirMustNotStartWithSlashError = "rel_dir_must_not_start_with_slash" as const;
-export const RelDirBackslashForbiddenError = "rel_dir_backslash_forbidden" as const;
-export const RelDirControlCharsForbiddenError = "rel_dir_control_chars_forbidden" as const;
-export const RelDirEmptyError = "rel_dir_empty" as const;
-export const RelDirBadSegmentsError = "rel_dir_bad_segments" as const;
+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",
+} as const;
+
+// 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,
+        .every((segment) => DIRECTORY_PATH_RELATIVE_CHARS.test(segment) && !DOT_SEGMENTS.includes(segment)),
+    DirectoryPathRelativeError.BadSegments,
   )
-  .brand("directory_path_relative");
+  .brand("DirectoryPathRelativeSchema");
 
 export type DirectoryPathRelativeType = z.infer<typeof DirectoryPathRelativeSchema>;

package/src/division-factor.vo.ts

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

package/src/duration-ms.vo.ts

@@ -0,0 +1,7 @@
+import { z } from "zod/v4";
+
+export const DurationMsError = { Invalid: "duration.invalid" } as const;
+
+export const DurationMs = z.number(DurationMsError.Invalid).int(DurationMsError.Invalid).brand("DurationMs");
+
+export type DurationMsType = z.infer<typeof DurationMs>;

package/src/duration.service.ts

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

package/src/email-mask.service.ts

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