Seed starter splits deterministically with immutable clone-on-edit seeds

Starter splits ship as byte-canonical SplitDocument JSON with fixed ULIDs (Workouts/Resources/StarterSplits, regenerated by Scripts/generate_starter_splits.swift) and auto-seed after connect into a verifiably empty container, re-checked after a settle delay — wrong guesses are harmless because identical bytes make same-path conflicts empty and tombstones reap resurrected seeds. Seeds are immutable: SyncEngine.save(split:) forks an edited seed to a fresh ULID and soft-deletes the original, whose stub is exempt from pruning (IndieSync 0.3.0 prune(exempting:)) and vetoes resurrection forever; split views resolve by id through a redirect map to follow the swap. Add Starter Splits in Settings restores deleted seeds by lifting the veto stub and rewriting the bundle bytes. Also fixes ingestFromWatch bypassing the tombstone veto (a phone-deleted workout resurrected when a stale watch resent it) and reaps a live file immediately when its tombstone arrives. SplitDetailView also picks up the category-grouped exercise sections from the exercise-category work.
2026-07-06 01:16:05 -04:00
parent 7274f155e9
commit 936a585ece
16 changed files with 1088 additions and 242 deletions
@@ -0,0 +1,65 @@
+import Foundation
+import IndieSync
+
+/// The bundled immutable starter-split library. Each seed ships as byte-canonical
+/// `SplitDocument` JSON in `Resources/StarterSplits/*.split.json`, keyed by a fixed
+/// ULID (the shared `01DXF6DT00` prefix, minted from a frozen 2020 timestamp) so
+/// every install and device agrees on the same identity.
+///
+/// Seeds are never mutated in place: editing one clones it to a fresh random ULID
+/// and soft-deletes the seed (see `SyncEngine.save(split:)`). The seed's tombstone
+/// is exempt from pruning, so it vetoes resurrection forever; the app bundle — not
+/// the stub — is the canonical restore source, since the seed content is immutable.
+enum SeedLibrary {
+    /// One bundled seed: its fixed id, decoded document, and the verbatim bundle
+    /// bytes. The bytes are written to iCloud unchanged so the same seed is
+    /// byte-identical on every device — a same-path conflict between two devices
+    /// seeding at once is then semantically empty (both wrote the same bytes).
+    struct Seed: Sendable {
+        let id: String
+        let doc: SplitDocument
+        let data: Data
+    }
+
+    /// Resolves the enclosing bundle in both the app and a hosted XCTest bundle
+    /// (whose `Bundle.main` is the test runner, not the app), where the flattened
+    /// resources actually live.
+    private final class BundleToken {}
+
+    /// Every bundled seed, decoded once and cached, in display order.
+    static let seeds: [Seed] = {
+        let bundle = Bundle(for: BundleToken.self)
+        // XcodeGen flattens resource groups, so the files land in the bundle root as
+        // "<Name>.split.json" — enumerate all json and filter on the compound suffix.
+        let urls = (bundle.urls(forResourcesWithExtension: "json", subdirectory: nil) ?? [])
+            .filter { $0.lastPathComponent.hasSuffix(".split.json") }
+        let loaded: [Seed] = urls.compactMap { url in
+            guard let data = try? Data(contentsOf: url),
+                  let doc = try? DocumentCoder.decode(SplitDocument.self, from: data)
+            else { return nil }
+            return Seed(id: doc.id, doc: doc, data: data)
+        }
+        return loaded.sorted { $0.doc.order < $1.doc.order }
+    }()
+
+    static let seedIDs: Set<String> = Set(seeds.map(\.id))
+
+    static func isSeed(id: String) -> Bool { seedIDs.contains(id) }
+
+    static func seed(id: String) -> Seed? { seeds.first { $0.id == id } }
+
+    /// True when `doc` is unchanged from its pristine seed in every field except
+    /// `updatedAt`. The edit sheets stamp `updatedAt` on every Save, so a no-op save
+    /// would otherwise read as an edit and fork the seed; normalizing both timestamps
+    /// to a common value before the `==` isolates real changes. A non-seed id has no
+    /// seed to compare against — treated as pristine (callers gate on `isSeed` first).
+    static func isPristine(_ doc: SplitDocument) -> Bool {
+        guard let seed = seed(id: doc.id) else { return true }
+        var edited = doc
+        var pristine = seed.doc
+        let common = Date(timeIntervalSince1970: 0)
+        edited.updatedAt = common
+        pristine.updatedAt = common
+        return edited == pristine
+    }
+}