Versioning

let timeline = try await storage.timeline(spaceId: space.id)

// Timeline properties
print("Start: \(timeline.startDate)")
print("End: \(timeline.endDate)")
print("Total events: \(timeline.events.count)")
print("Unique anchors: \(timeline.anchorIds.count)")

// Get anchors as they existed yesterday
let yesterday = Calendar.current.date(byAdding: .day, value: -1, to: Date())!
let anchors = try await storage.anchorsAt(spaceId: space.id, date: yesterday)

for anchor in anchors {
    let position = anchor.position
    print("Anchor at \(position)")
}

let oneWeekAgo = Calendar.current.date(byAdding: .day, value: -7, to: Date())!
let diff = try await storage.diff(spaceId: space.id, from: oneWeekAgo, to: Date())

print(diff.summary) // "3 added, 1 removed, 2 moved"

// Inspect specific changes
for added in diff.added {
    print("New anchor: \(added.id)")
}

for moved in diff.moved {
    print("Moved \(moved.distanceMoved)m: \(moved.anchor.id)")
}

for updated in diff.updated {
    print("Changed keys: \(updated.changedKeys)")
}

let events = try await storage.history(anchorId: anchor.id)

for event in events {
    print("\(event.timestamp): \(event.type) (v\(event.version))")
}

// Restore anchor to version 3
let restored = try await storage.rollback(anchorId: anchor.id, toVersion: 3)
print("Restored to v3: \(restored.metadata)")

public enum EventType: String, Codable {
    case created   // Anchor was created
    case moved     // Transform changed
    case updated   // Metadata changed
    case deleted   // Anchor was deleted
    case restored  // Anchor restored from deletion or rollback
}

// Created via HBStorage
let timeline = try await storage.timeline(spaceId: space.id)

// Query events
func events(for anchorId: UUID) -> [HBAnchorEvent]
func events(from: Date, to: Date) -> [HBAnchorEvent]
func events(ofType type: EventType) -> [HBAnchorEvent]

// State reconstruction
func state(at date: Date) -> [HBAnchor]

// Diff generation
func diff(from: Date, to: Date) -> HBDiff

// UI helpers
func scrubberDates(from: Date?, to: Date?, steps: Int) -> [Date]
func closestEvent(to date: Date) -> HBAnchorEvent?
var significantDates: [Date]

var changeCount: Int      // Total number of changes
var hasChanges: Bool      // Whether any changes occurred
var summary: String       // "3 added, 1 removed, 2 moved"
var currentAnchors: [HBAnchor]   // All anchors at `to` date
var previousAnchors: [HBAnchor]  // All anchors at `from` date

struct MovedAnchor {
    let anchor: HBAnchor           // Current state
    let previousTransform: [Float] // Transform at `from` date

    var previousPosition: SIMD3<Float>  // Extracted from transform
    var currentPosition: SIMD3<Float>   // From current anchor
    var distanceMoved: Float            // Distance in meters
}

struct UpdatedAnchor {
    let anchor: HBAnchor
    let previousMetadata: [String: AnyCodableValue]

    var addedKeys: Set<String>    // New keys
    var removedKeys: Set<String>  // Deleted keys
    var changedKeys: Set<String>  // Keys with different values
}

struct TimeMachineView: View {
    @State private var scrubberPosition: Double = 1.0
    @State private var currentAnchors: [HBAnchor] = []

    let timeline: HBTimeline
    let scrubberDates: [Date]

    var body: some View {
        VStack {
            // AR View showing currentAnchors
            ARViewContainer(anchors: currentAnchors)

            // Time scrubber
            Slider(value: $scrubberPosition, in: 0...1)
                .onChange(of: scrubberPosition) { _, newValue in
                    let index = Int(newValue * Double(scrubberDates.count - 1))
                    let date = scrubberDates[index]
                    currentAnchors = timeline.state(at: date)
                }
        }
    }
}

func showRecentChanges() async {
    let lastWeek = Calendar.current.date(byAdding: .day, value: -7, to: Date())!
    let diff = try await storage.diff(spaceId: space.id, from: lastWeek, to: Date())

    if diff.hasChanges {
        print("Last 7 days: \(diff.summary)")
    }
}

func undoLastChange(for anchorId: UUID) async throws {
    let events = try await storage.history(anchorId: anchorId)
    guard events.count > 1 else { return } // Need at least 2 versions

    let previousVersion = events[events.count - 2].version
    try await storage.rollback(anchorId: anchorId, toVersion: previousVersion)
}

case versionNotFound(anchorId: UUID, version: Int)
case reconstructionFailed(anchorId: UUID)
case eventLogCorrupted(spaceId: UUID)