@@ -0,0 +1,5 @@
+---
+'zero-swift': patch
+---
+
+Add `Zero.mutationOutcomes` and `Zero.addMutationOutcomeListener(_:)`, which report the server's outcome of every mutation once, including mutations replayed after a disconnect, whose `server` already settled with `.zeroError`.
@@ -293,6 +293,21 @@ public enum MutationOutcome: Sendable, Hashable {
   }
 }
 
+/// The server's outcome of a mutation this client made, reported by
+/// ``Zero/mutationOutcomes`` and ``Zero/addMutationOutcomeListener(_:)``.
+/// Swift only: the JS client has no counterpart.
+public struct MutationServerOutcome: Sendable, Hashable {
+  /// The mutation's ID, counted per client from 1.
+  public var mutationID: Int
+  /// The mutator's name, such as `issue.create`.
+  public var name: String
+  /// The mutator's arguments.
+  public var args: JSONValue?
+  /// `.success` or `.appError`, with the server's data or message; or
+  /// `.zeroError` when the server reported a mutation it couldn't process.
+  public var outcome: MutationOutcome
+}
+
 /// What `zero.mutate` returns: the outcome of the optimistic run on the
 /// client, and the server's.
 @MainActor
 
@@ -213,6 +213,7 @@ final class Engine {
       ackMutations: { [weak self] id in self?.sendIfConnected(.ackMutationResponses(id)) },
       onFatalError: { [weak self] error in self?.disconnect(error) })
     mutationTracker.setClientID(clientID)
+    mutationTracker.onOutcome = { [weak self] outcome in self?.onMutationOutcome?(outcome) }
     context = QueryContext(
       branch: ivmMain,
       addCustomQuery: { [weak self] ast, id, ttl, got in
@@ -1017,6 +1018,8 @@ final class Engine {
   /// What `Zero` does when the app must be updated to sync, besides calling
   /// `ZeroOptions.onUpdateNeeded`.
   var onUpdateNeeded: ((UpdateNeededReason) -> Void)?
+  /// Hears the server's outcome of each mutation this client made.
+  var onMutationOutcome: ((MutationServerOutcome) -> Void)?
 
   private func clientStateNotFound() {
     if let onClientStateNotFound {
@@ -1186,7 +1189,7 @@ final class Engine {
     let mutationID = store.nextMutationID(for: clientID)
     let write = KVWrite(store.main)
     let branch = ivmMain.fork()
-    mutationTracker.mutationIDAssigned(ephemeralID, mutationID)
+    mutationTracker.mutationIDAssigned(ephemeralID, mutationID, name: name, args: args ?? .null)
     let tx = Transaction(
       clientID: clientID, mutationID: Int(mutationID), reason: .optimistic, token: token,
       write: write, branch: branch, schema: schema)
 
@@ -49,6 +49,13 @@ final class MutationTracker {
   private var clientID: String?
   private var largestOutstandingMutationID: Double = 0
   private var currentMutationID: Double = 0
+  /// The mutations sent to the server whose outcome hasn't been reported,
+  /// by mutation ID. Unlike `outstanding`, they stay when the connection
+  /// gives up on them: they're sent again on reconnect, and their outcome
+  /// is reported then.
+  private var unreported: [Double: (name: String, args: JSONValue?)] = [:]
+  /// Hears each mutation's outcome from the server once.
+  var onOutcome: ((MutationServerOutcome) -> Void)?
 
   private let ackMutations: (MutationID) -> Void
   private let onFatalError: (ConnectionError) -> Void
@@ -77,8 +84,11 @@ final class MutationTracker {
     return (nextEphemeralID, server)
   }
 
-  func mutationIDAssigned(_ ephemeralID: Int, _ mutationID: Double) {
+  func mutationIDAssigned(
+    _ ephemeralID: Int, _ mutationID: Double, name: String, args: JSONValue?
+  ) {
     guard let entry = entry(ephemeralID) else { return }
+    unreported[mutationID] = (name, args)
     entry.mutationID = mutationID
     ephemeralIDsByMutationID[mutationID] = ephemeralID
     largestOutstandingMutationID = max(largestOutstandingMutationID, mutationID)
@@ -87,6 +97,7 @@ final class MutationTracker {
   /// Rejects a mutation the client could not run. It was not stored.
   func rejectMutation(_ ephemeralID: Int, _ error: any Error) {
     guard let entry = entry(ephemeralID) else { return }
+    if let mid = entry.mutationID { unreported[mid] = nil }
     settle(ephemeralID, entry, .failure(ApplicationError.wrapping(error)))
   }
 
@@ -172,6 +183,10 @@ final class MutationTracker {
     }
     if lastMutationID == currentMutationID { return }
     currentMutationID = lastMutationID
+    // Applied without a result of their own: they succeeded.
+    for mid in unreported.keys.filter({ $0 <= lastMutationID }).sorted() {
+      report(mid, .success(nil))
+    }
     while head < order.count {
       let id = order[head]
       if let entry = outstanding[id] {
@@ -205,29 +220,24 @@ final class MutationTracker {
     guard clientID == self.clientID else {
       throw ConnectionError.client(.internal, message: "received mutation for the wrong client")
     }
-    guard let ephemeralID = ephemeralIDsByMutationID[mid], let entry = entry(ephemeralID) else {
-      return
-    }
     let kind = error.error.stringValue ?? ""
     if kind == "alreadyProcessed" { return }
+    let failure: any Error
     if kind == "app" {
-      settle(
-        ephemeralID, entry,
-        .failure(
-          ApplicationError(
-            error.message?.stringValue ?? "Unknown application error: app",
-            details: error.details)))
+      failure = ApplicationError(
+        error.message?.stringValue ?? "Unknown application error: app", details: error.details)
     } else {
       let message =
         kind == "oooMutation"
         ? "Server reported an out-of-order mutation"
         : "Unknown fallback error with mutation ID \(JSNumber.format(mid)): \(kind)"
-      settle(
-        ephemeralID, entry,
-        .failure(
-          ConnectionError.server(
-            .basic(BasicErrorBody(kind: .invalidPush, message: message, origin: .server)))))
+      failure = ConnectionError.server(
+        .basic(BasicErrorBody(kind: .invalidPush, message: message, origin: .server)))
+    }
+    if let ephemeralID = ephemeralIDsByMutationID[mid], let entry = entry(ephemeralID) {
+      settle(ephemeralID, entry, .failure(failure))
     }
+    report(mid, .failure(failure))
     if kind == "oooMutation" {
       onFatalError(
         .server(
@@ -242,10 +252,23 @@ final class MutationTracker {
     guard clientID == self.clientID else {
       throw ConnectionError.client(.internal, message: "received mutation for the wrong client")
     }
-    guard let ephemeralID = ephemeralIDsByMutationID[mid], let entry = entry(ephemeralID) else {
-      return
+    if let ephemeralID = ephemeralIDsByMutationID[mid], let entry = entry(ephemeralID) {
+      settle(ephemeralID, entry, .success(data))
     }
-    settle(ephemeralID, entry, .success(data))
+    report(mid, .success(data))
+  }
+
+  /// Reports the outcome of mutation `mid`, the first time the server gives
+  /// one.
+  private func report(_ mid: Double, _ result: Result<JSONValue?, any Error>) {
+    guard let m = unreported.removeValue(forKey: mid) else { return }
+    let outcome: MutationOutcome =
+      switch result {
+      case .success(let data): .success(data: data)
+      case .failure(let error): Engine.outcome(error)
+      }
+    onOutcome?(
+      MutationServerOutcome(mutationID: Int(mid), name: m.name, args: m.args, outcome: outcome))
   }
 
   private func settle(_ ephemeralID: Int, _ entry: Entry, _ result: Result<JSONValue?, any Error>) {
 
@@ -21,6 +21,8 @@ public final class Zero<Context: Sendable> {
   /// The views and preloads to move to a new client.
   private var views: [WeakView] = []
   private var preloads: [PreloadRecord] = []
+  private var outcomeListeners: [(id: Int, listener: (MutationServerOutcome) -> Void)] = []
+  private var nextOutcomeListenerID = 0
   #if canImport(Darwin)
     private var lifecycle: AppLifecycle?
   #endif
@@ -77,6 +79,45 @@ public final class Zero<Context: Sendable> {
       engine.onClientStateNotFound = { [weak self] in self?.replaceClient() }
     }
     engine.onUpdateNeeded = { [weak self] reason in self?.connection.updateNeeded = reason }
+    engine.onMutationOutcome = { [weak self] outcome in
+      for (_, l) in self?.outcomeListeners ?? [] { l(outcome) }
+    }
+  }
+
+  /// Calls `listener` with the server's outcome of each mutation this
+  /// client makes from now on, once per mutation, as the server reports it.
+  ///
+  /// Unlike a mutation's `server` result, it hears the outcome of a
+  /// mutation sent again after the connection came back: `server` settles
+  /// with `.zeroError` when the client gives up connecting
+  /// (`disconnectTimeoutMs`), and the mutation is replayed when it
+  /// reconnects. A mutation still pending when the app quits is replayed
+  /// when it next launches, but its outcome isn't reported.
+  ///
+  /// Use it for a single place that shows rejections, instead
+  /// of each `server` result, so a rejection isn't shown twice. Swift only:
+  /// the JS client has no counterpart.
+  @discardableResult
+  public func addMutationOutcomeListener(
+    _ listener: @escaping (MutationServerOutcome) -> Void
+  ) -> () -> Void {
+    let id = nextOutcomeListenerID
+    nextOutcomeListenerID += 1
+    outcomeListeners.append((id, listener))
+    return { [weak self] in self?.outcomeListeners.removeAll { $0.id == id } }
+  }
+
+  /// The server's outcomes of the mutations this client makes, as
+  /// ``addMutationOutcomeListener(_:)`` hears them, until the iterating
+  /// task is cancelled.
+  public var mutationOutcomes: AsyncStream<MutationServerOutcome> {
+    let (stream, continuation) = AsyncStream<MutationServerOutcome>.makeStream()
+    let id = nextOutcomeListenerID
+    _ = addMutationOutcomeListener { continuation.yield($0) }
+    continuation.onTermination = { [weak self] _ in
+      Task { @MainActor in self?.outcomeListeners.removeAll { $0.id == id } }
+    }
+    return stream
   }
 
   /// Replaces the client, which can't sync any longer, by a new one on the
 
@@ -148,6 +148,16 @@ is written or sent.
   Freeing one still recurses: in a release build 1,500 levels fit in a
   512 KB stack (a macOS test or cooperative thread), but a debug build
   overflows one when it frees objects nested more than about 1,000 deep.
+- **Mutation outcomes after a disconnect (Swift only).** As in JS, when
+  the connection drops before the server answers a mutation, its `server`
+  settles with `.zeroError` and doesn't settle again after the mutation is
+  replayed. JS has no way to learn the replay's result. Swift adds
+  ``Zero/mutationOutcomes`` and ``Zero/addMutationOutcomeListener(_:)``,
+  which report the server's outcome of every mutation once, with its
+  mutator name and arguments, including mutations replayed after their
+  `server` gave up (but not mutations from before the app last launched).
+  To show a rejection, use either the stream or `server`,
+  not both, or the user sees it twice.
 - **Storage.** The replica is a SQLite database per user and URL, not
   IndexedDB. One process uses it at a time; there are no tabs to share it
   with.
@@ -122,6 +122,67 @@ import ZeroTesting
     #expect(try await zero.run(zql.issue).map(\.title) == ["t"])
   }
 
+  /// The outcomes stream hears each mutation's server outcome once,
+  /// including those of mutations replayed after `server` gave up on them.
+  @Test func reportsServerOutcomesOfMutationsReplayedAfterADisconnect() async throws {
+    let zero = try makeZero()
+    var outcomes: [MutationServerOutcome] = []
+    _ = zero.addMutationOutcomeListener { outcomes.append($0) }
+    func connect() throws -> MockSocket {
+      scheduler.runDueTimers()
+      let socket = try #require(sockets.sockets.last)
+      socket.receive(text: #"["connected",{"wsid":"w"}]"#)
+      scheduler.runDueTimers()
+      return socket
+    }
+    func poke(_ socket: MockSocket, _ base: String, _ cookie: String, _ part: String) {
+      socket.receive(text: #"["pokeStart",{"pokeID":"\#(cookie)","baseCookie":\#(base)}]"#)
+      socket.receive(text: #"["pokePart",{"pokeID":"\#(cookie)",\#(part)}]"#)
+      socket.receive(text: #"["pokeEnd",{"pokeID":"\#(cookie)","cookie":"\#(cookie)"}]"#)
+      scheduler.runDueTimers()
+    }
+    let cid = zero.clientID
+
+    let first = try connect()
+    let one = zero.mutate(Self.create(CreateIssue(id: "i1", title: "one")))
+    scheduler.runDueTimers()
+    poke(first, "null", "01", #""lastMutationIDChanges":{"\#(cid)":1}"#)
+    #expect(try await one.server.value == .success(data: nil))
+
+    // The server goes away with two mutations unconfirmed, and the client
+    // gives up on it.
+    let two = zero.mutate(Self.create(CreateIssue(id: "i2", title: "two")))
+    let three = zero.mutate(Self.create(CreateIssue(id: "i3", title: "three")))
+    scheduler.runDueTimers()
+    first.serverClose()
+    for _ in 0..<70 { scheduler.advance(by: 1_000) }
+    guard case .zeroError = try await two.server.value else {
+      Testing.Issue.record("the server result of a mutation the client gave up on")
+      return
+    }
+    guard case .zeroError = try await three.server.value else { return }
+
+    // It comes back: the two are replayed, and it rejects one.
+    scheduler.advance(by: 5_000)
+    let second = try connect()
+    poke(
+      second, #""01""#, "02",
+      #""lastMutationIDChanges":{"\#(cid)":3},"mutationsPatch":[{"op":"put","mutation":{"id":{"clientID":"\#(cid)","id":2},"result":{"error":"app","message":"taken"}}}]"#
+    )
+    #expect(
+      outcomes == [
+        MutationServerOutcome(
+          mutationID: 1, name: "issue.create", args: ["id": "i1", "title": "one"],
+          outcome: .success(data: nil)),
+        MutationServerOutcome(
+          mutationID: 2, name: "issue.create", args: ["id": "i2", "title": "two"],
+          outcome: .appError(message: "taken", details: nil)),
+        MutationServerOutcome(
+          mutationID: 3, name: "issue.create", args: ["id": "i3", "title": "three"],
+          outcome: .success(data: nil)),
+      ])
+  }
+
   @Test func anUnregisteredMutatorFailsWithoutWritingOrPushing() async throws {
     let zero = try makeZero()
     scheduler.runDueTimers()
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +'zero-swift': patch
 +---
++
 +Add `Zero.mutationOutcomes` and `Zero.addMutationOutcomeListener(_:)`, which report the server's outcome of every mutation once, including mutations replayed after a disconnect, whose `server` already settled with `.zeroError`.