scschedule 2.1.1 → 3.0.0

package/dist/getNextUnavailableFromSchedule.js

@@ -1,31 +1,111 @@
 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;
+        }
+        for (const timeRange of rule.times) {
+            if (isAfterTime(timeRange.from, timeRange.to)) {
+                // Cross-midnight range ends tomorrow
+                const tomorrow = addDaysToDate(date, 1);
+                const rangeEnd = getTimestampFromDateAndTime(tomorrow, timeRange.to);
+                candidates.push(addMinutesToTimestamp(rangeEnd, 1, timeZone));
+            }
+            else {
+                if (afterTime && !isSameTimeOrAfter(timeRange.to, afterTime)) {
+                    continue;
+                }
+                const rangeEnd = getTimestampFromDateAndTime(date, timeRange.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;
+        }
+        for (const timeRange of rule.times) {
+            // Only cross-midnight ranges (from > to) spill into today
+            if (!isAfterTime(timeRange.from, timeRange.to)) {
+                continue;
+            }
+            if (!isSameTimeOrAfter(timeRange.to, afterTime)) {
+                continue;
+            }
+            const rangeEnd = getTimestampFromDateAndTime(currentDate, timeRange.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 +121,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 +135,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/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/index.d.ts

@@ -4,16 +4,14 @@ 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 './validateNonEmptyTimes.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,15 @@ 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 './validateNonEmptyTimes.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/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({

package/dist/internal/validateNoOverlappingRules.js

@@ -14,10 +14,11 @@ import { doRulesOverlap } from './doRulesOverlap.js';
 export const validateNoOverlappingRules = (schedule) => {
     const errors = [];
     // Check weekly rules for overlaps
-    for (let i = 0; i < schedule.weekly.length; i++) {
-        for (let j = i + 1; j < schedule.weekly.length; j++) {
-            const rule1 = schedule.weekly[i];
-            const rule2 = schedule.weekly[j];
+    const weeklyRules = schedule.weekly === true ? [] : schedule.weekly;
+    for (let i = 0; i < weeklyRules.length; i++) {
+        for (let j = i + 1; j < weeklyRules.length; j++) {
+            const rule1 = weeklyRules[i];
+            const rule2 = weeklyRules[j];
             if (rule1 && rule2) {
                 const overlapWeekday = doRulesOverlap(rule1, rule2);
                 if (overlapWeekday !== undefined) {

package/dist/internal/validateNoOverlappingTimesInRule.js

@@ -32,7 +32,8 @@ const validateRuleTimes = (rule, location) => {
 export const validateNoOverlappingTimesInRule = (schedule) => {
     const errors = [];
     // Validate weekly rules
-    schedule.weekly.forEach((rule, ruleIndex) => {
+    const weeklyRules = schedule.weekly === true ? [] : schedule.weekly;
+    weeklyRules.forEach((rule, ruleIndex) => {
         const ruleErrors = validateRuleTimes(rule, {
             type: RuleLocationType.Weekly,
             ruleIndex,

package/dist/internal/validateNoSpilloverConflictsAtOverrideBoundaries.d.ts

@@ -3,9 +3,11 @@ import type { Schedule, ValidationError } from '../types.js';
  * Validates that cross-midnight spillover at override boundaries doesn't
  * create overlapping time ranges. Checks:
  * 1. Spillover into override first day (from weekly or previous override)
- * 2. Override last day spillover into next day (weekly or another override)
+ * 2. Override last day spillover into next day (weekly, weekly: true, or
+ *    another override)
  *
  * Note: Spillover into empty/closed days is allowed (adds availability).
- * Only spillover that OVERLAPS with explicit time ranges is flagged as error.
+ * Spillover that overlaps with explicit time ranges OR into weekly: true
+ * days (which are fully available) is flagged as an error.
  */
 export declare const validateNoSpilloverConflictsAtOverrideBoundaries: (schedule: Schedule) => ValidationError[];

package/dist/internal/validateNoSpilloverConflictsAtOverrideBoundaries.js

@@ -7,10 +7,12 @@ import { splitCrossMidnightTimeRange } from './splitCrossMidnightTimeRange.js';
  * Validates that cross-midnight spillover at override boundaries doesn't
  * create overlapping time ranges. Checks:
  * 1. Spillover into override first day (from weekly or previous override)
- * 2. Override last day spillover into next day (weekly or another override)
+ * 2. Override last day spillover into next day (weekly, weekly: true, or
+ *    another override)
  *
  * Note: Spillover into empty/closed days is allowed (adds availability).
- * Only spillover that OVERLAPS with explicit time ranges is flagged as error.
+ * Spillover that overlaps with explicit time ranges OR into weekly: true
+ * days (which are fully available) is flagged as an error.
  */
 export const validateNoSpilloverConflictsAtOverrideBoundaries = (schedule) => {
     const errors = [];
@@ -27,59 +29,63 @@ export const validateNoSpilloverConflictsAtOverrideBoundaries = (schedule) => {
         // including indefinite ones)
         // Get rules that apply to previous day (weekly or override)
         const previousDayResult = getApplicableRuleForDate(schedule, previousDate);
-        // Check each rule from previous day for cross-midnight spillover
-        previousDayResult.rules.forEach((previousDayRule, previousDayRuleIndex) => {
-            // Skip if previous day rule doesn't include previous weekday
-            if (!doesWeekdaysIncludeWeekday(previousDayRule.weekdays, previousWeekday)) {
-                return;
-            }
-            // Check each time range for cross-midnight
-            previousDayRule.times.forEach((timeRange) => {
-                const splitRanges = splitCrossMidnightTimeRange(timeRange);
-                // If cross-midnight, splitRanges[1] is the spillover portion
-                if (splitRanges.length === 2 && splitRanges[1]) {
-                    const spilloverRange = splitRanges[1];
-                    // Check if spillover conflicts with override first day's times
-                    override.rules.forEach((overrideRule, overrideRuleIndex) => {
-                        // Does first day match override rule's weekdays?
-                        if (!doesWeekdaysIncludeWeekday(overrideRule.weekdays, firstDateWeekday)) {
-                            return;
-                        }
-                        // Check each time range in override rule
-                        overrideRule.times.forEach((overrideTimeRange) => {
-                            const overrideSplitRanges = splitCrossMidnightTimeRange(overrideTimeRange);
-                            // Check same-day portion of override time range
-                            const overrideSameDayRange = overrideSplitRanges[0];
-                            if (overrideSameDayRange &&
-                                doTimeRangesOverlap(spilloverRange, overrideSameDayRange)) {
-                                // Use source information from getApplicableRuleForDate
-                                if (previousDayResult.source.type === 'override') {
-                                    // Previous day is in an override
-                                    errors.push({
-                                        issue: ValidationIssue.SpilloverConflictIntoOverrideFirstDay,
-                                        overrideIndex,
-                                        date: firstDate.toJSON(),
-                                        overrideRuleIndex,
-                                        sourceOverrideIndex: previousDayResult.source.overrideIndex,
-                                        sourceOverrideRuleIndex: previousDayRuleIndex,
-                                    });
-                                }
-                                else {
-                                    // Previous day is weekly
-                                    errors.push({
-                                        issue: ValidationIssue.SpilloverConflictIntoOverrideFirstDay,
-                                        overrideIndex,
-                                        date: firstDate.toJSON(),
-                                        overrideRuleIndex,
-                                        sourceWeeklyRuleIndex: previousDayRuleIndex,
-                                    });
-                                }
+        // If previous day is always available (weekly: true), no cross-midnight
+        // rules to check
+        if (previousDayResult.rules !== true) {
+            // Check each rule from previous day for cross-midnight spillover
+            previousDayResult.rules.forEach((previousDayRule, previousDayRuleIndex) => {
+                // Skip if previous day rule doesn't include previous weekday
+                if (!doesWeekdaysIncludeWeekday(previousDayRule.weekdays, previousWeekday)) {
+                    return;
+                }
+                // Check each time range for cross-midnight
+                previousDayRule.times.forEach((timeRange) => {
+                    const splitRanges = splitCrossMidnightTimeRange(timeRange);
+                    // If cross-midnight, splitRanges[1] is the spillover portion
+                    if (splitRanges.length === 2 && splitRanges[1]) {
+                        const spilloverRange = splitRanges[1];
+                        // Check if spillover conflicts with override first day's times
+                        override.rules.forEach((overrideRule, overrideRuleIndex) => {
+                            // Does first day match override rule's weekdays?
+                            if (!doesWeekdaysIncludeWeekday(overrideRule.weekdays, firstDateWeekday)) {
+                                return;
                             }
+                            // Check each time range in override rule
+                            overrideRule.times.forEach((overrideTimeRange) => {
+                                const overrideSplitRanges = splitCrossMidnightTimeRange(overrideTimeRange);
+                                // Check same-day portion of override time range
+                                const overrideSameDayRange = overrideSplitRanges[0];
+                                if (overrideSameDayRange &&
+                                    doTimeRangesOverlap(spilloverRange, overrideSameDayRange)) {
+                                    // Use source information from getApplicableRuleForDate
+                                    if (previousDayResult.source === 'override') {
+                                        // Previous day is in an override
+                                        errors.push({
+                                            issue: ValidationIssue.SpilloverConflictIntoOverrideFirstDay,
+                                            overrideIndex,
+                                            date: firstDate.toJSON(),
+                                            overrideRuleIndex,
+                                            sourceOverrideIndex: previousDayResult.overrideIndex,
+                                            sourceOverrideRuleIndex: previousDayRuleIndex,
+                                        });
+                                    }
+                                    else {
+                                        // Previous day is weekly
+                                        errors.push({
+                                            issue: ValidationIssue.SpilloverConflictIntoOverrideFirstDay,
+                                            overrideIndex,
+                                            date: firstDate.toJSON(),
+                                            overrideRuleIndex,
+                                            sourceWeeklyRuleIndex: previousDayRuleIndex,
+                                        });
+                                    }
+                                }
+                            });
                         });
-                    });
-                }
+                    }
+                });
             });
-        });
+        }
         // PART 2: Check spillover FROM override last day into next day
         // Skip for indefinite overrides (no last day)
         if (!override.to) {
@@ -103,6 +109,17 @@ export const validateNoSpilloverConflictsAtOverrideBoundaries = (schedule) => {
                     const spilloverRange = splitRanges[1];
                     // Get what rule applies to next day
                     const nextDayResult = getApplicableRuleForDate(schedule, nextDate);
+                    // If next day is always available (weekly: true), spillover
+                    // creates overlapping ranges with the full-day availability.
+                    if (nextDayResult.rules === true) {
+                        errors.push({
+                            issue: ValidationIssue.SpilloverConflictOverrideIntoNext,
+                            overrideIndex,
+                            date: lastDate.toJSON(),
+                            overrideRuleIndex,
+                        });
+                        return;
+                    }
                     // Check if spillover conflicts with next day's times
                     nextDayResult.rules.forEach((nextDayRule, nextDayRuleIndex) => {
                         // Does next day match the rule's weekdays?
@@ -117,14 +134,14 @@ export const validateNoSpilloverConflictsAtOverrideBoundaries = (schedule) => {
                             if (nextDaySameDayRange &&
                                 doTimeRangesOverlap(spilloverRange, nextDaySameDayRange)) {
                                 // Use source information from getApplicableRuleForDate
-                                if (nextDayResult.source.type === 'override') {
+                                if (nextDayResult.source === 'override') {
                                     // Next day is in an override
                                     errors.push({
                                         issue: ValidationIssue.SpilloverConflictOverrideIntoNext,
                                         overrideIndex,
                                         date: lastDate.toJSON(),
                                         overrideRuleIndex,
-                                        nextDayOverrideIndex: nextDayResult.source.overrideIndex,
+                                        nextDayOverrideIndex: nextDayResult.overrideIndex,
                                         nextDayOverrideRuleIndex: nextDayRuleIndex,
                                     });
                                 }

package/dist/internal/validateNonEmptyTimes.js

@@ -5,7 +5,8 @@ import { RuleLocationType, ValidationIssue } from '../constants.js';
 export const validateNonEmptyTimes = (schedule) => {
     const errors = [];
     // Validate weekly rules
-    schedule.weekly.forEach((rule, ruleIndex) => {
+    const weeklyRules = schedule.weekly === true ? [] : schedule.weekly;
+    weeklyRules.forEach((rule, ruleIndex) => {
         if (rule.times.length === 0) {
             errors.push({
                 issue: ValidationIssue.EmptyTimes,

package/dist/internal/validateScDateFormats.js

@@ -86,7 +86,8 @@ const validateRule = (rule, fieldPrefix) => {
 export const validateScDateFormats = (schedule) => {
     const errors = [];
     // Validate weekly rules
-    schedule.weekly.forEach((rule, ruleIndex) => {
+    const weeklyRules = schedule.weekly === true ? [] : schedule.weekly;
+    weeklyRules.forEach((rule, ruleIndex) => {
         errors.push(...validateRule(rule, `weekly[${String(ruleIndex)}]`));
     });
     // Validate overrides