@oneuptime/common 11.3.26 → 11.4.0

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

@@ -0,0 +1,300 @@
+import LayerUtil, { LayerProps } from "../../../Types/OnCallDutyPolicy/Layer";
+import CalendarEvent from "../../../Types/Calendar/CalendarEvent";
+import RestrictionTimes, {
+  RestrictionType,
+} 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";
+
+function user(id: string): User {
+  return {
+    id: {
+      toString: () => {
+        return id;
+      },
+    } as any,
+  } as User;
+}
+
+function rotation(t: EventInterval, c: number): Recurring {
+  return Recurring.fromJSON({
+    _type: "Recurring",
+    value: {
+      intervalType: t,
+      intervalCount: { _type: "PositiveNumber", value: c },
+    },
+  } as any);
+}
+
+function noRestriction(): RestrictionTimes {
+  const r: RestrictionTimes = new RestrictionTimes();
+  r.restictionType = RestrictionType.None;
+  r.dayRestrictionTimes = null;
+  return r;
+}
+
+function dailyRestriction(
+  startHour: number,
+  endHour: number,
+): RestrictionTimes {
+  const r: RestrictionTimes = new RestrictionTimes();
+  r.restictionType = RestrictionType.Daily;
+  r.dayRestrictionTimes = {
+    startTime: OneUptimeDate.getDateWithCustomTime({
+      hours: startHour,
+      minutes: 0,
+      seconds: 0,
+    }),
+    endTime: OneUptimeDate.getDateWithCustomTime({
+      hours: endHour,
+      minutes: 0,
+      seconds: 0,
+    }),
+  };
+  return r;
+}
+
+function coveringUser(events: Array<CalendarEvent>, t: Date): string | null {
+  for (const e of events) {
+    if (e.start.getTime() <= t.getTime() && e.end.getTime() > t.getTime()) {
+      return e.title;
+    }
+  }
+  return null;
+}
+
+function oracleUser(
+  perLayerEvents: Array<Array<CalendarEvent>>,
+  t: Date,
+): string | null {
+  for (const layerEvents of perLayerEvents) {
+    const u: string | null = coveringUser(layerEvents, t);
+    if (u !== null) {
+      return u;
+    }
+  }
+  return null;
+}
+
+function overlappingPairs(
+  events: Array<CalendarEvent>,
+): Array<[CalendarEvent, CalendarEvent]> {
+  const pairs: Array<[CalendarEvent, CalendarEvent]> = [];
+  for (let i: number = 0; i < events.length; i++) {
+    for (let j: number = i + 1; j < events.length; j++) {
+      const a: CalendarEvent = events[i]!;
+      const b: CalendarEvent = events[j]!;
+      const start: number = Math.max(a.start.getTime(), b.start.getTime());
+      const end: number = Math.min(a.end.getTime(), b.end.getTime());
+      if (end - start > 0) {
+        pairs.push([a, b]);
+      }
+    }
+  }
+  return pairs;
+}
+
+describe("Multi-layer edge cases", () => {
+  const util: LayerUtil = new LayerUtil();
+
+  function checkMerge(
+    layers: Array<LayerProps>,
+    calStart: Date,
+    calEnd: Date,
+    stepMin: number = 15,
+  ): {
+    mismatches: Array<string>;
+    overlaps: number;
+    merged: Array<CalendarEvent>;
+  } {
+    const merged: Array<CalendarEvent> = util.getMultiLayerEvents({
+      layers: layers,
+      calendarStartDate: calStart,
+      calendarEndDate: calEnd,
+    });
+    const perLayerEvents: Array<Array<CalendarEvent>> = layers.map(
+      (layer: LayerProps): Array<CalendarEvent> => {
+        return util.getEvents({
+          ...layer,
+          calendarStartDate: calStart,
+          calendarEndDate: calEnd,
+        });
+      },
+    );
+    const mismatches: Array<string> = [];
+    for (
+      let ms: number = calStart.getTime() + 17000;
+      ms < calEnd.getTime();
+      ms += stepMin * 60 * 1000
+    ) {
+      const t: Date = new Date(ms);
+      const expected: string | null = oracleUser(perLayerEvents, t);
+      const actual: string | null = coveringUser(merged, t);
+      if (expected !== actual) {
+        mismatches.push(
+          `${OneUptimeDate.toString(t)} expected=${expected} actual=${actual}`,
+        );
+      }
+    }
+    return {
+      mismatches: mismatches,
+      overlaps: overlappingPairs(merged).length,
+      merged: merged,
+    };
+  }
+
+  test("G: high-priority layer starts 2 days into a 5-day window; fallback fills the head", () => {
+    const calStart: Date = new Date(2026, 0, 5, 0, 0, 0);
+    const primaryStart: Date = new Date(2026, 0, 7, 0, 0, 0); // 2 days later
+    const calEnd: Date = new Date(2026, 0, 10, 0, 0, 0);
+
+    const layers: Array<LayerProps> = [
+      {
+        users: [user("P1"), user("P2")],
+        startDateTimeOfLayer: primaryStart,
+        restrictionTimes: noRestriction(),
+        handOffTime: primaryStart,
+        rotation: rotation(EventInterval.Day, 1),
+      },
+      {
+        users: [user("F1")],
+        startDateTimeOfLayer: calStart,
+        restrictionTimes: noRestriction(),
+        handOffTime: calStart,
+        rotation: rotation(EventInterval.Week, 1),
+      },
+    ];
+
+    const { mismatches, overlaps } = checkMerge(layers, calStart, calEnd);
+    // First 2 days: fallback F1. After primaryStart: P1/P2 daily.
+    expect(mismatches).toEqual([]);
+    expect(overlaps).toBe(0);
+  });
+
+  test("H: three layers with different start offsets and rotations", () => {
+    const calStart: Date = new Date(2026, 0, 5, 0, 0, 0);
+    const calEnd: Date = new Date(2026, 0, 9, 0, 0, 0);
+
+    const layers: Array<LayerProps> = [
+      {
+        users: [user("A")],
+        startDateTimeOfLayer: new Date(2026, 0, 6, 12, 0, 0),
+        restrictionTimes: dailyRestriction(0, 6),
+        handOffTime: new Date(2026, 0, 6, 12, 0, 0),
+        rotation: rotation(EventInterval.Day, 1),
+      },
+      {
+        users: [user("B1"), user("B2")],
+        startDateTimeOfLayer: new Date(2026, 0, 5, 6, 0, 0),
+        restrictionTimes: dailyRestriction(8, 20),
+        handOffTime: new Date(2026, 0, 5, 12, 0, 0),
+        rotation: rotation(EventInterval.Hour, 6),
+      },
+      {
+        users: [user("Z")],
+        startDateTimeOfLayer: calStart,
+        restrictionTimes: noRestriction(),
+        handOffTime: calStart,
+        rotation: rotation(EventInterval.Week, 1),
+      },
+    ];
+
+    const { mismatches, overlaps } = checkMerge(layers, calStart, calEnd, 10);
+    expect(mismatches).toEqual([]);
+    expect(overlaps).toBe(0);
+  });
+
+  test("I: three layers all starting at window start (equal starts) -> priority order", () => {
+    const calStart: Date = new Date(2026, 0, 5, 0, 0, 0);
+    const calEnd: Date = new Date(2026, 0, 12, 0, 0, 0);
+
+    const layers: Array<LayerProps> = [
+      {
+        users: [user("A")],
+        startDateTimeOfLayer: calStart,
+        restrictionTimes: noRestriction(),
+        handOffTime: calStart,
+        rotation: rotation(EventInterval.Week, 1),
+      },
+      {
+        users: [user("B")],
+        startDateTimeOfLayer: calStart,
+        restrictionTimes: noRestriction(),
+        handOffTime: calStart,
+        rotation: rotation(EventInterval.Day, 1),
+      },
+      {
+        users: [user("C")],
+        startDateTimeOfLayer: calStart,
+        restrictionTimes: noRestriction(),
+        handOffTime: calStart,
+        rotation: rotation(EventInterval.Hour, 1),
+      },
+    ];
+
+    const { mismatches, overlaps } = checkMerge(layers, calStart, calEnd, 13);
+    // Layer 0 (A) is 24/7 highest priority -> A everywhere.
+    expect(mismatches).toEqual([]);
+    expect(overlaps).toBe(0);
+  });
+
+  test("J: high-priority restricted layer over a RESTRICTED (non-24/7) fallback leaving true gaps", () => {
+    // Both layers restricted; there are genuine uncovered periods (oracle=null).
+    const calStart: Date = new Date(2026, 0, 5, 0, 0, 0);
+    const calEnd: Date = new Date(2026, 0, 9, 0, 0, 0);
+
+    const layers: Array<LayerProps> = [
+      {
+        users: [user("A")],
+        startDateTimeOfLayer: calStart,
+        restrictionTimes: dailyRestriction(9, 12),
+        handOffTime: calStart,
+        rotation: rotation(EventInterval.Week, 1),
+      },
+      {
+        users: [user("B")],
+        startDateTimeOfLayer: calStart,
+        restrictionTimes: dailyRestriction(10, 17), // overlaps A at 10-12
+        handOffTime: calStart,
+        rotation: rotation(EventInterval.Week, 1),
+      },
+    ];
+
+    const { mismatches, overlaps } = checkMerge(layers, calStart, calEnd, 11);
+    // Expect: A owns 9-12, B owns 12:00:01-17, nobody owns nights.
+    expect(mismatches).toEqual([]);
+    expect(overlaps).toBe(0);
+  });
+
+  test("K: primary rotation window exactly abuts fallback stitch boundary", () => {
+    /*
+     * Primary hourly restricted 10-14; fallback 24/7. Check the exact 10:00 and
+     * 14:00 boundaries via the merged output shape (no overlaps, contiguous).
+     */
+    const calStart: Date = new Date(2026, 0, 5, 0, 0, 0);
+    const calEnd: Date = new Date(2026, 0, 7, 0, 0, 0);
+
+    const layers: Array<LayerProps> = [
+      {
+        users: [user("A"), user("B")],
+        startDateTimeOfLayer: calStart,
+        restrictionTimes: dailyRestriction(10, 14),
+        handOffTime: new Date(2026, 0, 5, 12, 0, 0),
+        rotation: rotation(EventInterval.Hour, 2),
+      },
+      {
+        users: [user("Z")],
+        startDateTimeOfLayer: calStart,
+        restrictionTimes: noRestriction(),
+        handOffTime: calStart,
+        rotation: rotation(EventInterval.Week, 1),
+      },
+    ];
+
+    const { mismatches, overlaps } = checkMerge(layers, calStart, calEnd, 5);
+    expect(mismatches).toEqual([]);
+    expect(overlaps).toBe(0);
+  });
+});

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

@@ -0,0 +1,158 @@
+import LayerUtil, { LayerProps } from "../../../Types/OnCallDutyPolicy/Layer";
+import RestrictionTimes, {
+  RestrictionType,
+} from "../../../Types/OnCallDutyPolicy/RestrictionTimes";
+import Recurring from "../../../Types/Events/Recurring";
+import EventInterval from "../../../Types/Events/EventInterval";
+import PositiveNumber from "../../../Types/PositiveNumber";
+import User from "../../../Models/DatabaseModels/User";
+import CalendarEvent from "../../../Types/Calendar/CalendarEvent";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Audit L1: getEventsByDailyRestriction's overnight (end < start) branch stepped
+ * its day-by-day iterator with addRemoveDays(currentDayStart, 1) WITHOUT the
+ * schedule timezone, i.e. a fixed 24h step. Every segment-shaping call
+ * (getStartOfDay / keepTimeButMoveDay) IS timezone-aware, so on a fall-back DST
+ * date (the schedule-zone day is 25h long) the 24h step landed the iterator back
+ * inside the SAME schedule-zone calendar day and emitted that day's night +
+ * morning segments a SECOND time — duplicate, identical on-call events for the
+ * same user. Coverage stays continuous (no gap), so this is a duplicate-segment
+ * defect. The fix passes this.timezone to both day-step calls.
+ */
+
+function user(id: string): User {
+  return {
+    id: {
+      toString: (): string => {
+        return id;
+      },
+    } as any,
+  } as User;
+}
+
+function overnightRestriction(): RestrictionTimes {
+  const rt: RestrictionTimes = new RestrictionTimes();
+  rt.restictionType = RestrictionType.Daily;
+  // 22:00 -> 06:00 (next day). end < start within a day => overnight branch.
+  rt.dayRestrictionTimes = {
+    startTime: new Date(Date.UTC(2025, 0, 1, 22, 0, 0)),
+    endTime: new Date(Date.UTC(2025, 0, 1, 6, 0, 0)),
+  };
+  return rt;
+}
+
+function weeklyRotation(): Recurring {
+  /*
+   * One long period so a single rotation event spans the whole DST window and
+   * the daily overnight restriction tiles nightly across it.
+   */
+  const r: Recurring = new Recurring();
+  r.intervalType = EventInterval.Week;
+  r.intervalCount = new PositiveNumber(1);
+  return r;
+}
+
+function duplicateKeys(events: Array<CalendarEvent>): Array<string> {
+  const seen: Set<string> = new Set<string>();
+  const dupes: Array<string> = [];
+  for (const e of events) {
+    const key: string = `${e.title}|${new Date(e.start).toISOString()}|${new Date(
+      e.end,
+    ).toISOString()}`;
+    if (seen.has(key)) {
+      dupes.push(key);
+    }
+    seen.add(key);
+  }
+  return dupes;
+}
+
+describe("LayerUtil audit L1: overnight restriction across DST fall-back", () => {
+  test("no duplicate segments across the 2025-11-02 fall-back (America/New_York)", () => {
+    const anchor: Date = new Date(Date.UTC(2025, 9, 27, 0, 0, 0)); // Oct 27
+    const layer: LayerProps = {
+      users: [user("A")],
+      startDateTimeOfLayer: anchor,
+      handOffTime: anchor,
+      restrictionTimes: overnightRestriction(),
+      rotation: weeklyRotation(),
+      timezone: "America/New_York",
+    };
+
+    const events: Array<CalendarEvent> = new LayerUtil().getEvents({
+      ...layer,
+      calendarStartDate: new Date(Date.UTC(2025, 10, 1, 0, 0, 0)), // Nov 1
+      calendarEndDate: new Date(Date.UTC(2025, 10, 6, 0, 0, 0)), // Nov 6
+    });
+
+    expect(events.length).toBeGreaterThan(0); // coverage still exists (no gap)
+    expect(duplicateKeys(events)).toEqual([]); // and no duplicate on-call blocks
+  });
+
+  test("no duplicate segments across the 2025-03-09 spring-forward (America/New_York)", () => {
+    const anchor: Date = new Date(Date.UTC(2025, 2, 2, 0, 0, 0)); // Mar 2
+    const layer: LayerProps = {
+      users: [user("A")],
+      startDateTimeOfLayer: anchor,
+      handOffTime: anchor,
+      restrictionTimes: overnightRestriction(),
+      rotation: weeklyRotation(),
+      timezone: "America/New_York",
+    };
+
+    const events: Array<CalendarEvent> = new LayerUtil().getEvents({
+      ...layer,
+      calendarStartDate: new Date(Date.UTC(2025, 2, 7, 0, 0, 0)), // Mar 7
+      calendarEndDate: new Date(Date.UTC(2025, 2, 12, 0, 0, 0)), // Mar 12
+    });
+
+    expect(events.length).toBeGreaterThan(0);
+    expect(duplicateKeys(events)).toEqual([]);
+  });
+
+  test("control: same overnight restriction on a non-DST week has no duplicates", () => {
+    const anchor: Date = new Date(Date.UTC(2025, 6, 6, 0, 0, 0)); // Jul 6
+    const layer: LayerProps = {
+      users: [user("A")],
+      startDateTimeOfLayer: anchor,
+      handOffTime: anchor,
+      restrictionTimes: overnightRestriction(),
+      rotation: weeklyRotation(),
+      timezone: "America/New_York",
+    };
+
+    const events: Array<CalendarEvent> = new LayerUtil().getEvents({
+      ...layer,
+      calendarStartDate: new Date(Date.UTC(2025, 6, 7, 0, 0, 0)),
+      calendarEndDate: new Date(Date.UTC(2025, 6, 12, 0, 0, 0)),
+    });
+
+    expect(events.length).toBeGreaterThan(0);
+    expect(duplicateKeys(events)).toEqual([]);
+  });
+
+  test("no event has zero or negative length (start < end) across DST", () => {
+    const anchor: Date = new Date(Date.UTC(2025, 9, 27, 0, 0, 0));
+    const layer: LayerProps = {
+      users: [user("A")],
+      startDateTimeOfLayer: anchor,
+      handOffTime: anchor,
+      restrictionTimes: overnightRestriction(),
+      rotation: weeklyRotation(),
+      timezone: "America/New_York",
+    };
+
+    const events: Array<CalendarEvent> = new LayerUtil().getEvents({
+      ...layer,
+      calendarStartDate: new Date(Date.UTC(2025, 10, 1, 0, 0, 0)),
+      calendarEndDate: new Date(Date.UTC(2025, 10, 6, 0, 0, 0)),
+    });
+
+    for (const e of events) {
+      expect(new Date(e.end).getTime()).toBeGreaterThan(
+        new Date(e.start).getTime(),
+      );
+    }
+  });
+});

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

@@ -0,0 +1,253 @@
+/**
+ * REGRESSION SUITE for the restricted-rotation post-window-gap off-by-one fix
+ * (audit F2).
+ *
+ * When the roster is resolved partway through a rotation period, AFTER that
+ * period's restriction window has already closed (the live "who is on call
+ * now / next" path resolving in a daily or weekend off-hours gap), the windowed
+ * expansion used to carry the current period's user into the next period,
+ * paging/notifying the WRONG "next" user for every subsequent shift.
+ *
+ * The fix decides the first-period rotation advance on the period's FULL span
+ * rather than the clamped [now, periodEnd] slice. These tests lock in that
+ * behavior AND assert the #2413 "fully-restricted period keeps its turn skipped"
+ * behavior is preserved (the guard the fix touches).
+ */
+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 dailyRestriction(sh: number, eh: number): RestrictionTimes {
+  const r: RestrictionTimes = new RestrictionTimes();
+  r.restictionType = RestrictionType.Daily;
+  r.dayRestrictionTimes = {
+    startTime: OneUptimeDate.getDateWithCustomTime({
+      hours: sh,
+      minutes: 0,
+      seconds: 0,
+    }),
+    endTime: OneUptimeDate.getDateWithCustomTime({
+      hours: eh,
+      minutes: 0,
+      seconds: 0,
+    }),
+  };
+  return r;
+}
+
+function dailyLayer(data: {
+  users: string[];
+  intervalCount: number;
+  restriction: RestrictionTimes;
+  start: Date;
+}): LayerProps {
+  const rot: Recurring = new Recurring();
+  rot.intervalType = EventInterval.Day;
+  rot.intervalCount = new PositiveNumber(data.intervalCount);
+  return {
+    users: data.users.map(user),
+    startDateTimeOfLayer: data.start,
+    restrictionTimes: data.restriction,
+    handOffTime: Recurring.getNextDateInterval(data.start, rot),
+    rotation: rot,
+    timezone: undefined,
+  };
+}
+
+/*
+ * Who does the LIVE roster path (windowed, getNumberOfEvents:1) resolve as the
+ * first covered event at instant `at`.
+ */
+function windowedNextAt(
+  layer: LayerProps,
+  at: Date,
+): CalendarEvent | undefined {
+  const util: LayerUtil = new LayerUtil();
+  return util.getMultiLayerEvents(
+    {
+      layers: [layer],
+      calendarStartDate: at,
+      calendarEndDate: OneUptimeDate.addRemoveDays(at, 20),
+    },
+    { getNumberOfEvents: 1 },
+  )[0];
+}
+
+// Ground-truth covering (or next) user from a full expansion.
+function fullExpand(
+  layer: LayerProps,
+  from: Date,
+  to: Date,
+): Array<CalendarEvent> {
+  const util: LayerUtil = new LayerUtil();
+  return util.getEvents({
+    ...layer,
+    calendarStartDate: from,
+    calendarEndDate: to,
+  });
+}
+
+const MON_JAN6: Date = OneUptimeDate.fromString("2025-01-06T00:00:00.000Z");
+
+describe("F2 fix: daily rotation post-window gap resolves the correct next user", () => {
+  test("x1 daily, [A,B], 09-17: evening gaps never go off-by-one over 10 days", () => {
+    const layer: LayerProps = dailyLayer({
+      users: ["A", "B"],
+      intervalCount: 1,
+      restriction: dailyRestriction(9, 17),
+      start: MON_JAN6,
+    });
+
+    const full: Array<CalendarEvent> = fullExpand(
+      layer,
+      MON_JAN6,
+      OneUptimeDate.addRemoveDays(MON_JAN6, 12),
+    );
+
+    /*
+     * For each day, the evening (post-17:00) gap query's "next" must equal the
+     * NEXT day's covered user in the full expansion.
+     */
+    for (let day: number = 0; day < 9; day++) {
+      const eveningGap: Date = OneUptimeDate.addRemoveHours(
+        OneUptimeDate.addRemoveDays(MON_JAN6, day),
+        20, // 20:00, after the 09-17 window closed
+      );
+      const nextCovered: CalendarEvent | undefined = full.find(
+        (e: CalendarEvent) => {
+          return OneUptimeDate.isAfter(e.start, eveningGap);
+        },
+      );
+      const windowed: CalendarEvent | undefined = windowedNextAt(
+        layer,
+        eveningGap,
+      );
+      expect(windowed?.title).toBe(nextCovered?.title);
+    }
+  });
+
+  test("x1 daily, 3 users [A,B,C], 09-17: evening gap next-user matches calendar", () => {
+    const layer: LayerProps = dailyLayer({
+      users: ["A", "B", "C"],
+      intervalCount: 1,
+      restriction: dailyRestriction(9, 17),
+      start: MON_JAN6,
+    });
+    const full: Array<CalendarEvent> = fullExpand(
+      layer,
+      MON_JAN6,
+      OneUptimeDate.addRemoveDays(MON_JAN6, 12),
+    );
+    for (let day: number = 0; day < 9; day++) {
+      const eveningGap: Date = OneUptimeDate.addRemoveHours(
+        OneUptimeDate.addRemoveDays(MON_JAN6, day),
+        20,
+      );
+      const nextCovered: CalendarEvent | undefined = full.find(
+        (e: CalendarEvent) => {
+          return OneUptimeDate.isAfter(e.start, eveningGap);
+        },
+      );
+      expect(windowedNextAt(layer, eveningGap)?.title).toBe(nextCovered?.title);
+    }
+  });
+
+  test("x2 daily, [A,B], 09-17: last-day evening gap advances to next user", () => {
+    const layer: LayerProps = dailyLayer({
+      users: ["A", "B"],
+      intervalCount: 2,
+      restriction: dailyRestriction(9, 17),
+      start: MON_JAN6,
+    });
+    /*
+     * Period 1 = [Jan6,Jan8) = A (covers Jan6 & Jan7). Period 2 = [Jan8,Jan10) = B.
+     * Querying on Jan7 evening (last covered day of period 1, after 17:00) must
+     * resolve the NEXT covered shift = Jan8 = B, not A.
+     */
+    const jan7evening: Date = OneUptimeDate.fromString(
+      "2025-01-07T20:00:00.000Z",
+    );
+    const next: CalendarEvent | undefined = windowedNextAt(layer, jan7evening);
+    expect(next?.title).toBe("B");
+    expect(next?.start.getUTCDate()).toBe(8);
+
+    // Querying on Jan6 evening (still period 1, Jan7 window ahead) resolves A/Jan7.
+    const jan6evening: Date = OneUptimeDate.fromString(
+      "2025-01-06T20:00:00.000Z",
+    );
+    const next2: CalendarEvent | undefined = windowedNextAt(layer, jan6evening);
+    expect(next2?.title).toBe("A");
+    expect(next2?.start.getUTCDate()).toBe(7);
+  });
+});
+
+describe("F2 fix preserves #2413: fully-restricted periods still skip their turn", () => {
+  test("daily [A,B], Mon-Fri only (weekend fully off): weekend query resolves next Monday's user", () => {
+    /*
+     * Restriction Mon 00:00 -> Sat 00:00 via a weekly restriction => Sat & Sun
+     * are fully restricted (no coverage). Rotation must NOT advance across the
+     * dead weekend, so the sequence of covered days stays a clean A,B,A,B...
+     */
+    const weekly: WeeklyResctriction = {
+      startDay: DayOfWeek.Monday,
+      endDay: DayOfWeek.Saturday,
+      startTime: OneUptimeDate.fromString("2025-01-06T00:00:00.000Z"),
+      endTime: OneUptimeDate.fromString("2025-01-11T00:00:00.000Z"),
+    };
+    const r: RestrictionTimes = new RestrictionTimes();
+    r.restictionType = RestrictionType.Weekly;
+    r.weeklyRestrictionTimes = [weekly];
+
+    const rot: Recurring = new Recurring();
+    rot.intervalType = EventInterval.Day;
+    rot.intervalCount = new PositiveNumber(1);
+    const layer: LayerProps = {
+      users: [user("A"), user("B")],
+      startDateTimeOfLayer: MON_JAN6,
+      restrictionTimes: r,
+      handOffTime: Recurring.getNextDateInterval(MON_JAN6, rot),
+      rotation: rot,
+      timezone: undefined,
+    };
+
+    const full: Array<CalendarEvent> = fullExpand(
+      layer,
+      MON_JAN6,
+      OneUptimeDate.addRemoveDays(MON_JAN6, 14),
+    );
+
+    /*
+     * A Saturday-gap query (Jan 11) must resolve to the next covered day
+     * (Monday Jan 13) with the SAME user the calendar assigns it.
+     */
+    const saturdayGap: Date = OneUptimeDate.fromString(
+      "2025-01-11T12:00:00.000Z",
+    );
+    const nextCovered: CalendarEvent | undefined = full.find(
+      (e: CalendarEvent) => {
+        return OneUptimeDate.isAfter(e.start, saturdayGap);
+      },
+    );
+    expect(nextCovered).toBeTruthy();
+    expect(windowedNextAt(layer, saturdayGap)?.title).toBe(nextCovered?.title);
+  });
+});