scschedule 2.1.1 → 3.1.0

package/dist/getNextAvailableFromSchedule.js

@@ -7,6 +7,7 @@ import { isScheduleAvailable } from './isScheduleAvailable.js';
  *
  * This function searches forward from the given timestamp to find when the
  * schedule next becomes available. It handles:
+ * - Always-available days (`weekly: true` or `rules: true` from an override)
  * - Same-day availability (finding the next time range on the current day)
  * - Cross-midnight spillover (ranges that extend past midnight are detected
  *   via isScheduleAvailable)
@@ -16,8 +17,9 @@ import { isScheduleAvailable } from './isScheduleAvailable.js';
  * The algorithm works by:
  * 1. Checking if fromTimestamp is already available (including spillover from
  *    the previous day's cross-midnight ranges)
- * 2. If not, finding the earliest time range start on the current day that
- *    occurs after fromTimestamp
+ * 2. If not, iterating day-by-day:
+ *    - If rules are `true`, the entire day is available (returns 00:00)
+ *    - Otherwise, finding the earliest time range start after fromTimestamp
  * 3. If no ranges found on current day, moving to the next day and repeating
  *
  * Note: Spillover ranges don't need explicit tracking because:
@@ -27,12 +29,11 @@ import { isScheduleAvailable } from './isScheduleAvailable.js';
  * - The "next available" time is always a time range start, never a spillover
  *   timestamp
  *
- * @param schedule - The schedule to check availability against
- * @param fromTimestamp - The starting timestamp to search from
- * @param maxDaysToSearch - Maximum number of days to search forward (default:
- *   365)
+ * @param schedule The schedule to check availability against.
+ * @param fromTimestamp The starting timestamp to search from.
+ * @param maxDaysToSearch Maximum number of days to search forward.
  * @returns The next available timestamp, or undefined if none found within
- *   the search window
+ *   the search window.
  *
  * @example
  * // Schedule: Mon-Fri 09:00-17:00
@@ -53,7 +54,7 @@ import { isScheduleAvailable } from './isScheduleAvailable.js';
  * // Custom search window: only search 30 days ahead
  * getNextAvailableFromSchedule(schedule, timestamp, 30)
  */
-export const getNextAvailableFromSchedule = (schedule, fromTimestamp, maxDaysToSearch = 365) => {
+export const getNextAvailableFromSchedule = (schedule, fromTimestamp, maxDaysToSearch) => {
     const initialTimestamp = sTimestamp(fromTimestamp);
     // Check if already available at fromTimestamp (handles spillover too)
     if (isScheduleAvailable(schedule, initialTimestamp)) {
@@ -65,21 +66,24 @@ export const getNextAvailableFromSchedule = (schedule, fromTimestamp, maxDaysToS
     for (let day = 0; day < maxDaysToSearch; day++) {
         const weekday = getWeekdayFromDate(currentDate);
         const { rules } = getApplicableRuleForDate(schedule, currentDate.date);
+        // If rules are true, the entire day is available. This only happens on
+        // day 1+ because on day 0, isScheduleAvailable would have returned true.
+        if (rules === true) {
+            return getTimestampFromDateAndTime(currentDate, '00:00');
+        }
         // Track earliest time
         let earliestTime;
         for (const rule of rules) {
             if (!doesWeekdaysIncludeWeekday(rule.weekdays, weekday)) {
                 continue;
             }
-            for (const timeRange of rule.times) {
-                // Day 0: only consider ranges starting after fromTimestamp's time
-                // Day 1+: consider all ranges (any start time qualifies)
-                if (day === 0 && !isAfterTime(timeRange.from, fromTime)) {
-                    continue;
-                }
-                if (!earliestTime || isBeforeTime(timeRange.from, earliestTime)) {
-                    earliestTime = timeRange.from;
-                }
+            // Day 0: only consider ranges starting after fromTimestamp's time
+            // Day 1+: consider all ranges (any start time qualifies)
+            if (day === 0 && !isAfterTime(rule.from, fromTime)) {
+                continue;
+            }
+            if (!earliestTime || isBeforeTime(rule.from, earliestTime)) {
+                earliestTime = rule.from;
             }
         }
         if (earliestTime) {

package/dist/getNextUnavailableFromSchedule.d.ts

@@ -6,25 +6,30 @@ import type { Schedule } from './types.js';
  *
  * This function searches forward from the given timestamp to find when the
  * schedule next becomes unavailable. It handles:
+ * - Always-available schedules (`weekly: true`) by searching for overrides
  * - Same-day unavailability (gaps between time ranges or after the last range)
  * - Cross-midnight ranges (unavailability after a range that crosses midnight)
  * - Date overrides (temporary closures)
  *
  * The algorithm works by:
  * 1. Checking if fromTimestamp is already unavailable
- * 2. Collecting all potential "end of availability" candidates from:
+ * 2. If `weekly` is `true`, searching forward day-by-day for an override that
+ *    closes availability
+ * 3. Otherwise, collecting all potential "end of availability" candidates from:
  *    - Previous day's cross-midnight spillover (ends today at `to` time)
  *    - Current day's regular ranges (end today at `to` time)
  *    - Current day's cross-midnight ranges (end tomorrow at `to` time)
- * 3. Sorting candidates and returning the earliest one that's unavailable
+ * 4. Sorting candidates and returning the earliest one that's unavailable
  *
- * Note: No day-by-day iteration is needed because if we're available, we must
- * be in some range, and that range ends within at most 24 hours (or ~48 hours
- * for cross-midnight ranges).
+ * Note: For rule-based schedules, no day-by-day iteration is needed because if
+ * available, the current range ends within at most ~48 hours (cross-midnight).
  *
- * @param schedule - The schedule to check availability against
- * @param fromTimestamp - The starting timestamp to search from
- * @returns The next unavailable timestamp, or undefined if always available
+ * @param schedule The schedule to check availability against.
+ * @param timeZone IANA time zone identifier for timestamp arithmetic.
+ * @param fromTimestamp The starting timestamp to search from.
+ * @param maxDaysToSearch Maximum number of days to search forward.
+ * @returns The next unavailable timestamp, or undefined if no unavailability
+ *   is found within the search window.
  *
  * @example
  * // Schedule: Mon-Fri 09:00-17:00
@@ -40,5 +45,10 @@ import type { Schedule } from './types.js';
  * // Schedule: Thu-Sat 20:00-02:00 (cross-midnight)
  * // Query: Thursday at 23:00
  * // Returns: Friday at 02:01 (after shift ends)
+ *
+ * @example
+ * // Schedule: weekly: true, override closing Dec 25
+ * // Query: Dec 20 at 10:00
+ * // Returns: Dec 25 at 00:00
  */
-export declare const getNextUnavailableFromSchedule: (schedule: Schedule, fromTimestamp: STimestamp | string) => STimestamp | undefined;
+export declare const getNextUnavailableFromSchedule: (schedule: Schedule, timeZone: string, fromTimestamp: STimestamp | string, maxDaysToSearch: number) => STimestamp | undefined;

package/dist/getNextUnavailableFromSchedule.js

@@ -1,31 +1,107 @@
 import { addDaysToDate, addMinutesToTimestamp, doesWeekdaysIncludeWeekday, getDateFromTimestamp, getTimeFromTimestamp, getTimestampFromDateAndTime, getWeekdayFromDate, isAfterTime, isBeforeTimestamp, isSameTimeOrAfter, sTimestamp, } from 'scdate';
 import { getApplicableRuleForDate } from './internal/getApplicableRuleForDate.js';
 import { isScheduleAvailable } from './isScheduleAvailable.js';
+/**
+ * Collects "range end + 1 minute" candidate timestamps for a given date's
+ * rules. For cross-midnight ranges, the candidate falls on the next day.
+ * When afterTime is provided, regular (non-cross-midnight) ranges ending
+ * before afterTime are excluded.
+ */
+const collectRangeEndCandidates = (rules, date, timeZone, afterTime) => {
+    const candidates = [];
+    const weekday = getWeekdayFromDate(date);
+    for (const rule of rules) {
+        if (!doesWeekdaysIncludeWeekday(rule.weekdays, weekday)) {
+            continue;
+        }
+        if (isAfterTime(rule.from, rule.to)) {
+            // Cross-midnight range ends tomorrow
+            const tomorrow = addDaysToDate(date, 1);
+            const rangeEnd = getTimestampFromDateAndTime(tomorrow, rule.to);
+            candidates.push(addMinutesToTimestamp(rangeEnd, 1, timeZone));
+        }
+        else {
+            if (afterTime && !isSameTimeOrAfter(rule.to, afterTime)) {
+                continue;
+            }
+            const rangeEnd = getTimestampFromDateAndTime(date, rule.to);
+            candidates.push(addMinutesToTimestamp(rangeEnd, 1, timeZone));
+        }
+    }
+    return candidates;
+};
+/**
+ * Collects candidate timestamps from the previous day's cross-midnight ranges
+ * that spill into the current date. Only includes spillover endings at or
+ * after afterTime.
+ */
+const collectSpilloverCandidates = (schedule, currentDate, timeZone, afterTime) => {
+    const candidates = [];
+    const previousDate = addDaysToDate(currentDate, -1);
+    const previousWeekday = getWeekdayFromDate(previousDate);
+    const previousResult = getApplicableRuleForDate(schedule, previousDate.date);
+    if (previousResult.rules === true) {
+        return candidates;
+    }
+    for (const rule of previousResult.rules) {
+        if (!doesWeekdaysIncludeWeekday(rule.weekdays, previousWeekday)) {
+            continue;
+        }
+        // Only cross-midnight ranges (from > to) spill into today
+        if (!isAfterTime(rule.from, rule.to)) {
+            continue;
+        }
+        if (!isSameTimeOrAfter(rule.to, afterTime)) {
+            continue;
+        }
+        const rangeEnd = getTimestampFromDateAndTime(currentDate, rule.to);
+        candidates.push(addMinutesToTimestamp(rangeEnd, 1, timeZone));
+    }
+    return candidates;
+};
+/**
+ * Sorts timestamps chronologically and returns the first one where the
+ * schedule is unavailable, or undefined if all are available.
+ */
+const findFirstUnavailableTimestamp = (schedule, candidates) => {
+    candidates.sort((a, b) => (isBeforeTimestamp(a, b) ? -1 : 1));
+    for (const candidate of candidates) {
+        if (!isScheduleAvailable(schedule, candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+};
 /**
  * Finds the next unavailable timestamp in a schedule starting from the
  * specified timestamp.
  *
  * This function searches forward from the given timestamp to find when the
  * schedule next becomes unavailable. It handles:
+ * - Always-available schedules (`weekly: true`) by searching for overrides
  * - Same-day unavailability (gaps between time ranges or after the last range)
  * - Cross-midnight ranges (unavailability after a range that crosses midnight)
  * - Date overrides (temporary closures)
  *
  * The algorithm works by:
  * 1. Checking if fromTimestamp is already unavailable
- * 2. Collecting all potential "end of availability" candidates from:
+ * 2. If `weekly` is `true`, searching forward day-by-day for an override that
+ *    closes availability
+ * 3. Otherwise, collecting all potential "end of availability" candidates from:
  *    - Previous day's cross-midnight spillover (ends today at `to` time)
  *    - Current day's regular ranges (end today at `to` time)
  *    - Current day's cross-midnight ranges (end tomorrow at `to` time)
- * 3. Sorting candidates and returning the earliest one that's unavailable
+ * 4. Sorting candidates and returning the earliest one that's unavailable
  *
- * Note: No day-by-day iteration is needed because if we're available, we must
- * be in some range, and that range ends within at most 24 hours (or ~48 hours
- * for cross-midnight ranges).
+ * Note: For rule-based schedules, no day-by-day iteration is needed because if
+ * available, the current range ends within at most ~48 hours (cross-midnight).
  *
- * @param schedule - The schedule to check availability against
- * @param fromTimestamp - The starting timestamp to search from
- * @returns The next unavailable timestamp, or undefined if always available
+ * @param schedule The schedule to check availability against.
+ * @param timeZone IANA time zone identifier for timestamp arithmetic.
+ * @param fromTimestamp The starting timestamp to search from.
+ * @param maxDaysToSearch Maximum number of days to search forward.
+ * @returns The next unavailable timestamp, or undefined if no unavailability
+ *   is found within the search window.
  *
  * @example
  * // Schedule: Mon-Fri 09:00-17:00
@@ -41,8 +117,13 @@ import { isScheduleAvailable } from './isScheduleAvailable.js';
  * // Schedule: Thu-Sat 20:00-02:00 (cross-midnight)
  * // Query: Thursday at 23:00
  * // Returns: Friday at 02:01 (after shift ends)
+ *
+ * @example
+ * // Schedule: weekly: true, override closing Dec 25
+ * // Query: Dec 20 at 10:00
+ * // Returns: Dec 25 at 00:00
  */
-export const getNextUnavailableFromSchedule = (schedule, fromTimestamp) => {
+export const getNextUnavailableFromSchedule = (schedule, timeZone, fromTimestamp, maxDaysToSearch) => {
     const initialTimestamp = sTimestamp(fromTimestamp);
     // Check if already unavailable at fromTimestamp
     if (!isScheduleAvailable(schedule, initialTimestamp)) {
@@ -50,63 +131,39 @@ export const getNextUnavailableFromSchedule = (schedule, fromTimestamp) => {
     }
     const currentDate = getDateFromTimestamp(initialTimestamp);
     const fromTime = getTimeFromTimestamp(initialTimestamp);
-    // Collect all candidate "end + 1 minute" timestamps
-    const candidates = [];
-    // 1. Check previous day's cross-midnight spillover into today
-    const previousDate = addDaysToDate(currentDate, -1);
-    const previousWeekday = getWeekdayFromDate(previousDate);
-    const { rules: previousRules } = getApplicableRuleForDate(schedule, previousDate.date);
-    for (const rule of previousRules) {
-        if (!doesWeekdaysIncludeWeekday(rule.weekdays, previousWeekday)) {
-            continue;
-        }
-        for (const timeRange of rule.times) {
-            // Cross-midnight range (from > to) spills into today
-            if (!isAfterTime(timeRange.from, timeRange.to)) {
-                continue;
-            }
-            // Spillover ends today at timeRange.to
-            // Only consider if end is at or after current time
-            if (!isSameTimeOrAfter(timeRange.to, fromTime)) {
-                continue;
-            }
-            const rangeEnd = getTimestampFromDateAndTime(currentDate, timeRange.to);
-            const afterRangeEnd = addMinutesToTimestamp(rangeEnd, 1, schedule.timezone);
-            candidates.push(afterRangeEnd);
-        }
-    }
-    // 2. Check current day's ranges
-    const weekday = getWeekdayFromDate(currentDate);
-    const { rules } = getApplicableRuleForDate(schedule, currentDate.date);
-    for (const rule of rules) {
-        if (!doesWeekdaysIncludeWeekday(rule.weekdays, weekday)) {
-            continue;
-        }
-        for (const timeRange of rule.times) {
-            // Cross-midnight range (from > to) ends TOMORROW
-            if (isAfterTime(timeRange.from, timeRange.to)) {
-                const tomorrow = addDaysToDate(currentDate, 1);
-                const rangeEnd = getTimestampFromDateAndTime(tomorrow, timeRange.to);
-                const afterRangeEnd = addMinutesToTimestamp(rangeEnd, 1, schedule.timezone);
-                candidates.push(afterRangeEnd);
-            }
-            else {
-                // Regular range ends today - only consider if end >= current time
-                if (!isSameTimeOrAfter(timeRange.to, fromTime)) {
-                    continue;
+    // When weekly is true (always available), search forward for an override
+    // that closes availability.
+    const initialResult = getApplicableRuleForDate(schedule, currentDate.date);
+    if (initialResult.rules === true) {
+        // rules === true implies source === 'weekly', so skip current date
+        // and start searching from the next day.
+        let searchDate = addDaysToDate(currentDate, 1);
+        for (let day = 1; day < maxDaysToSearch; day++) {
+            const result = getApplicableRuleForDate(schedule, searchDate.date);
+            // If we are here it means that weekly is true, so we need to search for
+            // an override that closes availability.
+            if (result.source === 'override') {
+                const dayStart = getTimestampFromDateAndTime(searchDate, '00:00');
+                const nextUnavailable = findFirstUnavailableTimestamp(schedule, [
+                    dayStart,
+                    ...collectRangeEndCandidates(result.rules, searchDate, timeZone),
+                ]);
+                if (nextUnavailable) {
+                    return nextUnavailable;
                 }
-                const rangeEnd = getTimestampFromDateAndTime(currentDate, timeRange.to);
-                const afterRangeEnd = addMinutesToTimestamp(rangeEnd, 1, schedule.timezone);
-                candidates.push(afterRangeEnd);
             }
+            searchDate = addDaysToDate(searchDate, 1);
         }
+        return undefined;
     }
-    // Sort candidates chronologically and find first that's actually unavailable
-    candidates.sort((a, b) => (isBeforeTimestamp(a, b) ? -1 : 1));
-    for (const candidate of candidates) {
-        if (!isScheduleAvailable(schedule, candidate)) {
-            return candidate;
-        }
+    // Collect candidates from previous day's cross-midnight spillover and
+    // current day's ranges, then return the earliest unavailable one.
+    const { rules } = getApplicableRuleForDate(schedule, currentDate.date);
+    if (rules === true) {
+        return undefined;
     }
-    return undefined;
+    return findFirstUnavailableTimestamp(schedule, [
+        ...collectSpilloverCandidates(schedule, currentDate, timeZone, fromTime),
+        ...collectRangeEndCandidates(rules, currentDate, timeZone, fromTime),
+    ]);
 };

package/dist/index.d.ts

@@ -1,9 +1,10 @@
+export { isValidTimeZone } from 'scdate';
 export type { SDate, STime, STimestamp, SWeekdays } from 'scdate';
 export * from './constants.js';
 export type * from './types.js';
 export * from './validateSchedule.js';
 export * from './cleanupExpiredOverridesFromSchedule.js';
-export * from './isScheduleAvailable.js';
+export * from './getAvailableRangesFromSchedule.js';
 export * from './getNextAvailableFromSchedule.js';
 export * from './getNextUnavailableFromSchedule.js';
-export * from './getAvailableRangesFromSchedule.js';
+export * from './isScheduleAvailable.js';

package/dist/index.js

@@ -1,3 +1,5 @@
+// Re-export scdate types and utilities for convenience
+export { isValidTimeZone } from 'scdate';
 // Export constants
 export * from './constants.js';
 // Export validation functions
@@ -5,7 +7,7 @@ export * from './validateSchedule.js';
 // Export schedule management functions
 export * from './cleanupExpiredOverridesFromSchedule.js';
 // Export availability query functions
-export * from './isScheduleAvailable.js';
+export * from './getAvailableRangesFromSchedule.js';
 export * from './getNextAvailableFromSchedule.js';
 export * from './getNextUnavailableFromSchedule.js';
-export * from './getAvailableRangesFromSchedule.js';
+export * from './isScheduleAvailable.js';

package/dist/internal/doTimeRangesOverlap.d.ts

@@ -1,4 +1,4 @@
-import type { TimeRange } from '../types.js';
+import type { TimeRange } from './types.js';
 /**
  * Checks if two time ranges overlap when both start on the same day.
  *

package/dist/internal/getApplicableRuleForDate.d.ts

@@ -1,24 +1,24 @@
 import { SDate } from 'scdate';
 import type { Schedule, SDateString, WeeklyScheduleRule } from '../types.js';
-export type RuleSource = {
-    type: 'weekly';
+export type ApplicableRule = {
+    source: 'weekly';
+    rules: WeeklyScheduleRule[] | true;
 } | {
-    type: 'override';
+    source: 'override';
     overrideIndex: number;
-};
-export interface RuleWithSource {
     rules: WeeklyScheduleRule[];
-    source: RuleSource;
-}
+};
 /**
  * Determines which rules apply for a given date based on overrides or weekly
- * schedule, and returns the source information (weekly vs which override
- * index). When multiple overrides apply, selects the most specific (shortest)
- * duration).
+ * schedule. Returns a discriminated union indicating the source (`'weekly'` or
+ * `'override'`) and the applicable rules. When the source is `'weekly'` and
+ * the schedule has `weekly: true`, the returned `rules` will be `true`.
+ *
+ * When multiple overrides apply, selects the most specific (shortest duration).
  *
  * Priority:
  * 1. Specific overrides (with 'to' date) - shortest duration wins
  * 2. Indefinite overrides (no 'to' date) - latest 'from' date wins
  * 3. Weekly schedule (fallback)
  */
-export declare const getApplicableRuleForDate: (schedule: Schedule, date: SDate | SDateString) => RuleWithSource;
+export declare const getApplicableRuleForDate: (schedule: Schedule, date: SDate | SDateString) => ApplicableRule;

package/dist/internal/getApplicableRuleForDate.js

@@ -1,9 +1,11 @@
 import { getDaysBetweenDates, isSameDateOrAfter, isSameDateOrBefore, } from 'scdate';
 /**
  * Determines which rules apply for a given date based on overrides or weekly
- * schedule, and returns the source information (weekly vs which override
- * index). When multiple overrides apply, selects the most specific (shortest)
- * duration).
+ * schedule. Returns a discriminated union indicating the source (`'weekly'` or
+ * `'override'`) and the applicable rules. When the source is `'weekly'` and
+ * the schedule has `weekly: true`, the returned `rules` will be `true`.
+ *
+ * When multiple overrides apply, selects the most specific (shortest duration).
  *
  * Priority:
  * 1. Specific overrides (with 'to' date) - shortest duration wins
@@ -15,8 +17,8 @@ export const getApplicableRuleForDate = (schedule, date) => {
     // schedule)
     if (!schedule.overrides || schedule.overrides.length === 0) {
         return {
+            source: 'weekly',
             rules: schedule.weekly,
-            source: { type: 'weekly' },
         };
     }
     // - Check the case where there are overrides and collect all specific
@@ -48,8 +50,9 @@ export const getApplicableRuleForDate = (schedule, date) => {
             return currentDuration < shortestDuration ? current : shortest;
         });
         return {
+            source: 'override',
+            overrideIndex: mostSpecific.index,
             rules: mostSpecific.override.rules,
-            source: { type: 'override', overrideIndex: mostSpecific.index },
         };
     }
     // - At this point, we know there are no applicable overrides with from and
@@ -70,13 +73,14 @@ export const getApplicableRuleForDate = (schedule, date) => {
                 : latest;
         });
         return {
+            source: 'override',
+            overrideIndex: mostRecent.index,
             rules: mostRecent.override.rules,
-            source: { type: 'override', overrideIndex: mostRecent.index },
         };
     }
     // - If there are no applicable indefinite overrides, return the weekly rules
     return {
+        source: 'weekly',
         rules: schedule.weekly,
-        source: { type: 'weekly' },
     };
 };

package/dist/internal/getEffectiveTimesForWeekday.d.ts

@@ -1,5 +1,6 @@
 import { Weekday } from 'scdate';
-import type { TimeRange, WeeklyScheduleRule } from '../types.js';
+import type { WeeklyScheduleRule } from '../types.js';
+import type { TimeRange } from './types.js';
 /**
  * Gets the effective time ranges that apply to a specific weekday for a given
  * rule, accounting for both direct ranges and cross-midnight spillover from

package/dist/internal/getEffectiveTimesForWeekday.js

@@ -14,13 +14,10 @@ export const getEffectiveTimesForWeekday = (rule, weekday) => {
     const previousWeekday = getPreviousWeekday(weekday);
     // Check if this weekday is directly included in the rule's weekdays
     if (doesWeekdaysIncludeWeekday(rule.weekdays, weekday)) {
-        // Add all time ranges for this weekday
-        rule.times.forEach((timeRange) => {
-            const splitRanges = splitCrossMidnightTimeRange(timeRange);
-            if (splitRanges.length > 0 && splitRanges[0]) {
-                effectiveTimes.push(splitRanges[0]);
-            }
-        });
+        const splitRanges = splitCrossMidnightTimeRange(rule);
+        if (splitRanges.length > 0 && splitRanges[0]) {
+            effectiveTimes.push(splitRanges[0]);
+        }
     }
     // Check if previous weekday has cross-midnight ranges that spill into this
     // weekday.
@@ -30,13 +27,11 @@ export const getEffectiveTimesForWeekday = (rule, weekday) => {
     // only those that occur in the date range. This ensures spillover is only
     // included from days that actually exist in the override period.
     if (doesWeekdaysIncludeWeekday(rule.weekdays, previousWeekday)) {
-        rule.times.forEach((timeRange) => {
-            const splitRanges = splitCrossMidnightTimeRange(timeRange);
-            // If there are 2 ranges, the second one is the spillover to next day
-            if (splitRanges.length === 2 && splitRanges[1]) {
-                effectiveTimes.push(splitRanges[1]);
-            }
-        });
+        const splitRanges = splitCrossMidnightTimeRange(rule);
+        // If there are 2 ranges, the second one is the spillover to next day
+        if (splitRanges.length === 2 && splitRanges[1]) {
+            effectiveTimes.push(splitRanges[1]);
+        }
     }
     return effectiveTimes;
 };

package/dist/internal/index.d.ts

@@ -1,19 +1,16 @@
+export type * from './types.js';
 export * from './doOverridesOverlap.js';
 export * from './doRulesOverlap.js';
 export * from './doTimeRangesOverlap.js';
 export * from './getApplicableRuleForDate.js';
 export * from './getEffectiveTimesForWeekday.js';
 export * from './isTimeInTimeRange.js';
-export * from './isValidTimezone.js';
 export * from './normalizeScheduleForValidation.js';
 export * from './splitCrossMidnightTimeRange.js';
 export * from './validateNoEmptyWeekdays.js';
 export * from './validateNoOverlappingOverrides.js';
 export * from './validateNoOverlappingRules.js';
-export * from './validateNoOverlappingTimesInRule.js';
 export * from './validateNoSpilloverConflictsAtOverrideBoundaries.js';
-export * from './validateNonEmptyTimes.js';
 export * from './validateOverrideDateOrder.js';
 export * from './validateOverrideWeekdaysMatchDates.js';
 export * from './validateScDateFormats.js';
-export * from './validateTimezone.js';

package/dist/internal/index.js

@@ -5,17 +5,13 @@ export * from './doTimeRangesOverlap.js';
 export * from './getApplicableRuleForDate.js';
 export * from './getEffectiveTimesForWeekday.js';
 export * from './isTimeInTimeRange.js';
-export * from './isValidTimezone.js';
 export * from './normalizeScheduleForValidation.js';
 export * from './splitCrossMidnightTimeRange.js';
 // Internal validation helpers
 export * from './validateNoEmptyWeekdays.js';
 export * from './validateNoOverlappingOverrides.js';
 export * from './validateNoOverlappingRules.js';
-export * from './validateNoOverlappingTimesInRule.js';
 export * from './validateNoSpilloverConflictsAtOverrideBoundaries.js';
-export * from './validateNonEmptyTimes.js';
 export * from './validateOverrideDateOrder.js';
 export * from './validateOverrideWeekdaysMatchDates.js';
 export * from './validateScDateFormats.js';
-export * from './validateTimezone.js';

package/dist/internal/isTimeInTimeRange.d.ts

@@ -1,5 +1,6 @@
 import { type STime } from 'scdate';
-import type { STimeString, TimeRange } from '../types.js';
+import type { STimeString } from '../types.js';
+import type { TimeRange } from './types.js';
 /**
  * Checks if a time falls within a time range, with support for
  * cross-midnight ranges (next-day portion).

package/dist/internal/splitCrossMidnightTimeRange.d.ts

@@ -1,4 +1,4 @@
-import type { TimeRange } from '../types.js';
+import type { TimeRange } from './types.js';
 /**
  * Splits a time range that crosses midnight into two same-day ranges.
  */

package/dist/internal/splitCrossMidnightTimeRange.js

@@ -5,8 +5,9 @@ import { isAfterTime, sTime } from 'scdate';
 export const splitCrossMidnightTimeRange = (timeRange) => {
     // Check if range crosses midnight
     if (isAfterTime(timeRange.to, timeRange.from)) {
-        // Same day range
-        return [timeRange];
+        // Same day range — construct a new object to strip extra fields (e.g.,
+        // weekdays) when callers pass a WeeklyScheduleRule as a TimeRange.
+        return [{ from: timeRange.from, to: timeRange.to }];
     }
     // Cross-midnight range: split into two periods
     return [

package/dist/internal/types.d.ts

@@ -0,0 +1,13 @@
+import type { STime } from 'scdate';
+import type { STimeString } from '../types.js';
+/**
+ * Represents a time range within a day. Time ranges can cross midnight. For
+ * example, a range from 20:00 to 02:00 represents 8:00 PM to 2:00 AM the next
+ * day.
+ */
+export interface TimeRange {
+    /** Start time of the range (inclusive) */
+    from: STime | STimeString;
+    /** End time of the range (inclusive) */
+    to: STime | STimeString;
+}

package/dist/internal/types.js

@@ -0,0 +1 @@
+export {};

package/dist/internal/validateNoEmptyWeekdays.js

@@ -8,7 +8,8 @@ import { RuleLocationType, ValidationIssue } from '../constants.js';
 export const validateNoEmptyWeekdays = (schedule) => {
     const errors = [];
     // Check weekly rules
-    schedule.weekly.forEach((rule, ruleIndex) => {
+    const weeklyRules = schedule.weekly === true ? [] : schedule.weekly;
+    weeklyRules.forEach((rule, ruleIndex) => {
         try {
             if (isWeekdaysEmpty(rule.weekdays)) {
                 errors.push({