diff --git a/docs/guide/getting_started.md b/docs/guide/getting_started.md
index fe6fa92..38c4437 100644
--- a/docs/guide/getting_started.md
+++ b/docs/guide/getting_started.md
@@ -21,7 +21,7 @@ Before we dive in, ensure you understand what SLAs & SLA Timers are by exploring
 
 Let's set up an SLA timer similar to the schedule shown below.
 
-For this example, we're working in the week of 25<sup>th</sup> - 29<sup>th</sup> July 2022, but the library works over [as long as you want*](#disclaimers).
+For this example, we're working in the week of 25<sup>th</sup> - 29<sup>th</sup> July 2022, but the library works over [as long as you want](#performance).
 
 <script setup>
 import { withBase } from 'vitepress';
@@ -107,8 +107,9 @@ Sometimes we will want to pause our timer, start this, head over to ["Pausing th
 
 ---
 
-#### Disclaimers
+## Performance
 
-\* `sifex/sla-timer` is still inefficient at calculating SLAs over periods longer than a month.
+SLAs spanning months or years – even with hundreds of pause periods or holidays – are calculated in
+milliseconds: a year-long SLA with a holiday on every day takes ~30ms, and a 10-year calculation ~90ms.
 
 
diff --git a/docs/guide/scheduling.md b/docs/guide/scheduling.md
index 4ca2ccc..2237a0f 100644
--- a/docs/guide/scheduling.md
+++ b/docs/guide/scheduling.md
@@ -12,3 +12,21 @@ $sla = SLA::fromSchedule(
         ->from('23:00:00')->to('23:30:00')->everyDay()
 );
 ```
+
+## Overnight Schedules
+
+Schedules that cross midnight are supported. A window whose end time is earlier than its start time
+carries over into the next day:
+
+```php
+// Covers 22:00 -> midnight, then midnight -> 02:00 the next day
+SLASchedule::create()->from('22:00:00')->to('02:00:00')->everyDay()
+```
+
+A full 24 hour day can be expressed by using the same time for `from` and `to`:
+
+```php
+// 24/7 coverage
+SLASchedule::create()->from('09:00:00')->to('09:00:00')->everyDay()
+```
+
diff --git a/phpstan.neon.dist b/phpstan.neon.dist
index 5109163..e307d61 100644
--- a/phpstan.neon.dist
+++ b/phpstan.neon.dist
@@ -5,7 +5,3 @@ parameters:
     level: 8
     paths:
         - src
-
-    ignoreErrors:
-        # Provided at runtime by the Cmixin\EnhancedPeriod mixin
-        - '#Call to an undefined method Carbon\\CarbonPeriod::diff\(\)#'
diff --git a/src/Agenda/Weekly.php b/src/Agenda/Weekly.php
index af0ef6d..fbb1f42 100644
--- a/src/Agenda/Weekly.php
+++ b/src/Agenda/Weekly.php
@@ -61,7 +61,7 @@ public function setDays(array $days): Weekly
      * we need to generate a full number of periods surrounding/covering our subject period, because Carbon is not
      * capable of generating a full infinite series of 'Fridays 9am to 5pm', so we have to do the heavy lifting for it
      *
-     * @return CarbonPeriod[]
+     * @return array<int, array{0: CarbonInterface, 1: CarbonInterface}>
      */
     public function toPeriods(CarbonPeriod $subject_period): array
     {
@@ -81,12 +81,17 @@ public function toPeriods(CarbonPeriod $subject_period): array
             })
             ->flatMap(function (CarbonInterface $day) {
                 return collect($this->time_periods)
-                    ->map(function (array $t) use ($day) {
-                        return CarbonPeriod::create(
-                            $day->clone()->setTimeFromTimeString($t[0]),
-                            '1 second',
-                            $day->clone()->setTimeFromTimeString($t[1]),
-                        );
+                    ->flatMap(function (array $t) use ($day) {
+                        $start = $day->clone()->setTimeFromTimeString($t[0]);
+                        $end = $day->clone()->setTimeFromTimeString($t[1]);
+
+                        if ($end->lessThanOrEqualTo($start)) {
+                            // Overnight period: keep it as a single period spanning midnight, the
+                            // daily overlap logic in SLA::calculate clips it per day
+                            return [[$start, $end->clone()->addDay()]];
+                        }
+
+                        return [[$start, $end]];
                     });
             })->toArray();
     }
diff --git a/src/Interfaces/AgendaInterface.php b/src/Interfaces/AgendaInterface.php
index 7dc43ad..252948b 100644
--- a/src/Interfaces/AgendaInterface.php
+++ b/src/Interfaces/AgendaInterface.php
@@ -2,12 +2,15 @@
 
 namespace Sifex\SlaTimer\Interfaces;
 
+use Carbon\CarbonInterface;
 use Carbon\CarbonPeriod;
 
 interface AgendaInterface
 {
     /**
-     * @return CarbonPeriod[]
+     * Returns the agenda periods for the subject period as start/end pairs.
+     *
+     * @return array<int, array{0: CarbonInterface, 1: CarbonInterface}>
      */
     public function toPeriods(CarbonPeriod $subject_period): array;
 
diff --git a/src/SLA.php b/src/SLA.php
index 34e0b23..3771326 100644
--- a/src/SLA.php
+++ b/src/SLA.php
@@ -140,89 +140,190 @@ private function calculate(string $subject_start_time, ?string $subject_stop_tim
         $subject_start = Carbon::parse($subject_start_time);
         $subject_end = Carbon::parse($subject_stop_time ?? Carbon::now());
 
+        $subject_start_ts = $subject_start->getTimestamp();
+        $subject_end_ts = $subject_end->getTimestamp();
+
         $main_target_period = $this->get_current_duration($subject_start, $subject_end);
 
         // TODO End period should just be up until the next schedule is made
         $sla_periods = $this->recalculate_sla_periods($subject_start, $subject_end);
 
-        // Iterate over the period
-        $interval = collect(iterator_to_array($main_target_period))->map(function (Carbon $daily_subject_period) use ($subject_start, $subject_end, &$sla_periods) {
-            /**
-             * After we've divided each day, find where the start and end times are by min/max'ing them
-             */
-            $start_of_day = max($subject_start->clone(), $daily_subject_period->clone());
-            $end_of_day = min($subject_end->clone(), $daily_subject_period->clone()->addHours(24));
+        $schedule_valid_from_unixes = array_map(
+            fn (SLASchedule $schedule) => Carbon::parse($schedule->valid_from)->startOfDay()->unix(),
+            $this->schedules
+        );
 
-            /**
-             * Create a 24h period
-             */
-            $daily_period = CarbonPeriod::create($start_of_day, $end_of_day)
-                ->setDateInterval(CarbonInterval::seconds());
+        $default_schedule = SLASchedule::create();
+
+        $pause_periods = collect($this->pause_periods)
+            ->map(fn (SLAPause $pp) => $pp->toPeriod()->setDateInterval(CarbonInterval::seconds()))
+            ->sortBy(fn (CarbonPeriod $p) => $p->start?->getTimestamp())
+            ->values()
+            ->toArray();
+
+        $sla_cursor = 0;
+        $pause_cursor = 0;
+        $enabled_schedule = null;
+        $last_enabled_schedule = null;
+        $valid_from_unix = null;
+        $total_seconds = 0;
+
+        // Iterate over the period, one day at a time. Each day is anchored at the start of
+        // day, so its bounds and the schedule lookups only need integer timestamps.
+        foreach ($main_target_period as $daily) {
+            $daily_ts = $daily->getTimestamp();
+            $day_start_ts = max($subject_start_ts, $daily_ts);
+            $day_end_ts = min($subject_end_ts, $daily_ts + 86400);
 
             /**
              * Grab the enabled schedule, compare this every day to see if we now have a schedule that would
              * supersede it.
              */
-            $enabled_schedule = $this->get_enabled_schedule_for_day($start_of_day);
+            $enabled_schedule = $default_schedule;
+            foreach ($this->schedules as $index => $schedule) {
+                if ($schedule_valid_from_unixes[$index] <= $daily_ts) {
+                    $enabled_schedule = $schedule;
+                }
+            }
+
+            if ($enabled_schedule !== $last_enabled_schedule) {
+                $last_enabled_schedule = $enabled_schedule;
+                $valid_from_unix = Carbon::parse($enabled_schedule->valid_from)->startOfDay()->unix();
+            }
 
             /**
              * Deduplicate our SLA Periods
              * Why do this here? Mostly because of superseded schedules...
              */
-            if ($start_of_day->clone()->startOfDay()->unix() === Carbon::parse($enabled_schedule->valid_from)->clone()->startOfDay()->unix()) {
-                $sla_periods = $this->recalculate_sla_periods($start_of_day, $subject_end);
+            if ($daily_ts === $valid_from_unix) {
+                $sla_periods = $this->recalculate_sla_periods($daily, $subject_end);
+                $sla_cursor = 0;
+            }
+
+            /**
+             * Only consider SLA periods that can possibly overlap the current day, otherwise
+             * the work below would scale with the entire subject duration on every day.
+             *
+             * The periods are generated in chronological order, so a single forward-only
+             * cursor sweeps them without rescanning the whole list for every day.
+             */
+            $sla_count = count($sla_periods);
+            while ($sla_cursor < $sla_count && $sla_periods[$sla_cursor][1]->getTimestamp() <= $day_start_ts) {
+                $sla_cursor++;
+            }
+
+            $day_sla_periods = [];
+            for ($i = $sla_cursor; $i < $sla_count; $i++) {
+                if ($sla_periods[$i][0]->getTimestamp() >= $day_end_ts) {
+                    break;
+                }
+
+                $day_sla_periods[] = $sla_periods[$i];
             }
 
             /**
              * SLA Overlap
-             * This function has been optimised
+             *
+             * Clip each SLA period to the current day and merge the results into a
+             * continuous union using integer timestamps, avoiding the per-day cost of
+             * building CarbonPeriod objects and diffing them via spatie/period.
              */
-            $sla_coverage_periods = collect($sla_periods)
-                ->map(function (CarbonPeriod $sla_period) use ($start_of_day, $end_of_day) {
-                    if ($sla_period->start === null || $sla_period->end === null) {
-                        return null;
-                    }
+            $coverage = [];
+            foreach ($day_sla_periods as [$period_start, $period_end]) {
+                $start = max($period_start->getTimestamp(), $day_start_ts);
+                $end = min($period_end->getTimestamp(), $day_end_ts);
 
-                    $e = max($sla_period->start->getTimestamp(), $start_of_day->getTimestamp());
-                    $f = min($sla_period->end->getTimestamp(), $end_of_day->getTimestamp());
-
-                    if ($e > $f) {
-                        return null;
-                    } // No Overlap
-
-                    return CarbonPeriod::create(
-                        Carbon::createFromTimestamp($e),
-                        Carbon::createFromTimestamp($f),
-                    )->setDateInterval(CarbonInterval::seconds());
-                })
-                ->whereNotNull()
-                ->reduce(function (array $carry, ?CarbonPeriod $p) {
-                    /** De-duplicate overlapping SLA periods */
-                    return $p === null ? $carry : (count($carry) ? [...$p->diff(...$carry), ...$carry] : [$p]);
-                }, []);
-
-            if ($this->pause_periods) {
-                $sla_coverage_periods = collect($sla_coverage_periods)->flatMap(function (CarbonPeriod $period): array {
-                    $pause_periods = collect($this->pause_periods)->map(fn (SLAPause $pp) => $pp->toPeriod()->setDateInterval(CarbonInterval::seconds()))->toArray();
-
-                    return $period->diff(...$pause_periods);
-                })->toArray();
+                if ($start >= $end) {
+                    continue;
+                }
+
+                $coverage[] = [$start, $end];
+            }
+
+            if (count($coverage) > 1) {
+                usort($coverage, fn (array $a, array $b) => $a[0] <=> $b[0]);
+            }
+
+            $merged = [];
+            foreach ($coverage as [$start, $end]) {
+                if ($merged && $start <= $merged[count($merged) - 1][1]) {
+                    $merged[count($merged) - 1][1] = max($merged[count($merged) - 1][1], $end);
+                } else {
+                    $merged[] = [$start, $end];
+                }
             }
 
             /**
-             * Get the interval of each overlapping period and place it into an array of intervals
+             * Subtract the pauses that overlap the current day, reproducing the
+             * closed-interval semantics of spatie/period (the instants a pause
+             * starts and ends at are consumed by it).
+             *
+             * The pauses are sorted by start time and swept with a forward-only
+             * cursor, so only pauses that can overlap the day are considered.
              */
-            /** @var CarbonInterval[] $intervals */
-            $intervals = collect($sla_coverage_periods)
-                ->map(fn (CarbonPeriod $carbonPeriod): CarbonInterval => self::calculate_interval($carbonPeriod))
-                ->toArray();
+            if ($pause_periods) {
+                $pause_count = count($pause_periods);
+                while ($pause_cursor < $pause_count && ($pause_periods[$pause_cursor]->end === null || $pause_periods[$pause_cursor]->end->getTimestamp() <= $day_start_ts)) {
+                    $pause_cursor++;
+                }
+
+                $day_pause_periods = [];
+                for ($i = $pause_cursor; $i < $pause_count; $i++) {
+                    $pause = $pause_periods[$i];
+
+                    if ($pause->start === null || $pause->end === null) {
+                        continue;
+                    }
 
-            return self::combine_intervals($intervals);
+                    if ($pause->start->getTimestamp() >= $day_end_ts) {
+                        break;
+                    }
+
+                    $day_pause_periods[] = $pause;
+                }
+
+                $merged = collect($merged)->flatMap(function (array $pair) use ($day_pause_periods) {
+                    $parts = [$pair];
+
+                    foreach ($day_pause_periods as $pause) {
+                        $pause_start = $pause->start?->getTimestamp();
+                        $pause_end = $pause->end?->getTimestamp();
+
+                        if ($pause_start === null || $pause_end === null || $pause_end < $pair[0] || $pause_start > $pair[1]) {
+                            continue;
+                        }
+
+                        $next = [];
+                        foreach ($parts as [$start, $end]) {
+                            if ($pause_start - 1 >= $start) {
+                                $next[] = [$start, min($end, $pause_start - 1)];
+                            }
+
+                            if ($pause_end + 1 <= $end) {
+                                $next[] = [max($start, $pause_end + 1), $end];
+                            }
+                        }
+
+                        $parts = $next;
+
+                        if (! $parts) {
+                            break;
+                        }
+                    }
+
+                    return $parts;
+                })->toArray();
+            }
 
             /**
-             * Then combine all intervals
+             * Sum the seconds of every remaining coverage period of the day
              */
-        })->pipe(fn ($c) => self::combine_intervals($c->toArray()));
+            foreach ($merged as [$start, $end]) {
+                $total_seconds += $end - $start;
+            }
+        }
+
+        $interval = CarbonInterval::seconds((int) round($total_seconds))->cascade();
 
         return new SLAStatus(
             collect($this->breach_definitions)
@@ -234,7 +335,7 @@ private function calculate(string $subject_start_time, ?string $subject_stop_tim
     }
 
     /**
-     * @return CarbonPeriod[]
+     * @return array<int, array{0: CarbonInterface, 1: CarbonInterface}>
      */
     private function recalculate_sla_periods(CarbonInterface $from, CarbonInterface $to): array
     {
@@ -271,31 +372,6 @@ private function get_enabled_schedule_for_day(CarbonInterface $day): SLASchedule
             ->last() ?? SLASchedule::create();
     }
 
-    /**
-     * Turns a single period into an interval
-     */
-    private static function calculate_interval(CarbonPeriod $period): CarbonInterval
-    {
-        if ($period->start === null || $period->end === null) {
-            return CarbonInterval::seconds(0);
-        }
-
-        return CarbonInterval::seconds($period->end->getTimestamp() - $period->start->getTimestamp());
-    }
-
-    /**
-     * Combines two different intervals
-     *
-     * @param  CarbonInterval[]  $intervals
-     */
-    private static function combine_intervals(array $intervals): CarbonInterval
-    {
-        return collect($intervals)
-            ->reduce(function (CarbonInterval $i, CarbonInterval $overlapping_period) {
-                return $i->add($overlapping_period->cascade())->cascade();
-            }, CarbonInterval::seconds(0));
-    }
-
     /**
      * Filter out any excluded dates
      */
diff --git a/tests/SLAEdgeCasesTest.php b/tests/SLAEdgeCasesTest.php
new file mode 100644
index 0000000..ad3f400
--- /dev/null
+++ b/tests/SLAEdgeCasesTest.php
@@ -0,0 +1,375 @@
+<?php
+
+use Sifex\SlaTimer\SLA;
+use Sifex\SlaTimer\SLABreach;
+use Sifex\SlaTimer\SLAHoliday;
+use Sifex\SlaTimer\SLAPause;
+use Sifex\SlaTimer\SLASchedule;
+
+use function Spatie\PestPluginTestTime\testTime;
+
+/**
+ * Schedule building
+ */
+it('builds a schedule from a single day name string', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('10:00:00')->on('Saturday')
+    );
+
+    $duration = $sla->duration('2023-04-29 00:00:00', '2023-04-29 12:00:00');
+
+    expect($duration->totalSeconds)->toEqual(3600);
+});
+
+it('counts SLA time on weekends only', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('17:00:00')->onWeekends()
+    );
+
+    $duration = $sla->duration('2023-04-27 00:00:00', '2023-05-01 00:00:00');
+
+    expect($duration->totalSeconds)->toEqual(57600);
+});
+
+it('supports multiple time periods per day with andFrom', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()
+            ->from('09:00:00')->to('12:00:00')
+            ->andFrom('13:00:00')->to('17:00:00')
+            ->everyDay()
+    );
+
+    $duration = $sla->duration('2023-04-27 10:00:00', '2023-04-27 14:00:00');
+
+    expect($duration->totalSeconds)->toEqual(10800);
+});
+
+it('adds additional time periods via the weekly agenda', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('10:00:00')->everyDay()
+    );
+
+    $sla->schedules[0]->agendas[0]->addTimePeriods(['11:00:00', '12:00:00']);
+
+    $duration = $sla->duration('2023-04-27 08:00:00', '2023-04-27 13:00:00');
+
+    expect($duration->totalSeconds)->toEqual(7200);
+});
+
+it('clears time periods via the weekly agenda', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('10:00:00')->everyDay()
+    );
+
+    $sla->schedules[0]->agendas[0]->clearTimePeriods();
+
+    $duration = $sla->duration('2023-04-27 08:00:00', '2023-04-27 13:00:00');
+
+    expect($duration->totalSeconds)->toEqual(0);
+});
+
+it('stores the schedule timezone', function () {
+    $schedule = SLASchedule::create()->from('09:00:00')->to('17:00:00')->setTimezone('Europe/London');
+
+    expect($schedule->timezone)->toEqual('Europe/London');
+});
+
+/**
+ * Schedule validity
+ */
+it('returns zero when the schedule is not yet effective', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->effectiveFrom('2099-01-01')->from('09:00:00')->to('17:00:00')->everyDay()
+    );
+
+    $duration = $sla->duration('2023-04-27 09:00:00', '2023-04-27 17:00:00');
+
+    expect($duration->totalSeconds)->toEqual(0);
+});
+
+it('switches to the latest effective schedule mid-duration', function () {
+    $sla = SLA::fromSchedules([
+        SLASchedule::create()->from('09:00:00')->to('17:00:00')->everyDay(),
+        SLASchedule::create()->effectiveFrom('2023-04-28')->from('09:00:00')->to('10:00:00')->everyDay(),
+    ]);
+
+    $duration = $sla->duration('2023-04-27 09:00:00', '2023-04-29 09:00:00');
+
+    expect($duration->totalSeconds)->toEqual(32400);
+});
+
+/**
+ * Boundary conditions
+ */
+it('returns zero when the subject starts after the schedule ends', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('17:00:00')->everyDay()
+    );
+
+    $duration = $sla->duration('2023-04-27 18:00:00', '2023-04-27 19:00:00');
+
+    expect($duration->totalSeconds)->toEqual(0);
+});
+
+it('counts a subject starting exactly at the schedule start', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('17:00:00')->everyDay()
+    );
+
+    $duration = $sla->duration('2023-04-27 09:00:00', '2023-04-27 09:00:30');
+
+    expect($duration->totalSeconds)->toEqual(30);
+});
+
+it('counts a subject ending exactly at the schedule end', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('17:00:00')->everyDay()
+    );
+
+    $duration = $sla->duration('2023-04-27 09:00:00', '2023-04-27 17:00:00');
+
+    expect($duration->totalSeconds)->toEqual(28800);
+});
+
+it('counts SLA time across multiple weeks excluding weekends', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('17:00:00')->onWeekdays()
+    );
+
+    $duration = $sla->duration('2023-04-27 09:00:00', '2023-05-11 09:00:00');
+
+    expect($duration->totalSeconds)->toEqual(288000);
+});
+
+/**
+ * Overnight (midnight-crossing) schedules
+ */
+it('counts an overnight schedule across midnight', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('22:00:00')->to('02:00:00')->everyDay()
+    );
+
+    $duration = $sla->duration('2023-04-27 21:00:00', '2023-04-28 03:00:00');
+
+    expect($duration->totalSeconds)->toEqual(14400);
+});
+
+it('counts an overnight schedule when the subject sits entirely within the night', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('22:00:00')->to('02:00:00')->everyDay()
+    );
+
+    $duration = $sla->duration('2023-04-27 23:00:00', '2023-04-28 01:00:00');
+
+    expect($duration->totalSeconds)->toEqual(7200);
+});
+
+it('counts the full overnight window', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('22:00:00')->to('02:00:00')->everyDay()
+    );
+
+    $duration = $sla->duration('2023-04-27 22:00:00', '2023-04-28 02:00:00');
+
+    expect($duration->totalSeconds)->toEqual(14400);
+});
+
+it('counts an overnight schedule over multiple days', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('22:00:00')->to('02:00:00')->everyDay()
+    );
+
+    $duration = $sla->duration('2023-04-27 21:00:00', '2023-04-28 23:00:00');
+
+    expect($duration->totalSeconds)->toEqual(18000);
+});
+
+it('counts an overnight weekday schedule over multiple days', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('22:00:00')->to('02:00:00')->onWeekdays()
+    );
+
+    $duration = $sla->duration('2023-04-27 21:00:00', '2023-04-29 03:00:00');
+
+    expect($duration->totalSeconds)->toEqual(28800);
+});
+
+it('treats equal from and to times as a 24 hour schedule', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('09:00:00')->everyDay()
+    );
+
+    $duration = $sla->duration('2023-04-27 09:00:00', '2023-04-28 09:00:00');
+
+    expect($duration->totalSeconds)->toEqual(86400);
+});
+
+/**
+ * Pauses & holidays
+ */
+it('builds a pause day period spanning the full day', function () {
+    $pause = new SLAPause('2023-04-27 10:00:00', '2023-04-27 14:00:00');
+
+    $period = $pause->toDayPeriod();
+
+    expect($period->start->format('Y-m-d H:i:s'))->toEqual('2023-04-27 00:00:00')
+        ->and($period->end->format('Y-m-d H:i:s'))->toEqual('2023-04-27 23:59:59');
+});
+
+it('builds a holiday period spanning the full day', function () {
+    $holiday = new SLAHoliday('2023-04-27', '2023-04-27');
+
+    $period = $holiday->toPeriod();
+
+    expect($period->start->format('Y-m-d H:i:s'))->toEqual('2023-04-27 00:00:00')
+        ->and($period->end->format('Y-m-d H:i:s'))->toEqual('2023-04-27 23:59:59');
+});
+
+it('ignores a pause outside of the subject period', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('17:00:00')->everyDay()
+    );
+
+    $sla->addPause('2023-04-26 00:00:00', '2023-04-26 23:59:59');
+
+    $duration = $sla->duration('2023-04-27 09:00:00', '2023-04-27 17:00:00');
+
+    expect($duration->totalSeconds)->toEqual(28800);
+});
+
+it('returns zero when a pause covers the entire subject period', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('17:00:00')->everyDay()
+    );
+
+    $sla->addPause('2023-04-27 08:00:00', '2023-04-27 18:00:00');
+
+    $duration = $sla->duration('2023-04-27 09:00:00', '2023-04-27 17:00:00');
+
+    expect($duration->totalSeconds)->toEqual(0);
+});
+
+it('returns zero when a pause spans multiple days', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('17:00:00')->everyDay()
+    );
+
+    $sla->addPause('2023-04-27 00:00:00', '2023-04-28 23:59:59');
+
+    $duration = $sla->duration('2023-04-27 09:00:00', '2023-04-29 09:00:00');
+
+    expect($duration->totalSeconds)->toEqual(0);
+});
+
+it('accepts multiple holidays as an array', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('17:00:00')->everyDay()
+    );
+
+    $sla->addHolidays(['2023-04-27', '2023-04-28']);
+
+    $duration = $sla->duration('2023-04-27 09:00:00', '2023-04-29 17:00:00');
+
+    expect($duration->totalSeconds)->toEqual(28800);
+});
+
+it('ignores a holiday that falls on a day without SLA coverage', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('17:00:00')->onWeekdays()
+    );
+
+    $sla->addHoliday('2023-04-29');
+
+    $duration = $sla->duration('2023-04-28 09:00:00', '2023-05-01 17:00:00');
+
+    expect($duration->totalSeconds)->toEqual(57600);
+});
+
+/**
+ * Long durations (regression: these used to be quadratic in the number of days/pauses)
+ */
+it('calculates a year-long subject with a holiday on every day', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('17:00:00')->onWeekdays()
+    );
+
+    for ($i = 0; $i < 365; $i++) {
+        $sla->addHoliday(date('Y-m-d', strtotime("2023-01-01 +{$i} days")));
+    }
+
+    $duration = $sla->duration('2023-01-01 09:00:00', '2023-12-31 17:00:00');
+
+    expect($duration->totalSeconds)->toEqual(0);
+});
+
+it('calculates a year-long subject with weekly pause windows', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('17:00:00')->onWeekdays()
+    );
+
+    for ($i = 0; $i < 52; $i++) {
+        $sla->addPause(date('Y-m-d 12:00:00', strtotime("2023-01-04 +{$i} weeks")), date('Y-m-d 13:00:00', strtotime("2023-01-04 +{$i} weeks")));
+    }
+
+    $duration = $sla->duration('2023-01-01 09:00:00', '2024-01-01 09:00:00');
+
+    // 260 weekdays x 8h minus 52 weekly 1h pauses, with each pause diff
+    // removing 2 boundary seconds (closed-interval semantics in spatie/period)
+    expect($duration->totalSeconds)->toEqual(7300696);
+});
+
+it('calculates a year-long subject without pauses', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('17:00:00')->onWeekdays()
+    );
+
+    $duration = $sla->duration('2023-01-01 09:00:00', '2024-01-01 09:00:00');
+
+    expect($duration->totalSeconds)->toEqual(7488000);
+});
+
+/**
+ * Breaches
+ */
+it('returns only breached breaches from the breaches accessor', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('17:00:00')->everyDay()
+    );
+
+    $sla->addBreaches(
+        new SLABreach('fast', '1s'),
+        new SLABreach('slow', '1000h'),
+    );
+
+    testTime()->freeze('2023-04-27 09:00:05');
+
+    $breaches = $sla->breaches('2023-04-27 09:00:00');
+
+    expect($breaches)->toHaveCount(1)
+        ->and($breaches[0]->name)->toEqual('fast');
+});
+
+it('does not breach when the interval exactly matches the breach threshold', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('09:00:01')->everyDay()
+    );
+
+    $sla->addBreaches(new SLABreach('exact', '1s'));
+
+    testTime()->freeze('2023-04-27 09:00:01');
+
+    $status = $sla->status('2023-04-27 09:00:00');
+
+    expect($status->interval->totalSeconds)->toEqual(1)
+        ->and($status->hasABreach())->toBeFalse();
+});
+
+it('does not report a breach when no breaches are defined', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()->from('09:00:00')->to('17:00:00')->everyDay()
+    );
+
+    testTime()->freeze('2023-04-27 09:00:05');
+
+    expect($sla->status('2023-04-27 09:00:00')->hasABreach())->toBeFalse();
+});
diff --git a/tests/SLATest.php b/tests/SLATest.php
index 99bbfbc..9e8fee7 100644
--- a/tests/SLATest.php
+++ b/tests/SLATest.php
@@ -1,6 +1,5 @@
 <?php
 
-use Carbon\CarbonInterval;
 use Sifex\SlaTimer\SLA;
 use Sifex\SlaTimer\SLABreach;
 use Sifex\SlaTimer\SLASchedule;
@@ -10,19 +9,17 @@
 /**
  * Daily Periods
  */
-it('collapses intervals', function () {
-    $interval_one = CarbonInterval::seconds(30);
-    $interval_two = CarbonInterval::minutes(30);
-    $interval_three = CarbonInterval::seconds(180);
-
-    /** @var CarbonInterval $combined */
-    $combined = invade(new SLA(SLASchedule::create()->from('')))->combine_intervals([
-        $interval_one,
-        $interval_two,
-        $interval_three,
-    ]);
+it('collapses overlapping SLA periods into a single interval', function () {
+    $sla = SLA::fromSchedule(
+        SLASchedule::create()
+            ->from('09:00:00')->to('12:00:00')
+            ->andFrom('11:00:00')->to('17:00:00')
+            ->everyDay()
+    );
+
+    $duration = $sla->duration('2023-04-27 08:00:00', '2023-04-27 18:00:00');
 
-    expect($combined->totalSeconds)->toEqual(30 + (30 * 60) + 180);
+    expect($duration->totalSeconds)->toEqual(28800);
 });
 
 it('tests the SLA across a short duration', function () {