iOS 생명주기: 백그라운드는 평범한 일이고, 컨테이너는 옮겨가

import SwiftUI

@MainActor
@Observable
final class EngineSession {
    private(set) var isConnected = false
    func leaveForeground() {
        // Short and synchronous in spirit: save the draft, hand resting changes to the outbox,
        // close the socket. Backgrounding is the normal case for a remote client, not an error.
        isConnected = false
    }
    func returnToForeground() {
        // Reopen and replay from the record; never assume the socket survived.
        isConnected = true
    }
}

@main
struct SparkMobileApp: App {
    @Environment(\.scenePhase) private var scenePhase
    @State private var session = EngineSession()

    var body: some Scene {
        WindowGroup {
            Text(session.isConnected ? "Connected" : "Offline")
        }
        .onChange(of: scenePhase) { _, phase in
            switch phase {
            case .background: session.leaveForeground()
            case .active: session.returnToForeground()
            default: break
            }
        }
    }
}

import Foundation

/// Where the app's data lives on THIS launch. Re-derived every time, never stored:
/// an app update can move the whole container to a new path.
enum DeviceRoot {
    static func current(fileManager: FileManager = .default) throws -> URL {
        try fileManager.url(for: .applicationSupportDirectory, in: .userDomainMask,
                            appropriateFor: nil, create: true)
            .appending(path: "Spark", directoryHint: .isDirectory)
    }

    /// Records store paths RELATIVE to the root. A record written by an older build that
    /// stored an absolute path is rebased onto today's root by the part after the root folder.
    /// The FIRST occurrence is the root: a folder below it may carry the same name.
    static func resolve(_ stored: String, root: URL) -> URL {
        guard stored.hasPrefix("/") else { return root.appending(path: stored) }
        let marker = "/" + root.lastPathComponent + "/"
        guard let range = stored.range(of: marker) else { return URL(filePath: stored) }
        return root.appending(path: String(stored[range.upperBound...]))
    }
}

/// Device and inode survive the container's move; the path does not.
struct FileIdentity: Equatable, Sendable {
    let device: UInt64
    let inode: UInt64

    init?(url: URL) {
        var info = stat()
        guard lstat(url.path, &info) == 0 else { return nil }
        device = UInt64(UInt32(bitPattern: info.st_dev))
        inode = UInt64(info.st_ino)
    }
}