@oneuptime/common 11.3.26 → 11.3.28

package/Tests/Types/OnCallDutyPolicy/LayerUtilTimezone.test.ts

@@ -0,0 +1,243 @@
+import LayerUtil from "../../../Types/OnCallDutyPolicy/Layer";
+import CalendarEvent from "../../../Types/Calendar/CalendarEvent";
+import RestrictionTimes, {
+  RestrictionType,
+  WeeklyResctriction,
+} from "../../../Types/OnCallDutyPolicy/RestrictionTimes";
+import Recurring from "../../../Types/Events/Recurring";
+import User from "../../../Models/DatabaseModels/User";
+import EventInterval from "../../../Types/Events/EventInterval";
+import DayOfWeek from "../../../Types/Day/DayOfWeek";
+import moment from "moment-timezone";
+
+/*
+ * HIGH-5 (timezone) + LOW-2 (DST). These tests construct restriction times and
+ * verify results entirely in an explicit IANA zone via moment.tz, so they hold
+ * regardless of the machine/CI local timezone — which is exactly the bug:
+ * restriction wall-clock must resolve in the SCHEDULE's zone, not the server's.
+ */
+
+function user(id: string): User {
+  return {
+    id: {
+      toString: () => {
+        return id;
+      },
+    } as any,
+  } as User;
+}
+
+function rotation(
+  intervalType: EventInterval,
+  intervalCount: number,
+): Recurring {
+  return Recurring.fromJSON({
+    _type: "Recurring",
+    value: {
+      intervalType: intervalType,
+      intervalCount: { _type: "PositiveNumber", value: intervalCount },
+    },
+  } as any);
+}
+
+// An absolute instant that is `iso` wall-clock in `tz`.
+function tzInstant(iso: string, tz: string): Date {
+  return moment.tz(iso, tz).toDate();
+}
+
+// Wall-clock "HH:mm" of an instant AS SEEN IN `tz`.
+function hhmm(d: Date, tz: string): string {
+  return moment.tz(d, tz).format("HH:mm");
+}
+
+describe("LayerUtil HIGH-5: daily restriction resolves in the schedule timezone", () => {
+  const tz: string = "America/New_York";
+
+  test("09:00-17:00 restriction resolves to 09:00-17:00 in the schedule zone", () => {
+    const util: LayerUtil = new LayerUtil();
+
+    const layerStart: Date = tzInstant("2026-02-16 00:00", tz); // Mon (no DST)
+    const calStart: Date = layerStart;
+    const calEnd: Date = tzInstant("2026-02-19 00:00", tz); // +3 days
+
+    const restrictionTimes: RestrictionTimes = new RestrictionTimes();
+    restrictionTimes.restictionType = RestrictionType.Daily;
+    restrictionTimes.dayRestrictionTimes = {
+      startTime: tzInstant("2026-02-16 09:00", tz),
+      endTime: tzInstant("2026-02-16 17:00", tz),
+    };
+
+    const events: Array<CalendarEvent> = util.getEvents({
+      users: [user("u1")],
+      startDateTimeOfLayer: layerStart,
+      handOffTime: layerStart,
+      restrictionTimes: restrictionTimes,
+      rotation: rotation(EventInterval.Day, 1),
+      timezone: tz,
+      calendarStartDate: calStart,
+      calendarEndDate: calEnd,
+    });
+
+    // One 09:00-17:00 window per day, in New York wall-clock.
+    const windows: Array<CalendarEvent> = events.filter((e: CalendarEvent) => {
+      return hhmm(e.start, tz) === "09:00";
+    });
+    expect(windows.length).toBeGreaterThanOrEqual(3);
+    for (const w of windows) {
+      expect(hhmm(w.start, tz)).toBe("09:00");
+      expect(hhmm(w.end, tz)).toBe("17:00");
+    }
+  });
+
+  test("a schedule authored + resolved in Kolkata resolves to its own wall-clock", () => {
+    const util: LayerUtil = new LayerUtil();
+    const tzIST: string = "Asia/Kolkata"; // UTC+5:30, no DST
+
+    /*
+     * Author and resolve entirely in Kolkata, with the layer start aligned to
+     * local midnight (as a real schedule created in that zone would be).
+     */
+    const layerStart: Date = tzInstant("2026-02-16 00:00", tzIST);
+    const restrictionTimes: RestrictionTimes = new RestrictionTimes();
+    restrictionTimes.restictionType = RestrictionType.Daily;
+    restrictionTimes.dayRestrictionTimes = {
+      startTime: tzInstant("2026-02-16 09:30", tzIST),
+      endTime: tzInstant("2026-02-16 18:30", tzIST),
+    };
+
+    const events: Array<CalendarEvent> = util.getEvents({
+      users: [user("u1")],
+      startDateTimeOfLayer: layerStart,
+      handOffTime: layerStart,
+      restrictionTimes: restrictionTimes,
+      rotation: rotation(EventInterval.Day, 1),
+      timezone: tzIST,
+      calendarStartDate: layerStart,
+      calendarEndDate: tzInstant("2026-02-19 00:00", tzIST),
+    });
+
+    const windows: Array<CalendarEvent> = events.filter((e: CalendarEvent) => {
+      return hhmm(e.start, tzIST) === "09:30";
+    });
+    expect(windows.length).toBeGreaterThanOrEqual(2);
+    for (const w of windows) {
+      expect(hhmm(w.end, tzIST)).toBe("18:30");
+    }
+  });
+});
+
+describe("LayerUtil LOW-2: DST correctness across spring-forward", () => {
+  const tz: string = "America/New_York";
+
+  test("09:00-17:00 restriction stays 09:00-17:00 local across the DST spring-forward day", () => {
+    const util: LayerUtil = new LayerUtil();
+
+    // US spring-forward 2026 is Sun Mar 8. Cover Sat Mar 7 -> Tue Mar 10.
+    const layerStart: Date = tzInstant("2026-03-07 00:00", tz);
+    const restrictionTimes: RestrictionTimes = new RestrictionTimes();
+    restrictionTimes.restictionType = RestrictionType.Daily;
+    restrictionTimes.dayRestrictionTimes = {
+      startTime: tzInstant("2026-03-07 09:00", tz),
+      endTime: tzInstant("2026-03-07 17:00", tz),
+    };
+
+    const events: Array<CalendarEvent> = util.getEvents({
+      users: [user("u1")],
+      startDateTimeOfLayer: layerStart,
+      handOffTime: layerStart,
+      restrictionTimes: restrictionTimes,
+      rotation: rotation(EventInterval.Day, 1),
+      timezone: tz,
+      calendarStartDate: layerStart,
+      calendarEndDate: tzInstant("2026-03-10 00:00", tz),
+    });
+
+    const windows: Array<CalendarEvent> = events.filter((e: CalendarEvent) => {
+      return hhmm(e.start, tz) === "09:00";
+    });
+    // Sat, Sun (DST day), Mon — all keep 09:00-17:00 local despite the lost hour.
+    expect(windows.length).toBeGreaterThanOrEqual(3);
+    for (const w of windows) {
+      expect(hhmm(w.start, tz)).toBe("09:00");
+      expect(hhmm(w.end, tz)).toBe("17:00");
+    }
+  });
+});
+
+describe("LayerUtil HIGH-5: weekly restriction resolves day-of-week in the schedule zone", () => {
+  const tz: string = "America/New_York";
+
+  test("Mon 09:00 -> Wed 17:00 weekly restriction covers Tue midday, not Sat", () => {
+    const util: LayerUtil = new LayerUtil();
+
+    const monday: Date = tzInstant("2026-02-16 00:00", tz); // Monday
+    const weekly: WeeklyResctriction = {
+      startDay: DayOfWeek.Monday,
+      endDay: DayOfWeek.Wednesday,
+      startTime: tzInstant("2026-02-16 09:00", tz), // Monday 09:00 NY
+      endTime: tzInstant("2026-02-18 17:00", tz), // Wednesday 17:00 NY
+    };
+    const restrictionTimes: RestrictionTimes = new RestrictionTimes();
+    restrictionTimes.restictionType = RestrictionType.Weekly;
+    restrictionTimes.weeklyRestrictionTimes = [weekly];
+
+    const events: Array<CalendarEvent> = util.getEvents({
+      users: [user("u1")],
+      startDateTimeOfLayer: monday,
+      handOffTime: tzInstant("2026-02-23 00:00", tz),
+      restrictionTimes: restrictionTimes,
+      rotation: rotation(EventInterval.Week, 1),
+      timezone: tz,
+      calendarStartDate: monday,
+      calendarEndDate: tzInstant("2026-02-23 00:00", tz),
+    });
+
+    const covered: (t: Date) => boolean = (t: Date): boolean => {
+      return events.some((e: CalendarEvent) => {
+        return (
+          t.getTime() >= e.start.getTime() && t.getTime() < e.end.getTime()
+        );
+      });
+    };
+
+    // Tue 12:00 NY is inside Mon 09:00 -> Wed 17:00.
+    expect(covered(tzInstant("2026-02-17 12:00", tz))).toBe(true);
+    // Sat 12:00 NY is not.
+    expect(covered(tzInstant("2026-02-21 12:00", tz))).toBe(false);
+  });
+});
+
+describe("LayerUtil HIGH-5 backward compatibility: no timezone == legacy local behavior", () => {
+  test("omitting timezone yields identical results to before (local reconstruction)", () => {
+    const util: LayerUtil = new LayerUtil();
+    // Author restriction in machine-local time via native Date.
+    const layerStart: Date = new Date(2026, 1, 16, 0, 0, 0); // local midnight
+    const restrictionTimes: RestrictionTimes = new RestrictionTimes();
+    restrictionTimes.restictionType = RestrictionType.Daily;
+    restrictionTimes.dayRestrictionTimes = {
+      startTime: new Date(2026, 1, 16, 9, 0, 0),
+      endTime: new Date(2026, 1, 16, 17, 0, 0),
+    };
+
+    const events: Array<CalendarEvent> = util.getEvents({
+      users: [user("u1")],
+      startDateTimeOfLayer: layerStart,
+      handOffTime: layerStart,
+      restrictionTimes: restrictionTimes,
+      rotation: rotation(EventInterval.Day, 1),
+      // timezone intentionally omitted
+      calendarStartDate: layerStart,
+      calendarEndDate: new Date(2026, 1, 19, 0, 0, 0),
+    });
+
+    const windows: Array<CalendarEvent> = events.filter((e: CalendarEvent) => {
+      return e.start.getHours() === 9;
+    });
+    expect(windows.length).toBeGreaterThanOrEqual(2);
+    for (const w of windows) {
+      // Local wall-clock hours preserved exactly as legacy behavior.
+      expect(w.start.getHours()).toBe(9);
+      expect(w.end.getHours()).toBe(17);
+    }
+  });
+});

package/Tests/Types/OnCallDutyPolicy/LayerUtilWeekendGapRepro.test.ts

@@ -0,0 +1,112 @@
+/**
+ * REPRO (weekly granularity of the post-window-gap off-by-one):
+ * weekly rotation [A,B] with a Mon-Fri weekly restriction, resolved on the
+ * WEEKEND, attributes next week to the WRONG user.
+ *
+ * Layer start Mon 2025-01-06 00:00 UTC, weekly rotation, restriction active
+ * Mon 00:00 -> Sat 00:00 (i.e. Mon-Fri).
+ *   Full expansion (calendar): week0 (Jan6-10)=A, week1 (Jan13-17)=B ...
+ *   Windowed asked on Sat 2025-01-11 12:00 : next week=A (WRONG, should be B).
+ */
+import LayerUtil, { LayerProps } from "../../../Types/OnCallDutyPolicy/Layer";
+import CalendarEvent from "../../../Types/Calendar/CalendarEvent";
+import RestrictionTimes, {
+  RestrictionType,
+  WeeklyResctriction,
+} from "../../../Types/OnCallDutyPolicy/RestrictionTimes";
+import Recurring from "../../../Types/Events/Recurring";
+import OneUptimeDate from "../../../Types/Date";
+import User from "../../../Models/DatabaseModels/User";
+import EventInterval from "../../../Types/Events/EventInterval";
+import PositiveNumber from "../../../Types/PositiveNumber";
+import DayOfWeek from "../../../Types/Day/DayOfWeek";
+
+function user(id: string): User {
+  return {
+    id: {
+      toString: (): string => {
+        return id;
+      },
+    } as any,
+  } as User;
+}
+
+function makeLayer(): LayerProps {
+  const rot: Recurring = new Recurring();
+  rot.intervalType = EventInterval.Week;
+  rot.intervalCount = new PositiveNumber(1);
+  const start: Date = OneUptimeDate.fromString("2025-01-06T00:00:00.000Z"); // Monday
+
+  // Active Mon 00:00 -> Sat 00:00 (Mon-Fri coverage). Non-wrapping window.
+  const weekly: WeeklyResctriction = {
+    startDay: DayOfWeek.Monday,
+    endDay: DayOfWeek.Saturday,
+    startTime: OneUptimeDate.fromString("2025-01-06T00:00:00.000Z"), // Monday
+    endTime: OneUptimeDate.fromString("2025-01-11T00:00:00.000Z"), // Saturday
+  };
+  const r: RestrictionTimes = new RestrictionTimes();
+  r.restictionType = RestrictionType.Weekly;
+  r.weeklyRestrictionTimes = [weekly];
+
+  return {
+    users: [user("A"), user("B")],
+    startDateTimeOfLayer: start,
+    restrictionTimes: r,
+    handOffTime: Recurring.getNextDateInterval(start, rot),
+    rotation: rot,
+    timezone: undefined,
+  };
+}
+
+function fmt(e: CalendarEvent): string {
+  return `${e.title} [${e.start.toISOString()} -> ${e.end.toISOString()}]`;
+}
+
+describe("Weekly rotation + Mon-Fri restriction: weekend query off-by-one", () => {
+  test("week1 is B in calendar but a Saturday query says next week=A", () => {
+    const layer: LayerProps = makeLayer();
+    const util: LayerUtil = new LayerUtil();
+
+    const full: Array<CalendarEvent> = util.getEvents({
+      ...layer,
+      calendarStartDate: layer.startDateTimeOfLayer,
+      calendarEndDate: OneUptimeDate.fromString("2025-01-25T00:00:00.000Z"),
+    });
+
+    // Who covers Wed Jan 15 (inside week1 Mon-Fri) in the calendar?
+    const jan15: Date = OneUptimeDate.fromString("2025-01-15T12:00:00.000Z");
+    const week1Cover: CalendarEvent | undefined = full.find(
+      (e: CalendarEvent) => {
+        return (
+          OneUptimeDate.isOnOrAfter(jan15, e.start) &&
+          OneUptimeDate.isBefore(jan15, e.end)
+        );
+      },
+    );
+
+    // Ask on Saturday Jan 11 12:00 (weekend gap of week0).
+    const askAt: Date = OneUptimeDate.fromString("2025-01-11T12:00:00.000Z");
+    const windowed: Array<CalendarEvent> = util.getEvents(
+      {
+        ...layer,
+        calendarStartDate: askAt,
+        calendarEndDate: OneUptimeDate.addRemoveDays(askAt, 14),
+      },
+      { getNumberOfEvents: 1 },
+    );
+
+    // eslint-disable-next-line no-console
+    console.log("FULL:", full.map(fmt));
+    // eslint-disable-next-line no-console
+    console.log("week1 covered by (full):", week1Cover && fmt(week1Cover));
+    // eslint-disable-next-line no-console
+    console.log(
+      "WINDOWED next @Sat Jan11 12:00:",
+      windowed[0] && fmt(windowed[0]),
+    );
+
+    expect(week1Cover?.title).toBe("B");
+    // Windowed next on-call should be week1 = B; it is A -> BUG.
+    expect(windowed[0]?.title).toBe("B");
+  });
+});

package/Tests/Types/OnCallDutyPolicy/OverrideLensAudit.test.ts

@@ -0,0 +1,117 @@
+import CalendarEvent from "../../../Types/Calendar/CalendarEvent";
+import UserOverrideUtil, {
+  UserOverrideRecord,
+} from "../../../Types/OnCallDutyPolicy/UserOverrideUtil";
+
+function at(h: number, m: number = 0, s: number = 0, ms: number = 0): Date {
+  return new Date(2026, 0, 1, h, m, s, ms);
+}
+
+function event(
+  title: string,
+  startHour: number,
+  endHour: number,
+): CalendarEvent {
+  return {
+    id: 1,
+    title,
+    allDay: false,
+    start: at(startHour),
+    end: at(endHour),
+  };
+}
+
+function resolvedAt(events: Array<CalendarEvent>, t: Date): string | null {
+  for (const e of events) {
+    if (t.getTime() >= e.start.getTime() && t.getTime() < e.end.getTime()) {
+      return e.title;
+    }
+  }
+  return null;
+}
+
+describe("Override lens audit", () => {
+  test("REPRO: applyOverridesToEvents is non-transitive (roster stores B for chain A->B, B->C)", () => {
+    // User A is on-call. A->B (A on vacation, route to B). B->C (B also busy, route to C).
+    const base: CalendarEvent = event("A", 8, 14);
+    const aToB: UserOverrideRecord = {
+      overrideUserId: "A",
+      routeAlertsToUserId: "B",
+      startsAt: at(9),
+      endsAt: at(13),
+      onCallDutyPolicyId: null,
+    };
+    const bToC: UserOverrideRecord = {
+      overrideUserId: "B",
+      routeAlertsToUserId: "C",
+      startsAt: at(9),
+      endsAt: at(13),
+      onCallDutyPolicyId: null,
+    };
+    const result: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [base],
+        overrides: [aToB, bToC],
+      });
+    // Non-transitive: schedule resolution (roster + dashboard) reports B, NOT C.
+    expect(resolvedAt(result, at(11))).toBe("B");
+    /*
+     * The escalation paging path would then run getRouteAlertToUserId("B"),
+     * find the B->C override, and page C -> divergence from the roster (B).
+     */
+  });
+
+  test("REPRO: swap pair A->B and B->A resolves to B (roster), escalation would route B->A", () => {
+    const base: CalendarEvent = event("A", 8, 14);
+    const aToB: UserOverrideRecord = {
+      overrideUserId: "A",
+      routeAlertsToUserId: "B",
+      startsAt: at(9),
+      endsAt: at(13),
+      onCallDutyPolicyId: null,
+    };
+    const bToA: UserOverrideRecord = {
+      overrideUserId: "B",
+      routeAlertsToUserId: "A",
+      startsAt: at(9),
+      endsAt: at(13),
+      onCallDutyPolicyId: null,
+    };
+    const result: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [base],
+        overrides: [aToB, bToA],
+      });
+    // Roster resolves to B. getRouteAlertToUserId("B") would map B->A and page A.
+    expect(resolvedAt(result, at(11))).toBe("B");
+  });
+
+  test("EDGE: self-override A->A blocks a legit overlapping override A->B", () => {
+    const base: CalendarEvent = event("A", 8, 14);
+    const selfOverride: UserOverrideRecord = {
+      overrideUserId: "A",
+      routeAlertsToUserId: "A", // self, no-op substitution
+      startsAt: at(10),
+      endsAt: at(12),
+      onCallDutyPolicyId: null,
+    };
+    const aToB: UserOverrideRecord = {
+      overrideUserId: "A",
+      routeAlertsToUserId: "B",
+      startsAt: at(9),
+      endsAt: at(13),
+      onCallDutyPolicyId: null,
+    };
+    const result: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [base],
+        overrides: [selfOverride, aToB],
+      });
+    /*
+     * At 11:00 the real override A->B is expected, but the self-override marked
+     * [10,12] first, so it is skipped and A stays on-call.
+     */
+    // eslint-disable-next-line no-console
+    console.log("self-override case @11:00 =>", resolvedAt(result, at(11)));
+  });
+});

package/Tests/Types/OnCallDutyPolicy/RestrictionTimes.test.ts

@@ -209,11 +209,13 @@ describe("RestrictionTimes", () => {
       expect(restored.dayRestrictionTimes!.endTime).toBeDefined();
     });
 
-    test("falls back to an empty object when weeklyRestrictionTimes is missing", () => {
+    test("falls back to an empty array when weeklyRestrictionTimes is missing", () => {
       /*
-       * The source uses `(data["weeklyRestrictionTimes"] ...) || {}`, so when the
-       * value object omits weeklyRestrictionTimes the fallback is an empty object
-       * (NOT an empty array). This documents that quirky behavior precisely.
+       * When the value object omits weeklyRestrictionTimes, fromJSON must fall
+       * back to an empty ARRAY so the array-type contract holds. A previous
+       * `|| {}` fallback produced a non-array `{}` that slipped past
+       * Layer.getEventsByWeeklyRestriction's length guard and threw
+       * "not iterable" during weekly expansion (audit F20).
        */
       const restored: RestrictionTimes = RestrictionTimes.fromJSON({
         _type: ObjectType.RestrictionTimes,
@@ -223,8 +225,8 @@ describe("RestrictionTimes", () => {
         },
       });
 
-      expect(restored.weeklyRestrictionTimes).toEqual({});
-      expect(Array.isArray(restored.weeklyRestrictionTimes)).toBe(false);
+      expect(restored.weeklyRestrictionTimes).toEqual([]);
+      expect(Array.isArray(restored.weeklyRestrictionTimes)).toBe(true);
     });
 
     test("preserves a provided weeklyRestrictionTimes array on fromJSON", () => {

package/Tests/Types/OnCallDutyPolicy/RestrictionTimesDefaultDayAudit.test.ts

@@ -0,0 +1,112 @@
+import RestrictionTimes, {
+  RestrictionType,
+  WeeklyResctriction,
+} from "../../../Types/OnCallDutyPolicy/RestrictionTimes";
+import LayerUtil, { LayerProps } from "../../../Types/OnCallDutyPolicy/Layer";
+import Recurring from "../../../Types/Events/Recurring";
+import EventInterval from "../../../Types/Events/EventInterval";
+import PositiveNumber from "../../../Types/PositiveNumber";
+import OneUptimeDate from "../../../Types/Date";
+import DayOfWeek from "../../../Types/Day/DayOfWeek";
+import User from "../../../Models/DatabaseModels/User";
+import CalendarEvent from "../../../Types/Calendar/CalendarEvent";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Audit M4: getDefaultWeeklyRestrictionTIme() built startTime/endTime with
+ * getDateWithCustomTime(), which stamps TODAY's date. The rotation engine derives
+ * the ENFORCED weekday purely from the timestamp (getDayOfWeek(startTime)), not
+ * from the startDay/endDay enum the dropdown displays — so an untouched default
+ * enforced coverage on TODAY's weekday while still showing "Sunday -> Monday".
+ * The fix anchors the default timestamps onto the named weekday so the enforced
+ * day matches the displayed day.
+ */
+
+function user(id: string): User {
+  return {
+    id: {
+      toString: (): string => {
+        return id;
+      },
+    } as any,
+  } as User;
+}
+
+describe("RestrictionTimes audit M4: default weekly restriction weekday", () => {
+  test("default startTime falls on Sunday and endTime on Monday (matches the enum)", () => {
+    const def: WeeklyResctriction =
+      RestrictionTimes.getDefaultWeeklyRestrictionTIme();
+
+    expect(def.startDay).toBe(DayOfWeek.Sunday);
+    expect(def.endDay).toBe(DayOfWeek.Monday);
+
+    /*
+     * The TIMESTAMP's weekday — what the engine actually enforces — matches the
+     * enum. Before the fix this was TODAY's weekday.
+     */
+    expect(OneUptimeDate.getDayOfWeek(def.startTime)).toBe(DayOfWeek.Sunday);
+    expect(OneUptimeDate.getDayOfWeek(def.endTime)).toBe(DayOfWeek.Monday);
+  });
+
+  test("default preserves the intended times of day (00:00 start, 01:00 end)", () => {
+    const def: WeeklyResctriction =
+      RestrictionTimes.getDefaultWeeklyRestrictionTIme();
+
+    expect(new Date(def.startTime).getHours()).toBe(0);
+    expect(new Date(def.endTime).getHours()).toBe(1);
+  });
+
+  test("engine enforces the default weekly restriction on Sunday, not today", () => {
+    /*
+     * Wednesday 2025-06-04 — the layer/window start deliberately falls on a
+     * non-Sunday to prove enforcement follows the restriction weekday, not the
+     * start day.
+     */
+    const anchor: Date = new Date(Date.UTC(2025, 5, 4, 0, 0, 0));
+
+    const rt: RestrictionTimes = new RestrictionTimes();
+    rt.restictionType = RestrictionType.Weekly;
+    rt.weeklyRestrictionTimes = [
+      RestrictionTimes.getDefaultWeeklyRestrictionTIme(),
+    ];
+
+    const r: Recurring = new Recurring();
+    r.intervalType = EventInterval.Week;
+    r.intervalCount = new PositiveNumber(1);
+
+    /*
+     * Expand in the SAME zone the Common default was built in (server-local, i.e.
+     * timezone undefined). getDefaultWeeklyRestrictionTIme lands the timestamp on
+     * Sunday in server-local time; enforcing and reading the weekday in that same
+     * zone keeps the assertion independent of the CI machine's timezone (the
+     * frontend reconciles the default to the schedule zone separately).
+     */
+    const layer: LayerProps = {
+      users: [user("A")],
+      startDateTimeOfLayer: anchor,
+      handOffTime: anchor,
+      restrictionTimes: rt,
+      rotation: r,
+      timezone: undefined,
+    };
+
+    const events: Array<CalendarEvent> = new LayerUtil().getEvents({
+      ...layer,
+      calendarStartDate: anchor,
+      calendarEndDate: new Date(Date.UTC(2025, 5, 18, 0, 0, 0)),
+    });
+
+    expect(events.length).toBeGreaterThan(0);
+
+    /*
+     * Every emitted covered segment must start on Sunday (the restriction window
+     * is Sunday 00:00 -> Monday 01:00). Before the fix the default landed on the
+     * current weekday, so coverage appeared mid-week instead. Monday is allowed
+     * only as the continuation edge; no segment may start Tue-Sat.
+     */
+    for (const e of events) {
+      const startDow: DayOfWeek = OneUptimeDate.getDayOfWeek(new Date(e.start));
+      expect([DayOfWeek.Sunday, DayOfWeek.Monday]).toContain(startDow);
+    }
+  });
+});