fix: expiry conflict

NormalMonitor/NormalMonitor.swift

@@ -75,16 +75,17 @@ final class NormalMonitor: DeviceActivityMonitor {
         else { return }
 
         let domains = gatedDomains(dto.customDomains)
+        let allowing = activeSchedules(shouldBlock: false)
         if dto.isGroupUnblock {
             guard !sharedStore.isMainTimedUnblockActive() else {
                 sharedStore.removeTimedUnblock(id: dto.id)
                 return
             }
-            store.unionShields(with: selection)
-            store.unionFilterDomains(domains)
+            store.unionShields(with: allowing.applied(to: selection))
+            store.unionFilterDomains(allowing.applied(to: domains))
         } else {
-            store.replaceShields(with: selection)
-            store.replaceFilterDomains(domains)
+            store.replaceShields(with: allowing.applied(to: selection))
+            store.replaceFilterDomains(allowing.applied(to: domains))
             if dto.blockAllPreventsAppDelete == true {
                 store.application.denyAppRemoval = true
             }
@@ -121,7 +122,7 @@ final class NormalMonitor: DeviceActivityMonitor {
         else { return }
 
         let domains = gatedDomains(schedule.customDomains)
-        let stillActive = otherActiveSchedules(like: schedule)
+        let stillActive = activeSchedules(shouldBlock: schedule.shouldBlock, excluding: schedule.id)
         if schedule.shouldBlock {
             store.subtractShields(with: stillActive.applied(to: selection))
             store.subtractFilterDomains(stillActive.applied(to: domains))
@@ -137,15 +138,15 @@ final class NormalMonitor: DeviceActivityMonitor {
         .groupUnblocks(sharedStore.loadTimedUnblocks(), at: .now)
     }
 
-    private func otherActiveSchedules(like schedule: ScheduleDTO) -> ShieldExclusion {
+    private func activeSchedules(shouldBlock: Bool, excluding excludedID: UUID? = nil) -> ShieldExclusion {
         let monitored = Set(DeviceActivityCenter().activities.map(\.rawValue))
         return .activeSchedules(
             sharedStore.loadSchedules(),
-            shouldBlock: schedule.shouldBlock,
+            shouldBlock: shouldBlock,
             at: .now,
-            excluding: schedule.id
-        ) { other in
-            monitored.contains(SharedConstants.scheduleActivityName(for: other.id))
+            excluding: excludedID
+        ) { schedule in
+            monitored.contains(SharedConstants.scheduleActivityName(for: schedule.id))
         }
     }
 

NormalTests/Shared/ShieldExclusionTests.swift

@@ -122,4 +122,19 @@ struct ShieldExclusionTests {
         let remaining = groups.union(schedules).applied(to: TokenFixtures.selection(apps: [1, 2, 3]))
         #expect(remaining.applicationTokens == [TokenFixtures.app(3)])
     }
+
+    @Test func withoutExclusionIncludesEveryActiveScheduleOfKind() throws {
+        let lunch = try schedule(apps: [1], domains: ["a.com"], shouldBlock: false)
+        let work = try schedule(apps: [2])
+
+        let allowing = ShieldExclusion.activeSchedules(
+            [lunch, work],
+            shouldBlock: false,
+            at: noonWednesday,
+            calendar: cal
+        ) { _ in true }
+
+        #expect(allowing.applied(to: TokenFixtures.selection(apps: [1, 2])).applicationTokens == [TokenFixtures.app(2)])
+        #expect(allowing.applied(to: ["a.com", "b.com"]) == ["b.com"])
+    }
 }

Shared/SharedDTO.swift

@@ -165,7 +165,7 @@
     static func groupUnblocks(_ unblocks: [TimedUnblockDTO], at date: Date) -> ShieldExclusion {
         var exclusion = ShieldExclusion()
         for unblock in unblocks where unblock.isGroupUnblock && unblock.endDate > date {
             exclusion.add(unblock.selectionData, domains: unblock.customDomains)
         }
         return exclusion
     }
@@ -174,7 +174,7 @@
         _ schedules: [ScheduleDTO],
         shouldBlock: Bool,
         at date: Date,
-        excluding excludedID: UUID,
+        excluding excludedID: UUID? = nil,
         calendar: Calendar = .current,
         isEnabled: (ScheduleDTO) -> Bool
     ) -> ShieldExclusion {
@@ -183,28 +183,28 @@
             where schedule.id != excludedID
             && schedule.shouldBlock == shouldBlock
             && isEnabled(schedule)
             && schedule.isActive(at: date, calendar: calendar)
         {
             exclusion.add(schedule.selectionData, domains: schedule.customDomains)
         }
         return exclusion
     }
 
     func union(_ other: ShieldExclusion) -> ShieldExclusion {
         var merged = self
         merged.selection = selection.union(other.selection)
         merged.domains.formUnion(other.domains)
         return merged
     }
 
     private mutating func add(_ selectionData: Data, domains: [String]) {
         guard let added = try? FamilyActivitySelection.fromData(selectionData) else { return }
         selection = selection.union(added)
         self.domains.formUnion(domains)
     }
 
     func applied(to selection: FamilyActivitySelection) -> FamilyActivitySelection {
         selection.subtracting(self.selection)
     }
 
     func applied(to domains: [String]) -> [String] {