skedyul 1.2.43 → 1.2.48

package/dist/scheduling/calculateWaitTime.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Calculate Wait Time
+ *
+ * Calculates when to schedule a message or wait step based on relative/absolute time
+ * and optional time window constraints.
+ *
+ * This is the source of truth - skedyul-core re-exports for backward compatibility.
+ */
+import type { WaitInputType, CalculateWaitTimeResult } from './types-workflow';
+/**
+ * Calculate the wait time for a wait step
+ * @param step The input parameters for the wait step
+ * @param now The current date/time
+ * @returns The time to wait in milliseconds and the scheduled date
+ */
+export declare function calculateWaitTime(step: WaitInputType, now: Date): CalculateWaitTimeResult;

package/dist/scheduling/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Scheduling Module
+ *
+ * This module provides scheduling utilities that are safe to use in Temporal workflows.
+ * It intentionally avoids importing zod to prevent bundler issues.
+ *
+ * For zod schemas, import from './types' directly (not workflow-safe).
+ */
+export type { TimeStamp, DayOfWeek, TimeWindowSlot, WaitUnit, WaitInputRelative, WaitInputAbsolute, WaitInputType, CalculateWaitTimeResult, TimeWindowPolicy, } from './types-workflow';
+export { calculateWaitTime } from './calculateWaitTime';
+export { isTimeInWindowSlot, isTimeInPolicy } from './isTimeInWindow';

package/dist/scheduling/index.js

@@ -0,0 +1,334 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scheduling/index.ts
+var scheduling_exports = {};
+__export(scheduling_exports, {
+  calculateWaitTime: () => calculateWaitTime,
+  isTimeInPolicy: () => isTimeInPolicy,
+  isTimeInWindowSlot: () => isTimeInWindowSlot2
+});
+module.exports = __toCommonJS(scheduling_exports);
+
+// src/scheduling/calculateWaitTime.ts
+var dayNameToNumber = {
+  sunday: 0,
+  monday: 1,
+  tuesday: 2,
+  wednesday: 3,
+  thursday: 4,
+  friday: 5,
+  saturday: 6
+};
+function normalizeTimeToMinutes(timeStamp) {
+  if (timeStamp === void 0 || timeStamp === null) {
+    throw new Error("timeStamp is required and cannot be undefined or null");
+  }
+  if (typeof timeStamp === "number") {
+    return timeStamp * 60;
+  }
+  const minute = timeStamp.minute ?? 0;
+  const second = timeStamp.second ?? 0;
+  return timeStamp.hour * 60 + minute + Math.floor(second / 60);
+}
+function getHourFromTimeStamp(timeStamp) {
+  if (timeStamp === void 0 || timeStamp === null) {
+    throw new Error("timeStamp is required and cannot be undefined or null");
+  }
+  if (typeof timeStamp === "number") {
+    return timeStamp;
+  }
+  return timeStamp.hour;
+}
+function getMinuteFromTimeStamp(timeStamp) {
+  if (timeStamp === void 0 || timeStamp === null) {
+    throw new Error("timeStamp is required and cannot be undefined or null");
+  }
+  if (typeof timeStamp === "number") {
+    return 0;
+  }
+  return timeStamp.minute ?? 0;
+}
+function getTimezoneInfo(date, timezone) {
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  });
+  const parts = formatter.formatToParts(date);
+  const partsObj = parts.reduce(
+    (acc, part) => {
+      acc[part.type] = part.value;
+      return acc;
+    },
+    {}
+  );
+  return {
+    day: new Date(
+      parseInt(partsObj.year ?? "0"),
+      parseInt(partsObj.month ?? "1") - 1,
+      parseInt(partsObj.day ?? "1")
+    ).getDay(),
+    hour: parseInt(partsObj.hour ?? "0"),
+    minute: parseInt(partsObj.minute ?? "0"),
+    totalMinutes: parseInt(partsObj.hour ?? "0") * 60 + parseInt(partsObj.minute ?? "0")
+  };
+}
+function isTimeInWindowSlot(date, window) {
+  if (!window || window.startTime === void 0 || window.endTime === void 0) {
+    return false;
+  }
+  const {
+    days: daysOfWeek,
+    startTime: windowStartTime,
+    endTime: windowEndTime,
+    timezone
+  } = window;
+  const tz = timezone ?? "UTC";
+  const windowStartMinutes = normalizeTimeToMinutes(windowStartTime);
+  const windowEndMinutes = normalizeTimeToMinutes(windowEndTime);
+  const allowedDays = daysOfWeek.map((day) => {
+    return dayNameToNumber[day.toLowerCase()] ?? parseInt(day);
+  }).filter((day) => !isNaN(day) && day >= 0 && day <= 6);
+  const tzInfo = getTimezoneInfo(date, tz);
+  return allowedDays.includes(tzInfo.day) && tzInfo.totalMinutes >= windowStartMinutes && tzInfo.totalMinutes < windowEndMinutes;
+}
+function calculateWaitTime(step, now) {
+  const nowTime = now.getTime();
+  switch (step.mode) {
+    case "absolute": {
+      const scheduleAtTime = typeof step.scheduleAt === "string" ? new Date(step.scheduleAt).getTime() : step.scheduleAt;
+      return {
+        waitTime: Math.max(0, scheduleAtTime - nowTime),
+        scheduledAt: new Date(scheduleAtTime)
+      };
+    }
+    case "relative": {
+      if (!step.amount && (!step.windows || step.windows.length === 0)) {
+        return {
+          waitTime: 0,
+          scheduledAt: now
+        };
+      }
+      let relativeDelay = 0;
+      if (step.amount && step.unit) {
+        switch (step.unit) {
+          case "seconds":
+          case "second":
+            relativeDelay = step.amount * 1e3;
+            break;
+          case "minutes":
+          case "minute":
+            relativeDelay = step.amount * 60 * 1e3;
+            break;
+          case "hours":
+          case "hour":
+            relativeDelay = step.amount * 60 * 60 * 1e3;
+            break;
+          case "days":
+          case "day":
+            relativeDelay = step.amount * 24 * 60 * 60 * 1e3;
+            break;
+          case "weeks":
+          case "week":
+            relativeDelay = step.amount * 7 * 24 * 60 * 60 * 1e3;
+            break;
+          case "months":
+          case "month": {
+            relativeDelay = step.amount * 30 * 24 * 60 * 60 * 1e3;
+            break;
+          }
+          case "years":
+          case "year": {
+            relativeDelay = step.amount * 365 * 24 * 60 * 60 * 1e3;
+            break;
+          }
+        }
+      }
+      if (!step.windows || step.windows.length === 0) {
+        return {
+          waitTime: relativeDelay,
+          scheduledAt: new Date(nowTime + relativeDelay)
+        };
+      }
+      const targetDate = new Date(nowTime + relativeDelay);
+      for (const window of step.windows) {
+        if (isTimeInWindowSlot(targetDate, window)) {
+          return {
+            waitTime: relativeDelay,
+            scheduledAt: new Date(nowTime + relativeDelay)
+          };
+        }
+      }
+      let earliestScheduledTime = null;
+      let earliestWaitTime = Infinity;
+      for (const window of step.windows) {
+        if (!window || window.startTime === void 0 || window.endTime === void 0) {
+          continue;
+        }
+        const { days: daysOfWeek, startTime: windowStartTime, timezone } = window;
+        const tz = timezone ?? "UTC";
+        const windowStartMinutes = normalizeTimeToMinutes(windowStartTime);
+        const windowStartHour = getHourFromTimeStamp(windowStartTime);
+        const windowStartMinute = getMinuteFromTimeStamp(windowStartTime);
+        const allowedDays = daysOfWeek.map((day) => {
+          return dayNameToNumber[day.toLowerCase()] ?? parseInt(day);
+        }).filter((day) => !isNaN(day) && day >= 0 && day <= 6);
+        const targetTzInfo = getTimezoneInfo(targetDate, tz);
+        const currentDay = targetTzInfo.day;
+        const currentHour = targetTzInfo.hour;
+        const currentMinute = targetTzInfo.minute;
+        const currentTotalMinutes = targetTzInfo.totalMinutes;
+        let windowWaitTime;
+        let windowScheduledTime;
+        if (allowedDays.includes(currentDay) && currentTotalMinutes < windowStartMinutes) {
+          const minutesUntilWindow = windowStartMinutes - currentTotalMinutes;
+          windowWaitTime = minutesUntilWindow * 60 * 1e3;
+          windowScheduledTime = new Date(targetDate.getTime() + windowWaitTime);
+        } else {
+          let daysToAdd = 7;
+          for (let i = 1; i <= 7; i++) {
+            const nextDay = (currentDay + i) % 7;
+            if (allowedDays.includes(nextDay)) {
+              daysToAdd = i;
+              break;
+            }
+          }
+          const millisecondsPerDay = 24 * 60 * 60 * 1e3;
+          const millisecondsPerHour = 60 * 60 * 1e3;
+          const millisecondsPerMinute = 60 * 1e3;
+          const daysMs = daysToAdd * millisecondsPerDay;
+          const hoursAdjustment = (windowStartHour - currentHour) * millisecondsPerHour;
+          const minutesAdjustment = (windowStartMinute - currentMinute) * millisecondsPerMinute;
+          windowWaitTime = daysMs + hoursAdjustment + minutesAdjustment;
+          windowScheduledTime = new Date(targetDate.getTime() + windowWaitTime);
+        }
+        if (windowWaitTime < earliestWaitTime) {
+          earliestWaitTime = windowWaitTime;
+          earliestScheduledTime = windowScheduledTime;
+        }
+      }
+      if (earliestScheduledTime) {
+        return {
+          waitTime: relativeDelay + earliestWaitTime,
+          scheduledAt: earliestScheduledTime
+        };
+      }
+      throw new Error("No valid time windows found for scheduling");
+    }
+    default:
+      throw new Error(`Unsupported wait mode: ${step.mode}`);
+  }
+}
+
+// src/scheduling/isTimeInWindow.ts
+var dayNameToNumber2 = {
+  sunday: 0,
+  monday: 1,
+  tuesday: 2,
+  wednesday: 3,
+  thursday: 4,
+  friday: 5,
+  saturday: 6
+};
+function normalizeTimeToMinutes2(timeStamp) {
+  if (timeStamp === void 0 || timeStamp === null) {
+    throw new Error("timeStamp is required and cannot be undefined or null");
+  }
+  if (typeof timeStamp === "number") {
+    return timeStamp * 60;
+  }
+  const minute = timeStamp.minute ?? 0;
+  const second = timeStamp.second ?? 0;
+  return timeStamp.hour * 60 + minute + Math.floor(second / 60);
+}
+function getTimezoneInfo2(date, timezone) {
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  });
+  const parts = formatter.formatToParts(date);
+  const partsObj = parts.reduce(
+    (acc, part) => {
+      acc[part.type] = part.value;
+      return acc;
+    },
+    {}
+  );
+  return {
+    day: new Date(
+      parseInt(partsObj.year ?? "0"),
+      parseInt(partsObj.month ?? "1") - 1,
+      parseInt(partsObj.day ?? "1")
+    ).getDay(),
+    hour: parseInt(partsObj.hour ?? "0"),
+    minute: parseInt(partsObj.minute ?? "0"),
+    totalMinutes: parseInt(partsObj.hour ?? "0") * 60 + parseInt(partsObj.minute ?? "0")
+  };
+}
+function isTimeInWindowSlot2(date, slot, timezone) {
+  if (!slot || slot.startTime === void 0 || slot.endTime === void 0) {
+    return false;
+  }
+  const {
+    days: daysOfWeek,
+    startTime: windowStartTime,
+    endTime: windowEndTime
+  } = slot;
+  const tz = timezone ?? slot.timezone ?? "UTC";
+  const windowStartMinutes = normalizeTimeToMinutes2(windowStartTime);
+  const windowEndMinutes = normalizeTimeToMinutes2(windowEndTime);
+  const allowedDays = daysOfWeek.map((day) => {
+    return dayNameToNumber2[day.toLowerCase()] ?? parseInt(day);
+  }).filter((day) => !isNaN(day) && day >= 0 && day <= 6);
+  const tzInfo = getTimezoneInfo2(date, tz);
+  return allowedDays.includes(tzInfo.day) && tzInfo.totalMinutes >= windowStartMinutes && tzInfo.totalMinutes < windowEndMinutes;
+}
+function isTimeInPolicy(date, policy) {
+  if (!policy || !policy.windows || policy.windows.length === 0) {
+    return false;
+  }
+  for (const slot of policy.windows) {
+    const slotWithTimezone = {
+      ...slot,
+      timezone: slot.timezone ?? policy.timezone
+    };
+    if (isTimeInWindowSlot2(date, slotWithTimezone, policy.timezone)) {
+      return true;
+    }
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateWaitTime,
+  isTimeInPolicy,
+  isTimeInWindowSlot
+});

package/dist/scheduling/index.mjs

@@ -0,0 +1,305 @@
+// src/scheduling/calculateWaitTime.ts
+var dayNameToNumber = {
+  sunday: 0,
+  monday: 1,
+  tuesday: 2,
+  wednesday: 3,
+  thursday: 4,
+  friday: 5,
+  saturday: 6
+};
+function normalizeTimeToMinutes(timeStamp) {
+  if (timeStamp === void 0 || timeStamp === null) {
+    throw new Error("timeStamp is required and cannot be undefined or null");
+  }
+  if (typeof timeStamp === "number") {
+    return timeStamp * 60;
+  }
+  const minute = timeStamp.minute ?? 0;
+  const second = timeStamp.second ?? 0;
+  return timeStamp.hour * 60 + minute + Math.floor(second / 60);
+}
+function getHourFromTimeStamp(timeStamp) {
+  if (timeStamp === void 0 || timeStamp === null) {
+    throw new Error("timeStamp is required and cannot be undefined or null");
+  }
+  if (typeof timeStamp === "number") {
+    return timeStamp;
+  }
+  return timeStamp.hour;
+}
+function getMinuteFromTimeStamp(timeStamp) {
+  if (timeStamp === void 0 || timeStamp === null) {
+    throw new Error("timeStamp is required and cannot be undefined or null");
+  }
+  if (typeof timeStamp === "number") {
+    return 0;
+  }
+  return timeStamp.minute ?? 0;
+}
+function getTimezoneInfo(date, timezone) {
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  });
+  const parts = formatter.formatToParts(date);
+  const partsObj = parts.reduce(
+    (acc, part) => {
+      acc[part.type] = part.value;
+      return acc;
+    },
+    {}
+  );
+  return {
+    day: new Date(
+      parseInt(partsObj.year ?? "0"),
+      parseInt(partsObj.month ?? "1") - 1,
+      parseInt(partsObj.day ?? "1")
+    ).getDay(),
+    hour: parseInt(partsObj.hour ?? "0"),
+    minute: parseInt(partsObj.minute ?? "0"),
+    totalMinutes: parseInt(partsObj.hour ?? "0") * 60 + parseInt(partsObj.minute ?? "0")
+  };
+}
+function isTimeInWindowSlot(date, window) {
+  if (!window || window.startTime === void 0 || window.endTime === void 0) {
+    return false;
+  }
+  const {
+    days: daysOfWeek,
+    startTime: windowStartTime,
+    endTime: windowEndTime,
+    timezone
+  } = window;
+  const tz = timezone ?? "UTC";
+  const windowStartMinutes = normalizeTimeToMinutes(windowStartTime);
+  const windowEndMinutes = normalizeTimeToMinutes(windowEndTime);
+  const allowedDays = daysOfWeek.map((day) => {
+    return dayNameToNumber[day.toLowerCase()] ?? parseInt(day);
+  }).filter((day) => !isNaN(day) && day >= 0 && day <= 6);
+  const tzInfo = getTimezoneInfo(date, tz);
+  return allowedDays.includes(tzInfo.day) && tzInfo.totalMinutes >= windowStartMinutes && tzInfo.totalMinutes < windowEndMinutes;
+}
+function calculateWaitTime(step, now) {
+  const nowTime = now.getTime();
+  switch (step.mode) {
+    case "absolute": {
+      const scheduleAtTime = typeof step.scheduleAt === "string" ? new Date(step.scheduleAt).getTime() : step.scheduleAt;
+      return {
+        waitTime: Math.max(0, scheduleAtTime - nowTime),
+        scheduledAt: new Date(scheduleAtTime)
+      };
+    }
+    case "relative": {
+      if (!step.amount && (!step.windows || step.windows.length === 0)) {
+        return {
+          waitTime: 0,
+          scheduledAt: now
+        };
+      }
+      let relativeDelay = 0;
+      if (step.amount && step.unit) {
+        switch (step.unit) {
+          case "seconds":
+          case "second":
+            relativeDelay = step.amount * 1e3;
+            break;
+          case "minutes":
+          case "minute":
+            relativeDelay = step.amount * 60 * 1e3;
+            break;
+          case "hours":
+          case "hour":
+            relativeDelay = step.amount * 60 * 60 * 1e3;
+            break;
+          case "days":
+          case "day":
+            relativeDelay = step.amount * 24 * 60 * 60 * 1e3;
+            break;
+          case "weeks":
+          case "week":
+            relativeDelay = step.amount * 7 * 24 * 60 * 60 * 1e3;
+            break;
+          case "months":
+          case "month": {
+            relativeDelay = step.amount * 30 * 24 * 60 * 60 * 1e3;
+            break;
+          }
+          case "years":
+          case "year": {
+            relativeDelay = step.amount * 365 * 24 * 60 * 60 * 1e3;
+            break;
+          }
+        }
+      }
+      if (!step.windows || step.windows.length === 0) {
+        return {
+          waitTime: relativeDelay,
+          scheduledAt: new Date(nowTime + relativeDelay)
+        };
+      }
+      const targetDate = new Date(nowTime + relativeDelay);
+      for (const window of step.windows) {
+        if (isTimeInWindowSlot(targetDate, window)) {
+          return {
+            waitTime: relativeDelay,
+            scheduledAt: new Date(nowTime + relativeDelay)
+          };
+        }
+      }
+      let earliestScheduledTime = null;
+      let earliestWaitTime = Infinity;
+      for (const window of step.windows) {
+        if (!window || window.startTime === void 0 || window.endTime === void 0) {
+          continue;
+        }
+        const { days: daysOfWeek, startTime: windowStartTime, timezone } = window;
+        const tz = timezone ?? "UTC";
+        const windowStartMinutes = normalizeTimeToMinutes(windowStartTime);
+        const windowStartHour = getHourFromTimeStamp(windowStartTime);
+        const windowStartMinute = getMinuteFromTimeStamp(windowStartTime);
+        const allowedDays = daysOfWeek.map((day) => {
+          return dayNameToNumber[day.toLowerCase()] ?? parseInt(day);
+        }).filter((day) => !isNaN(day) && day >= 0 && day <= 6);
+        const targetTzInfo = getTimezoneInfo(targetDate, tz);
+        const currentDay = targetTzInfo.day;
+        const currentHour = targetTzInfo.hour;
+        const currentMinute = targetTzInfo.minute;
+        const currentTotalMinutes = targetTzInfo.totalMinutes;
+        let windowWaitTime;
+        let windowScheduledTime;
+        if (allowedDays.includes(currentDay) && currentTotalMinutes < windowStartMinutes) {
+          const minutesUntilWindow = windowStartMinutes - currentTotalMinutes;
+          windowWaitTime = minutesUntilWindow * 60 * 1e3;
+          windowScheduledTime = new Date(targetDate.getTime() + windowWaitTime);
+        } else {
+          let daysToAdd = 7;
+          for (let i = 1; i <= 7; i++) {
+            const nextDay = (currentDay + i) % 7;
+            if (allowedDays.includes(nextDay)) {
+              daysToAdd = i;
+              break;
+            }
+          }
+          const millisecondsPerDay = 24 * 60 * 60 * 1e3;
+          const millisecondsPerHour = 60 * 60 * 1e3;
+          const millisecondsPerMinute = 60 * 1e3;
+          const daysMs = daysToAdd * millisecondsPerDay;
+          const hoursAdjustment = (windowStartHour - currentHour) * millisecondsPerHour;
+          const minutesAdjustment = (windowStartMinute - currentMinute) * millisecondsPerMinute;
+          windowWaitTime = daysMs + hoursAdjustment + minutesAdjustment;
+          windowScheduledTime = new Date(targetDate.getTime() + windowWaitTime);
+        }
+        if (windowWaitTime < earliestWaitTime) {
+          earliestWaitTime = windowWaitTime;
+          earliestScheduledTime = windowScheduledTime;
+        }
+      }
+      if (earliestScheduledTime) {
+        return {
+          waitTime: relativeDelay + earliestWaitTime,
+          scheduledAt: earliestScheduledTime
+        };
+      }
+      throw new Error("No valid time windows found for scheduling");
+    }
+    default:
+      throw new Error(`Unsupported wait mode: ${step.mode}`);
+  }
+}
+
+// src/scheduling/isTimeInWindow.ts
+var dayNameToNumber2 = {
+  sunday: 0,
+  monday: 1,
+  tuesday: 2,
+  wednesday: 3,
+  thursday: 4,
+  friday: 5,
+  saturday: 6
+};
+function normalizeTimeToMinutes2(timeStamp) {
+  if (timeStamp === void 0 || timeStamp === null) {
+    throw new Error("timeStamp is required and cannot be undefined or null");
+  }
+  if (typeof timeStamp === "number") {
+    return timeStamp * 60;
+  }
+  const minute = timeStamp.minute ?? 0;
+  const second = timeStamp.second ?? 0;
+  return timeStamp.hour * 60 + minute + Math.floor(second / 60);
+}
+function getTimezoneInfo2(date, timezone) {
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  });
+  const parts = formatter.formatToParts(date);
+  const partsObj = parts.reduce(
+    (acc, part) => {
+      acc[part.type] = part.value;
+      return acc;
+    },
+    {}
+  );
+  return {
+    day: new Date(
+      parseInt(partsObj.year ?? "0"),
+      parseInt(partsObj.month ?? "1") - 1,
+      parseInt(partsObj.day ?? "1")
+    ).getDay(),
+    hour: parseInt(partsObj.hour ?? "0"),
+    minute: parseInt(partsObj.minute ?? "0"),
+    totalMinutes: parseInt(partsObj.hour ?? "0") * 60 + parseInt(partsObj.minute ?? "0")
+  };
+}
+function isTimeInWindowSlot2(date, slot, timezone) {
+  if (!slot || slot.startTime === void 0 || slot.endTime === void 0) {
+    return false;
+  }
+  const {
+    days: daysOfWeek,
+    startTime: windowStartTime,
+    endTime: windowEndTime
+  } = slot;
+  const tz = timezone ?? slot.timezone ?? "UTC";
+  const windowStartMinutes = normalizeTimeToMinutes2(windowStartTime);
+  const windowEndMinutes = normalizeTimeToMinutes2(windowEndTime);
+  const allowedDays = daysOfWeek.map((day) => {
+    return dayNameToNumber2[day.toLowerCase()] ?? parseInt(day);
+  }).filter((day) => !isNaN(day) && day >= 0 && day <= 6);
+  const tzInfo = getTimezoneInfo2(date, tz);
+  return allowedDays.includes(tzInfo.day) && tzInfo.totalMinutes >= windowStartMinutes && tzInfo.totalMinutes < windowEndMinutes;
+}
+function isTimeInPolicy(date, policy) {
+  if (!policy || !policy.windows || policy.windows.length === 0) {
+    return false;
+  }
+  for (const slot of policy.windows) {
+    const slotWithTimezone = {
+      ...slot,
+      timezone: slot.timezone ?? policy.timezone
+    };
+    if (isTimeInWindowSlot2(date, slotWithTimezone, policy.timezone)) {
+      return true;
+    }
+  }
+  return false;
+}
+export {
+  calculateWaitTime,
+  isTimeInPolicy,
+  isTimeInWindowSlot2 as isTimeInWindowSlot
+};

package/dist/scheduling/isTimeInWindow.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Time Window Detection
+ *
+ * Helper functions to check if a given time falls within a time window policy.
+ * Used for detecting the current time context (business hours, after hours, etc.)
+ */
+import type { TimeWindowSlot, TimeWindowPolicy } from './types-workflow';
+/**
+ * Check if a date falls within a specific time window slot
+ */
+export declare function isTimeInWindowSlot(date: Date, slot: TimeWindowSlot, timezone?: string): boolean;
+/**
+ * Check if a date falls within any slot of a time window policy
+ */
+export declare function isTimeInPolicy(date: Date, policy: TimeWindowPolicy): boolean;