캔버스는 언제나 펜 차지야

    private func reclaimCanvas(for touches: Set<UITouch>) {
        guard let active = activeTouch, !touches.contains(active) else { return }
        let pencilLands = touches.contains { $0.type == .pencil }
        if active.phase == .ended || active.phase == .cancelled || (pencilLands && active.type == .pencil) {
            finishActiveTouch(event: nil)
        } else if pencilLands {
            abandonActiveTouch()
        }
    }

    /// Procreate's Palm Support Mode: how broad a touch must be to be taken
    /// for a resting hand and ignored.
    enum PalmSupport: String, Codable, CaseIterable, Identifiable {
        case off
        /// Only plainly broad touches: a palm laid flat.
        case standard
        /// Narrower ones too: the edge of the hand, at the cost of a broad fingertip now and then.
        case fine

        /// The touch radius, in points, from which a touch is a palm.
        var threshold: CGFloat? {
            switch self {
            case .off: nil
            case .standard: 42
            case .fine: 30
            }
        }

        func isPalm(majorRadius: CGFloat) -> Bool {
            threshold.map { majorRadius >= $0 } ?? false
        }
    }

// A minimal sketch of the canvas's one-touch rule, before and after
// reclaimCanvas: the canvas holds a touch whose touchesEnded never arrives.
enum Kind { case pencil, finger }
enum Phase { case began, moved, ended, cancelled }
final class Touch {
    let kind: Kind
    var phase = Phase.began
    init(_ kind: Kind) { self.kind = kind }
}

final class Canvas {
    var active: Touch?
    let reclaims: Bool
    init(reclaims: Bool) { self.reclaims = reclaims }

    /// touchesBegan: returns whether this touch got the canvas.
    func lands(_ touch: Touch) -> Bool {
        if reclaims, let held = active, held !== touch {
            let pencilLands = touch.kind == .pencil
            if held.phase == .ended || held.phase == .cancelled || (pencilLands && held.kind == .pencil) {
                active = nil                       // finished as if lifted
            } else if pencilLands {
                active = nil                       // a finger's work is abandoned
            }
        }
        guard active == nil else { return false }
        active = touch
        return true
    }

    /// touchesEnded, when UIKit delivers it.
    func lifts(_ touch: Touch) { if active === touch { active = nil } }
}

// Which touch lost its end was never reproduced, so try three shapes of it.
let stuck: [(String, Kind, Phase)] = [
    ("finger, ended", .finger, .ended),       // UIKit marked it ended; the view never heard
    ("finger, still down", .finger, .moved),  // a finger really resting on the glass
    ("pencil, end lost", .pencil, .moved),    // an earlier Pencil touch never finished
]
for reclaims in [false, true] {
    for (name, kind, phase) in stuck {
        let canvas = Canvas(reclaims: reclaims)
        let held = Touch(kind)
        _ = canvas.lands(held)
        held.phase = phase
        var strokes: [Bool] = []
        for _ in 0..<3 {                           // three Pencil strokes
            let pencil = Touch(.pencil)
            strokes.append(canvas.lands(pencil))
            pencil.phase = .ended
            canvas.lifts(pencil)
        }
        print(reclaims ? "with reclaim, " : "no reclaim,   ", name + String(repeating: " ", count: 18 - name.count), strokes)
    }
}

// Prints:
// no reclaim,    finger, ended      [false, false, false]
// no reclaim,    finger, still down [false, false, false]
// no reclaim,    pencil, end lost   [false, false, false]
// with reclaim,  finger, ended      [true, true, true]
// with reclaim,  finger, still down [true, true, true]
// with reclaim,  pencil, end lost   [true, true, true]