chore(repo): iOS-App als ios/ ins Hauptrepo uebernehmen

Calendarr-IOS wird mit vollstaendiger Historie als Unterverzeichnis ios/ eingebunden. Damit liegen Server, Web, Android und iOS in einem gemeinsamen Repo. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-09-14 09:20:12 +02:00
parent 560457945c 31d7a0080e
commit 6e981e7aea
107 changed files with 19373 additions and 0 deletions
@@ -0,0 +1,626 @@
+import SwiftUI
+
+private enum CalEditorContext: Identifiable {
+    case create(Date)
+    case edit(CalEvent)
+    var id: String {
+        switch self {
+        case .create(let d): return "new-\(d.timeIntervalSince1970)"
+        case .edit(let ev): return "edit-\(ev.id)"
+        }
+    }
+}
+
+struct CalendarHostView: View {
+    let api: CalendarrAPI
+    @Binding var showMenu: Bool
+
+    @AppStorage("liquidGlass") private var liquidGlass = false
+    @AppStorage("cacheMonths") private var cacheMonths = 3
+    @AppStorage("appLanguage") private var appLang = "system"
+    @AppStorage("backgroundColor") private var bgHex = "#000000"
+    @AppStorage("weekStartDay") private var weekStartDay = "monday"
+    @AppStorage("defaultView")  private var defaultView = "month"
+    // Opt-in: empty keeps the translucent `.bar` material; a hex tints the top bar.
+    @AppStorage("surfaceColor") private var surfaceHex = ""
+    // Device-local: hide the hamburger (drawer then opens only via edge-swipe).
+    @AppStorage("hideMenuButton") private var hideMenuButton = false
+
+    @Environment(\.scenePhase) private var scenePhase
+
+    @State private var store = CalendarStore()
+    @State private var editorContext: CalEditorContext? = nil
+    @State private var selectedEvent: CalEvent? = nil
+    @State private var showFilter = false
+    @State private var didApplyDefaultView = false
+    @State private var groups: [CalGroup] = []
+    @State private var showNewBirthday = false
+    @State private var showDrawer = false
+
+    private var titleString: String {
+        if store.viewType == .month {
+            let f = DateFormatter()
+            f.locale = L10n.locale(appLang)
+            f.dateFormat = "LLLL yyyy"
+            return f.string(from: store.visibleMonth).capitalized(with: L10n.locale(appLang))
+        }
+        return store.titleForCurrentView(language: appLang)
+    }
+
+    var body: some View {
+        ZStack(alignment: .leading) {
+            Group {
+                if liquidGlass { glassVariant } else { flatVariant }
+            }
+            // Dim scrim behind the open drawer.
+            if showDrawer {
+                Color.black.opacity(0.35)
+                    .ignoresSafeArea()
+                    .transition(.opacity)
+                    .onTapGesture { closeDrawer() }
+            }
+            // Off-canvas left drawer.
+            CalendarDrawer(
+                api: api, store: store, groups: groups,
+                onSwitchGroup: { g in closeDrawer(); switchGroup(g) },
+                onSelectView: { vt in store.viewType = vt; closeDrawer() },
+                onOpenMenu: { closeDrawer(); showMenu = true },
+                onSync: { closeDrawer(); Task { await syncFromServer(force: true) } },
+                onClose: { closeDrawer() }
+            )
+            .frame(width: drawerWidth)
+            .frame(maxHeight: .infinity, alignment: .top)
+            .shadow(color: .black.opacity(showDrawer ? 0.25 : 0), radius: 12, x: 4)
+            .offset(x: showDrawer ? 0 : -(drawerWidth + 60))
+            .animation(.easeInOut(duration: 0.25), value: showDrawer)
+            // Swipe the drawer toward the left edge to close it.
+            .simultaneousGesture(
+                DragGesture(minimumDistance: 20)
+                    .onEnded { v in
+                        if showDrawer, v.translation.width < -45,
+                           abs(v.translation.width) > abs(v.translation.height) {
+                            closeDrawer()
+                        }
+                    }
+            )
+        }
+        // A narrow leading strip opens the drawer via edge-swipe (kept off the
+        // content area so month paging / week swipe stay free).
+        .overlay(alignment: .leading) {
+            if !showDrawer {
+                Color.clear
+                    .frame(width: 18)
+                    .frame(maxHeight: .infinity)
+                    .contentShape(Rectangle())
+                    .gesture(
+                        DragGesture(minimumDistance: 12, coordinateSpace: .local)
+                            .onEnded { v in
+                                if v.translation.width > 45,
+                                   abs(v.translation.width) > abs(v.translation.height) {
+                                    withAnimation(.easeInOut(duration: 0.25)) { showDrawer = true }
+                                }
+                            }
+                    )
+            }
+        }
+    }
+
+    private var drawerWidth: CGFloat { min(UIScreen.main.bounds.width - 40, 360) }
+
+    private func closeDrawer() {
+        withAnimation(.easeInOut(duration: 0.25)) { showDrawer = false }
+    }
+
+    // MARK: – Loading indicator
+
+    @ViewBuilder
+    private var loadingIndicator: some View {
+        if store.isLoading || store.isCachingBackground {
+            ProgressView()
+                .padding(14)
+                .background(.regularMaterial, in: Circle())
+                .shadow(color: .black.opacity(0.12), radius: 6, y: 2)
+                .transition(.opacity.combined(with: .scale(scale: 0.85)))
+        }
+    }
+
+    // MARK: – Flat variant
+
+    private var flatVariant: some View {
+        VStack(spacing: 0) {
+            topBar
+            groupBanner
+            Divider()
+            errorBanner
+            calendarContent
+                .frame(maxWidth: .infinity, maxHeight: .infinity)
+                .background(Color(hex: bgHex))
+                .overlay(alignment: .top) {
+                    loadingIndicator.padding(.top, 12)
+                }
+                .animation(.easeInOut(duration: 0.2), value: store.isLoading || store.isCachingBackground)
+        }
+        .overlay(alignment: .bottomTrailing) { solidFAB }
+        .modifier(calendarSheets)
+        .task { await startup() }
+        .onChange(of: store.currentDate) { _, _ in Task { await onNavigate() } }
+        .onChange(of: store.viewType)    { _, _ in Task { await onNavigate() } }
+        .onChange(of: cacheMonths)       { _, _ in Task { await recache() } }
+        .onChange(of: store.visibleMonth) { _, new in Task { await ensureLoaded(around: new) } }
+        .onChange(of: scenePhase)        { _, phase in if phase == .active { Task { await syncFromServer() } } }
+        .onReceive(NotificationCenter.default.publisher(for: .banishedCalendarsChanged)) { _ in
+            store.syncBanishedFromDefaults()
+        }
+        .onReceive(NotificationCenter.default.publisher(for: .settingsDidChange)) { _ in
+            applyServerDrivenSettings(initial: false)
+        }
+        .onReceive(NotificationCenter.default.publisher(for: .manualSyncRequested)) { _ in
+            Task { await forceReload() }
+        }
+        .onReceive(NotificationCenter.default.publisher(for: .rescheduleReminders)) { _ in
+            store.rescheduleNotifications()
+        }
+    }
+
+    // MARK: – Liquid Glass variant
+
+    private var glassVariant: some View {
+        // Real iOS-26 Liquid Glass: the system NavigationStack toolbar renders the
+        // glass bar (buttons). The month TITLE is NOT placed in the toolbar — the
+        // system title silently fails to refresh on month change on iOS 26 — but
+        // as a normal inline Text in a top safe-area inset just below the glass
+        // bar, where it updates reliably (same mechanism as the flat variant).
+        NavigationStack {
+            calendarContent
+                .frame(maxWidth: .infinity, maxHeight: .infinity)
+                .background(Color(hex: bgHex))
+                .overlay(alignment: .top) {
+                    loadingIndicator.padding(.top, 12)
+                }
+                .animation(.easeInOut(duration: 0.2), value: store.isLoading || store.isCachingBackground)
+                .navigationBarTitleDisplayMode(.inline)
+                .toolbar {
+                    ToolbarItem(placement: .navigationBarLeading) {
+                        HStack(spacing: 2) {
+                            if !hideMenuButton { menuButton }
+                            Button { store.navigatePrev() } label: { Image(systemName: "chevron.left") }
+                            Button { store.navigateNext() } label: { Image(systemName: "chevron.right") }
+                        }
+                    }
+                    ToolbarItem(placement: .navigationBarTrailing) {
+                        Button(L10n.t("nav.today", appLang)) { store.moveToToday() }.font(.callout)
+                    }
+                }
+                .safeAreaInset(edge: .top, spacing: 0) {
+                    VStack(spacing: 0) {
+                        Text(titleString)
+                            .font(.headline)
+                            .lineLimit(1)
+                            .minimumScaleFactor(0.7)
+                            .frame(maxWidth: .infinity)
+                            .padding(.vertical, 6)
+                            .background(.bar)
+                        groupBanner
+                        errorBanner
+                    }
+                }
+        }
+        .overlay(alignment: .bottomTrailing) { glassFAB }
+        .modifier(calendarSheets)
+        .task { await startup() }
+        .onChange(of: store.currentDate) { _, _ in Task { await onNavigate() } }
+        .onChange(of: store.viewType)    { _, _ in Task { await onNavigate() } }
+        .onChange(of: cacheMonths)       { _, _ in Task { await recache() } }
+        .onChange(of: store.visibleMonth) { _, new in Task { await ensureLoaded(around: new) } }
+        .onChange(of: scenePhase)        { _, phase in if phase == .active { Task { await syncFromServer() } } }
+        .onReceive(NotificationCenter.default.publisher(for: .banishedCalendarsChanged)) { _ in
+            store.syncBanishedFromDefaults()
+        }
+        .onReceive(NotificationCenter.default.publisher(for: .settingsDidChange)) { _ in
+            applyServerDrivenSettings(initial: false)
+        }
+        .onReceive(NotificationCenter.default.publisher(for: .manualSyncRequested)) { _ in
+            Task { await forceReload() }
+        }
+        .onReceive(NotificationCenter.default.publisher(for: .rescheduleReminders)) { _ in
+            store.rescheduleNotifications()
+        }
+    }
+
+    // MARK: – Top bar (flat mode)
+
+    /// Shared bar contents (chevrons / today / title / group / view / filter / menu).
+    /// Used by both the flat and the glass top bar so the inline title — which
+    /// updates reliably on month change — is identical in both modes.
+    @ViewBuilder private var barContents: some View {
+        HStack(spacing: 0) {
+            // Menu (hamburger) on the left — the drawer opens from the left.
+            if !hideMenuButton { menuButton.padding(.leading, 2) }
+            HStack(spacing: 2) {
+                Button { store.navigatePrev() } label: {
+                    Image(systemName: "chevron.left")
+                        .font(.system(size: 17, weight: .medium))
+                        .frame(width: 36, height: 36)
+                }
+                Button { store.navigateNext() } label: {
+                    Image(systemName: "chevron.right")
+                        .font(.system(size: 17, weight: .medium))
+                        .frame(width: 36, height: 36)
+                }
+            }
+            .padding(.leading, hideMenuButton ? 6 : 0)
+            Spacer(minLength: 6)
+            Text(titleString)
+                .font(.headline)
+                .lineLimit(1)
+                .minimumScaleFactor(0.7)
+                .layoutPriority(1)
+            Spacer(minLength: 6)
+            Button(L10n.t("nav.today", appLang)) { store.moveToToday() }
+                .font(.callout).padding(.horizontal, 6)
+                .lineLimit(1).fixedSize()
+                .padding(.trailing, 4)
+        }
+        .frame(height: 48)
+    }
+
+    private var topBar: some View {
+        barContents.background(
+            surfaceHex.isEmpty ? AnyShapeStyle(Material.bar) : AnyShapeStyle(Color(hex: surfaceHex))
+        )
+    }
+
+    @ViewBuilder private var groupBanner: some View {
+        if let g = store.activeGroup {
+            HStack(spacing: 6) {
+                GroupIconView(icon: g.icon).font(.subheadline)
+                Text("\(L10n.t("groups.view_label", appLang)): \(g.name)")
+                    .font(.subheadline).lineLimit(1)
+                Spacer()
+                Button(L10n.t("groups.exit", appLang)) { switchGroup(nil) }
+                    .font(.callout)
+            }
+            .padding(.horizontal, 12).padding(.vertical, 7)
+            .background(Color.accentColor.opacity(0.18))
+        }
+    }
+
+    private func switchGroup(_ g: CalGroup?) {
+        store.activeGroup = g
+        store.hiddenGroupKeys = []   // member visibility is per-group; start fresh
+        // The cache holds the previous mode's events — drop it and reload the
+        // visible range + prefetch a wide window so the whole grid is covered.
+        Task { await forceReload() }
+    }
+
+    /// Opens the side drawer (calendars + groups + navigation). Tinted when a
+    /// filter/group is active so the user sees state at a glance.
+    private var menuButton: some View {
+        Button {
+            withAnimation(.easeInOut(duration: 0.25)) { showDrawer = true }
+        } label: {
+            Image(systemName: "line.3.horizontal")
+                .font(.system(size: 18, weight: .medium))
+                .foregroundStyle(store.activeGroup == nil && store.hiddenCalendarKeys.isEmpty ? .primary : Color.accentColor)
+                .frame(width: 36, height: 36)
+        }
+        .accessibilityLabel(L10n.t("nav.menu", appLang))
+    }
+
+    // MARK: – Error banners
+
+    // `lastError` (whole fetch failed) and `syncErrors` (fetch succeeded, but
+    // individual calendars didn't sync) are independent conditions and can
+    // both be shown at once.
+    @ViewBuilder private var errorBanner: some View {
+        if let err = store.lastError { errorBannerView(err) }
+        if !store.syncErrors.isEmpty { syncErrorBannerView(store.syncErrors) }
+    }
+
+    private func errorBannerView(_ err: String) -> some View {
+        HStack(spacing: 8) {
+            Image(systemName: "exclamationmark.triangle.fill").foregroundStyle(.yellow)
+            Text(err).font(.caption).foregroundStyle(.white).lineLimit(2)
+            Spacer()
+            Button { Task { await onNavigate() } } label: {
+                Image(systemName: "arrow.clockwise").foregroundStyle(.white)
+            }
+        }
+        .padding(.horizontal, 12).padding(.vertical, 8)
+        .background(Color.red.opacity(0.85))
+    }
+
+    /// One or more calendars didn't sync on the last fetch (e.g. expired
+    /// credentials) even though they're still enabled. Same visual language
+    /// as `errorBannerView`, joined into a single compact banner.
+    private func syncErrorBannerView(_ errors: [SyncError]) -> some View {
+        let text = errors.map { "\($0.source) (\($0.name)): \($0.message)" }.joined(separator: "\n")
+        return HStack(alignment: .top, spacing: 8) {
+            Image(systemName: "exclamationmark.triangle.fill").foregroundStyle(.yellow)
+            Text(text).font(.caption).foregroundStyle(.white).lineLimit(errors.count + 1)
+            Spacer()
+            Button { Task { await onNavigate() } } label: {
+                Image(systemName: "arrow.clockwise").foregroundStyle(.white)
+            }
+        }
+        .padding(.horizontal, 12).padding(.vertical, 8)
+        .background(Color.red.opacity(0.85))
+    }
+
+    // MARK: – Calendar content (with swipe)
+
+    @ViewBuilder
+    private var calendarContent: some View {
+        let swipe = DragGesture(minimumDistance: 14, coordinateSpace: .local)
+            .onEnded { val in
+                let h = val.translation.width
+                let v = val.translation.height
+                guard abs(h) > abs(v) * 1.2, abs(h) > 28 else { return }
+                withAnimation(.easeInOut(duration: 0.2)) {
+                    if h < 0 { store.navigateNext() } else { store.navigatePrev() }
+                }
+            }
+        switch store.viewType {
+        case .month:
+            // Month view uses vertical scroll – no horizontal swipe.
+            MonthView(store: store,
+                      onDayTap: { store.currentDate = $0 },
+                      onEventTap: { selectedEvent = $0 },
+                      onCreateEvent: { day in editorContext = .create(day) },
+                      onShowWeek: { day in
+                          store.currentDate = day
+                          store.viewType = .week
+                      },
+                      onShowDay: { day in
+                          store.currentDate = day
+                          store.viewType = .day
+                      })
+        case .week:
+            WeekView(store: store,
+                     onEventTap: { selectedEvent = $0 },
+                     onCreateEvent: { date in editorContext = .create(date) },
+                     onShowMonth: { date in
+                         store.currentDate = date
+                         store.viewType = .month
+                     },
+                     onShowDay: { date in
+                         store.currentDate = date
+                         store.viewType = .day
+                     })
+                .simultaneousGesture(swipe)
+        case .day:
+            DayView(store: store,
+                    onEventTap: { selectedEvent = $0 },
+                    onCreateEvent: { date in editorContext = .create(date) })
+                .simultaneousGesture(swipe)
+        case .quarter:
+            QuarterView(store: store, onEventTap: { selectedEvent = $0 })
+                .simultaneousGesture(swipe)
+        case .agenda:
+            AgendaView(store: store, onEventTap: { selectedEvent = $0 })
+        }
+    }
+
+    // MARK: – FAB buttons
+
+    /// Long-press menu on the create button: a plain new event, or a new birthday
+    /// (which opens a minimal name + date mask that only targets birthday calendars).
+    @ViewBuilder private var fabMenu: some View {
+        Button {
+            editorContext = .create(.now)
+        } label: {
+            Label(L10n.t("event.new_title", appLang), systemImage: "plus")
+        }
+        Button {
+            showNewBirthday = true
+        } label: {
+            Label(L10n.t("birthday.new", appLang), systemImage: "birthday.cake.fill")
+        }
+    }
+
+    /// Standard solid FAB (flat mode)
+    private var solidFAB: some View {
+        Button {
+            editorContext = .create(.now)
+        } label: {
+            Image(systemName: "plus")
+                .font(.system(size: 22, weight: .semibold))
+                .foregroundStyle(.white)
+                .frame(width: 56, height: 56)
+                .background(Color.accentColor)
+                .clipShape(Circle())
+                .shadow(radius: 4, y: 2)
+        }
+        .contextMenu { fabMenu }
+        .padding(.trailing, 20).padding(.bottom, 20)
+    }
+
+    /// Liquid Glass FAB (iOS 26) with glass effect; falls back to solid on older OS
+    @ViewBuilder
+    private var glassFAB: some View {
+        if #available(iOS 26, *) {
+            Button {
+                editorContext = .create(.now)
+            } label: {
+                Image(systemName: "plus")
+                    .font(.system(size: 22, weight: .semibold))
+                    .foregroundStyle(.primary)
+                    .frame(width: 56, height: 56)
+            }
+            .buttonStyle(.plain)
+            .glassEffect(in: Circle())
+            .contextMenu { fabMenu }
+            .padding(.trailing, 20).padding(.bottom, 20)
+        } else {
+            solidFAB
+        }
+    }
+
+    // MARK: – Sheets modifier
+
+    private var calendarSheets: CalendarSheets {
+        CalendarSheets(store: store, editorContext: $editorContext,
+                       selectedEvent: $selectedEvent, showFilter: $showFilter,
+                       showNewBirthday: $showNewBirthday,
+                       api: api,
+                       reload: { await onNavigate() },
+                       reloadForce: { await reloadVisible(force: true) })
+    }
+
+    // MARK: – Loading logic
+
+    private func startup() async {
+        // Ask for notification permission early so reminders can be scheduled.
+        NotificationScheduler.requestAuthorizationIfNeeded()
+        // 0. Pull settings first so week-start / default-view are correct
+        //    before we compute the initial range and load events.
+        await SettingsSync.pull(api: api)
+        applyServerDrivenSettings(initial: true)
+
+        await store.loadWritableCalendars(api: api)
+        // Reconcile per-calendar visibility with the server BEFORE the first
+        // load so a calendar hidden/shown on the web is honoured immediately
+        // (banished set correct before events are filtered).
+        _ = await store.reconcileCalendarVisibility(api: api)
+        groups = (try? await api.getGroups()) ?? []
+        // 1. Load current view immediately (visible)
+        let (s, e) = store.rangeForCurrentView()
+        await store.loadEvents(api: api, start: s, end: e)
+        // 2. Background prefetch for the configured range (non-blocking)
+        Task(priority: .background) {
+            await store.prefetchBackground(api: api, months: cacheMonths)
+        }
+        // 2b. Mirror Contacts birthdays into the bound birthday calendar, if the
+        //     user enabled it, then refresh so new birthdays appear immediately.
+        if BirthdaysImporter.isEnabled {
+            Task(priority: .background) {
+                await BirthdaysImporter.sync(api: api)
+                await forceReload()
+            }
+        }
+        // 3. Periodic settings + visibility pull (tied to this .task's lifetime).
+        while !Task.isCancelled {
+            try? await Task.sleep(for: .seconds(600))
+            if Task.isCancelled { break }
+            await syncFromServer()
+        }
+    }
+
+    /// Apply the server-driven "always sync" settings to the live store.
+    /// `weekStartsOnMonday` is applied every time; the default view is applied
+    /// only once at startup so it never overrides the user's manual switches.
+    private func applyServerDrivenSettings(initial: Bool) {
+        store.weekStartsOnMonday = (weekStartDay != "sunday")
+        if initial, !didApplyDefaultView {
+            didApplyDefaultView = true
+            if let vt = CalViewType(rawValue: defaultView) {
+                store.viewType = vt
+            }
+        }
+    }
+
+    /// Called on every navigation – instant if within cache, fetches otherwise.
+    private func onNavigate() async {
+        let (s, e) = store.rangeForCurrentView()
+        await store.loadEvents(api: api, start: s, end: e)
+    }
+
+    /// Re-fetch the visible range. With `force` it bypasses the cache so a just
+    /// created/edited event shows up immediately (the server is authoritative).
+    private func reloadVisible(force: Bool) async {
+        let (s, e) = store.rangeForCurrentView()
+        await store.loadEvents(api: api, start: s, end: e, force: force)
+    }
+
+    /// Called when cacheMonths setting changes – clear cache and re-prefetch.
+    private func recache() async {
+        store.invalidateCache()
+        await startup()
+    }
+
+    /// Manual sync from the menu: drop the event cache and re-fetch from the
+    /// server (the periodic loop in `startup()` is untouched, so we don't spawn
+    /// a second one). Settings were already pulled by the menu action.
+    private func forceReload() async {
+        store.invalidateCache()
+        let (s, e) = store.rangeForCurrentView()
+        await store.loadEvents(api: api, start: s, end: e)
+        Task(priority: .background) {
+            await store.prefetchBackground(api: api, months: cacheMonths)
+        }
+    }
+
+    /// Pull server-driven settings AND reconcile per-calendar visibility in one
+    /// step (used on launch, resume and the periodic loop). If the server
+    /// changed a calendar's `sidebar_hidden` — e.g. hidden/shown on the web or
+    /// another device — or `force` is set (manual sync), refetch so the change
+    /// shows up without the user opening the filter sheet.
+    private func syncFromServer(force: Bool = false) async {
+        await SettingsSync.pull(api: api)
+        // Mirror Contacts birthdays on every server sync (manual, resume,
+        // periodic) — the user expects "sync with server" to include birthdays.
+        if BirthdaysImporter.isEnabled { await BirthdaysImporter.sync(api: api) }
+        let changed = await store.reconcileCalendarVisibility(api: api)
+        if changed || force { await forceReload() }
+    }
+
+    /// Called when the user scrolls into a new month – refreshes the visible range
+    /// immediately from cache, then fetches on demand if needed.
+    private func ensureLoaded(around month: Date) async {
+        let cal = store.userCalendar
+        let monthStart = cal.date(from: cal.dateComponents([.year, .month], from: month)) ?? month
+        let s = cal.date(byAdding: .month, value: -1, to: monthStart) ?? monthStart
+        let e = cal.date(byAdding: .month, value:  2, to: monthStart) ?? monthStart
+
+        // Only narrow the visible event set if the requested window is already cached.
+        // Otherwise keep the current events visible until the network fetch finishes,
+        // so previous/current/next month events don't disappear temporarily.
+        if store.isCached(start: s, end: e) {
+            store.refreshFromCache(start: s, end: e)
+        }
+
+        await store.loadEvents(api: api, start: s, end: e)
+    }
+}
+
+// MARK: – Shared sheet modifier
+
+private struct CalendarSheets: ViewModifier {
+    let store: CalendarStore
+    @Binding var editorContext: CalEditorContext?
+    @Binding var selectedEvent: CalEvent?
+    @Binding var showFilter: Bool
+    @Binding var showNewBirthday: Bool
+    let api: CalendarrAPI
+    let reload: () async -> Void
+    let reloadForce: () async -> Void
+
+    func body(content: Content) -> some View {
+        content
+            .sheet(isPresented: $showNewBirthday) {
+                BirthdayEditorSheet(api: api) { await reloadForce() }
+            }
+            // Use sheet(item:) so the editing event is captured atomically –
+            // avoiding the race where sheet(isPresented:) evaluates its content
+            // before the editingEvent state update propagates.
+            .sheet(item: $editorContext) { ctx in
+                let editingEv: CalEvent? = { if case .edit(let ev) = ctx { return ev }; return nil }()
+                let date: Date = { if case .create(let d) = ctx { return d }; return .now }()
+                EventEditorSheet(api: api, store: store,
+                                 initialDate: date, editingEvent: editingEv) {
+                    editorContext = nil
+                    await reloadForce()
+                }
+            }
+            .sheet(item: $selectedEvent) { ev in
+                EventDetailSheet(event: ev, api: api, store: store) { updated, needsForce in
+                    selectedEvent = nil
+                    if let u = updated { editorContext = .edit(u) }
+                    if needsForce { await reloadForce() } else { await reload() }
+                }
+            }
+            .sheet(isPresented: $showFilter) {
+                CalendarFilterSheet(api: api, store: store)
+            }
+    }
+}