fix(sync): propagate local unsubscribes via a three-way merge

    // MARK: Sync (subscriptions)

    /// Pulls remote subscription changes, applies them locally, then pushes the

    /// local subscription set. Subscription sync only — played/position sync

    /// requires local play-state persistence (not yet implemented).

    /// Reconciles subscriptions with the server via a three-way merge against

    /// the last-synced baseline: remote-only changes are applied locally and

    /// local-only changes (adds *and* removes) are pushed, so edits on one

    /// device never clobber another's. Then syncs episode play actions.

    func syncNow() async {

        guard let credentials = syncSettings.credentials() else {

            syncMessage = String(localized: "Configurez d'abord la synchronisation.")

        defer { isSyncing = false }

        let provider = makeSyncProvider(credentials)

        do {

            let changes = try await provider.subscriptionChanges(since: syncSettings.lastTimestamp)

            for url in changes.add where !isSubscribed(feedURL: url) {

            // Robust multi-device subscription sync via a three-way merge

            // against the last-synced baseline. Both backends return the full

            // list for `since: nil`, so we diff server-vs-baseline and

            // local-vs-baseline and apply/push only genuine changes — a podcast

            // added on another device is never mistaken for a local removal.

            let remote = try await provider.subscriptionChanges(since: nil)

            let serverNow = Set(remote.add)

            let localNow = Set(podcasts.map(\.feedURL))

            var newTimestamp: Int?

            if syncSettings.hasSyncedSubscriptions {

                let baseline = syncSettings.syncedSubscriptions

                let localAdds = localNow.subtracting(baseline)

                let localRemoves = baseline.subtracting(localNow)

                let remoteAdds = serverNow.subtracting(baseline)

                let remoteRemoves = baseline.subtracting(serverNow)

                // Apply remote-only changes locally.

                for url in remoteAdds where !isSubscribed(feedURL: url) {

                    await subscribe(feedURL: url)

                }

            for url in changes.remove {

                for url in remoteRemoves {

                    if let podcast = podcasts.first(where: { $0.feedURL == url }) {

                        await unsubscribe(podcast)

                    }

                }

            let newTimestamp = try await provider.uploadSubscriptionChanges(

                add: podcasts.map(\.feedURL), remove: []

            )

            syncSettings.lastTimestamp = newTimestamp ?? changes.timestamp ?? syncSettings.lastTimestamp

                // Push only what changed locally — never the whole set.

                if !localAdds.isEmpty || !localRemoves.isEmpty {

                    newTimestamp = try await provider.uploadSubscriptionChanges(

                        add: Array(localAdds), remove: Array(localRemoves))

                }

            } else {

                // First sync (no baseline): union and never remove; removals

                // begin propagating from the next sync.

                for url in serverNow where !isSubscribed(feedURL: url) {

                    await subscribe(feedURL: url)

                }

                let localOnly = Array(localNow.subtracting(serverNow))

                if !localOnly.isEmpty {

                    newTimestamp = try await provider.uploadSubscriptionChanges(

                        add: localOnly, remove: [])

                }

            }

            syncSettings.lastTimestamp = newTimestamp ?? remote.timestamp ?? syncSettings.lastTimestamp

            // The reconciled local set becomes the baseline for the next sync.

            syncSettings.saveBaseline(Set(podcasts.map(\.feedURL)))

            try await syncEpisodeActions(using: provider)

    var password: String

    var lastTimestamp: Int?

    var lastEpisodeTimestamp: Int?

    /// Feed URLs in sync with the server as of the last successful sync — the

    /// baseline for computing local add/remove deltas (robust multi-device sync).

    private(set) var syncedSubscriptions: Set<URL>

    /// Whether a baseline has ever been recorded; distinguishes a first sync

    /// from "synced to an empty set".

    private(set) var hasSyncedSubscriptions: Bool

    @ObservationIgnored private let defaults = UserDefaults.standard

    private static let passwordAccount = "sync.password"

        lastTimestamp = stored == 0 ? nil : stored

        let storedEpisode = defaults.integer(forKey: "sync.epTimestamp")

        lastEpisodeTimestamp = storedEpisode == 0 ? nil : storedEpisode

        if let stored = defaults.array(forKey: "sync.baseline") as? [String] {

            syncedSubscriptions = Set(stored.compactMap(URL.init(string:)))

            hasSyncedSubscriptions = true

        } else {

            syncedSubscriptions = []

            hasSyncedSubscriptions = false

        }

    }

    /// Records the set of subscriptions now in sync with the server, as the

    /// baseline for the next sync's delta computation.

    func saveBaseline(_ feeds: Set<URL>) {

        syncedSubscriptions = feeds

        hasSyncedSubscriptions = true

        defaults.set(feeds.map(\.absoluteString), forKey: "sync.baseline")

    }

    func save() {

        password = ""

        lastTimestamp = nil

        lastEpisodeTimestamp = nil

        for key in ["sync.kind", "sync.server", "sync.user", "sync.timestamp", "sync.epTimestamp"] {

        syncedSubscriptions = []

        hasSyncedSubscriptions = false

        for key in ["sync.kind", "sync.server", "sync.user", "sync.timestamp", "sync.epTimestamp", "sync.baseline"] {

            defaults.removeObject(forKey: key)

        }

        KeychainStore.delete(account: Self.passwordAccount)