스냅숏 하나, 읽는 쪽은 여럿

    /// Current state of the given tiles, the after-half of an undo step. The
    /// snapshot shares the live buffers (frozen); the store copies on its next write.
    public func snapshot(of keys: some Sequence<TileKey>) -> TileSnapshot {
        var snapshot: TileSnapshot = [:]
        for key in keys {
            snapshot.updateValue(tiles[key]?.freeze(), forKey: key)
        }
        return snapshot
    }

    /// Writes a snapshot back (undo or redo). The store shares the snapshot's
    /// frozen buffers, so the snapshot never changes.
    public func restore(_ snapshot: TileSnapshot) {
        for (key, tile) in snapshot {
            setTile(tile?.freeze(), at: key)
        }
    }

/// Undo and redo stacks, bounded by bytes and by count.
///
/// History owns frozen tile copies; applying a step copies again, so the
/// stacks never alias live layer tiles.
public final class History {

// A minimal sketch of one frozen buffer with many readers: undo history,
// a duplicate layer and the live store all hold the same object, and the
// store's copy-on-write keeps each of them from seeing another's writes.
final class Buffer {
    var value: Int
    private(set) var isFrozen = false
    init(_ value: Int) { self.value = value }
    @discardableResult func freeze() -> Buffer { isFrozen = true; return self }
}

final class Store {
    private(set) var tiles: [Int: Buffer] = [:]
    private(set) var copies = 0

    func writableTile(at key: Int) -> Buffer {
        if let tile = tiles[key] {
            guard tile.isFrozen else { return tile }
            copies += 1
            let copy = Buffer(tile.value)
            tiles[key] = copy
            return copy
        }
        let tile = Buffer(0)
        tiles[key] = tile
        return tile
    }

    func setTile(_ tile: Buffer?, at key: Int) { tiles[key] = tile }  // takes it as it is: frozen stays shared
    func snapshot(_ key: Int) -> Buffer? { tiles[key]?.freeze() }
    func restore(_ tile: Buffer?, at key: Int) { setTile(tile?.freeze(), at: key) }  // shares, never copies
}

let layer = Store()
layer.writableTile(at: 0).value = 10                 // the canvas before the stroke
let before = layer.snapshot(0)                       // history's before-state (frozen, shared)
layer.writableTile(at: 0).value = 20                 // the stroke: copies once, writes the copy
let after = layer.snapshot(0)                        // history's after-state IS the live tile

let duplicate = Store()                              // Duplicate Layer: share every tile, copy none
duplicate.setTile(layer.snapshot(0), at: 0)
print("duplicate shares the live tile:", duplicate.tiles[0]! === layer.tiles[0]!)

layer.restore(before, at: 0)                         // undo: the store now holds history's buffer
print("after undo, live tile is history's before-state:", layer.tiles[0]! === before!)

layer.writableTile(at: 0).value = 99                 // paint after the undo
print("history before =", before!.value, " history after =", after!.value,
      " duplicate =", duplicate.tiles[0]!.value, " live =", layer.tiles[0]!.value)
print("copies made by the live store:", layer.copies)

// Output (swiftc -swift-version 6):
// duplicate shares the live tile: true
// after undo, live tile is history's before-state: true
// history before = 10  history after = 20  duplicate = 20  live = 99
// copies made by the live store: 2