What Survives a Relaunch: Memory, Defaults, JSON, and SwiftData

Where did the note go?

You typed it. You saw it on screen. You killed the app. On the next launch three stores still had "Harbor build 418" and one showed a dash. That dash is not a bug in the demo — it is the control.

Four stores, one string

static let seededValue = "Harbor build 418"

Capture does this for real: one process with -mode seed, then a new process with -mode reload that only reads. No fake "clear memory" button.

Right after the write, everything agrees. MEMORY says LIVE. The durable three already say SURVIVED because the read-back came from disk, not from hope.

After kill

Footer on that still: MODE RELOAD · AFTER KILL.

How each survivor is written

UserDefaults — one key, one string:

UserDefaults.standard.set(text, forKey: Self.noteKey)
// …
defaultsValue = UserDefaults.standard.string(forKey: Self.noteKey) ?? "—"

Fine for small preferences. Wrong for large documents, and invisible when you forget the key name.

JSON file — the Saving Files pattern from SwiftUI Apprentice, narrowed to one note:

struct NoteFile: Codable { var text: String }
 
try JSONEncoder().encode(NoteFile(text: text))
  .write(to: jsonURL, options: .atomic)

Atomic write matters: a half-written file after a kill is how "JSON survived" becomes "JSON corrupted."

SwiftData — a one-field @Model in a file-backed container under Application Support:

@Model
final class PersistedNote {
  var text: String
  init(text: String) { self.text = text }
}

Same string came back. The point of this bench is not schema design — it is that choosing any durable store beats pretending @State would remember.

Mini-exercise

In reloadAll(), restore memory from UserDefaults "to be helpful." Re-run -mode reload. MEMORY will falsely say LIVE. You just destroyed the control — put the blanking back.

Challenges

1. Delete the JSON file in Finder between seed and reload; photograph JSON MISS while Defaults and SwiftData still survive.
2. Switch the SwiftData ModelConfiguration to isStoredInMemoryOnly: true and show it joins MEMORY in the GONE column after kill.
3. Write a second field (updatedAt) only to SwiftData and show the JSON card cannot display it without a format bump — motivate migrations (next queue item).
4. Use ScenePhase.background to seed Defaults automatically and prove a background write still survives kill.
5. XCUITest: launch seed, terminate via XCUIApplication().terminate(), relaunch reload, assert MEMORY accessibility value is the dash and SWIFTDATA contains 418.

Key Points

• @State dies with the process — relaunch still shows — / GONE.
• UserDefaults, JSON in Documents, and SwiftData all returned Harbor build 418 after a real kill.
• Seed and reload are separate process launches (-mode seed then -mode reload), not an in-app reset.
• Atomic JSON writes avoid half-file corruption across kills.
• SwiftData here is a single @Model string — enough to prove durability, not an app architecture.
• The seeded still makes MEMORY look fine; only AFTER KILL exposes the control.
• Pick storage by lifetime need: preferences → Defaults; documents → files/SwiftData; screen chrome → @State.
• Next failure mode is schema change — surviving bytes you can no longer read.

Next up: migrations — load a store written by an older schema; one build migrates, one crashes; show the actual error text.