@@ -405,7 +405,7 @@ internal class SyncManager(
             logger.w { "[performSync] rejected (no events to emit)" }
             return SyncOutcome(syncedCids = syncedCids)
         }
-        if (rawLastSyncAt != null && rawLatestEventDate != null && sameInstant(rawLastSyncAt, rawLatestEventDate)) {
+        if (sameInstant(rawLastSyncAt, rawLatestEventDate)) {
             logger.w { "[performSync] rejected (rawLatestEventDate equals to rawLastSyncAt)" }
             return SyncOutcome(syncedCids = syncedCids)
         }
@@ -1148,8 +1148,8 @@ internal class SyncManager(
  * don't parse are compared as written.
  */
 @OptIn(ExperimentalTime::class)
-internal fun sameInstant(raw: String, other: String): Boolean {
-    val instant = Instant.parseOrNull(raw)
-    val otherInstant = Instant.parseOrNull(other)
+internal fun sameInstant(raw: String?, other: String?): Boolean {
+    val instant = raw?.let(Instant::parseOrNull)
+    val otherInstant = other?.let(Instant::parseOrNull)
     return if (instant != null && otherInstant != null) instant == otherInstant else raw == other
 }
@@ -127,10 +127,24 @@ internal class V2EventParser(
      * Parses the events a `/sync` response replays, each as the socket delivers it, leaving out those the SDK
      * ignores. An event that fails to parse is skipped and the rest are replayed: failing the response would keep the
      * sync cursor where it is, so every later sync would ask for the same events and fail on the same one. A response
-     * whose envelope can't be read still fails.
+     * whose envelope can't be read, or of whose events none can be read, still fails.
      */
     fun parseSyncEvents(body: BufferedSource): List<ChatEvent> {
         val parsed = mutableListOf<ChatEvent>()
+        val skipped = mutableListOf<SkippedEvent>()
+        var read = 0
+        forEachSyncEvent(body) { raw -> if (parseSyncEvent(raw, parsed, skipped)) read++ }
+        if (skipped.isNotEmpty()) {
+            val cause = skipped.first().cause
+            // With nothing read, the failure is likely not one event's, and the cursor must not move past them all.
+            if (read == 0) throw JsonDataException("None of the ${skipped.size} synced events could be read", cause)
+            logger.e(cause) { "[parseSyncEvents] skipped ${skipped.size} event(s): ${skipped.map { it.type }}" }
+        }
+        return parsed
+    }
+
+    /** Calls [action] with the raw JSON of each event in a `/sync` response's `events`. */
+    private fun forEachSyncEvent(body: BufferedSource, action: (String) -> Unit) {
         JsonReader.of(body).use { reader ->
             reader.beginObject()
             while (reader.hasNext()) {
@@ -139,24 +153,29 @@ internal class V2EventParser(
                     continue
                 }
                 reader.beginArray()
-                while (reader.hasNext()) parseSyncEvent(reader.nextSource().use { it.readUtf8() })?.let(parsed::add)
+                while (reader.hasNext()) action(reader.nextSource().use { it.readUtf8() })
                 reader.endArray()
             }
             reader.endObject()
         }
-        return parsed
     }
 
+    /**
+     * Reads [raw] into [parsed], unless the SDK ignores it, and returns true; an event that can't be read is added to
+     * [skipped] instead.
+     */
     @Suppress("TooGenericExceptionCaught")
-    private fun parseSyncEvent(raw: String): ChatEvent? = try {
-        parse(raw)
+    private fun parseSyncEvent(raw: String, parsed: MutableList<ChatEvent>, skipped: MutableList<SkippedEvent>) = try {
+        parse(raw)?.let(parsed::add)
+        true
     } catch (e: Exception) {
         // Any failure to read one event skips it; an Error, such as running out of memory, still fails the sync.
-        val type = runCatching { readHead(raw).type }.getOrNull() ?: "unknown"
-        logger.e(e) { "[parseSyncEvents] skipped a '$type' event" }
-        null
+        skipped += SkippedEvent(runCatching { readHead(raw).type }.getOrNull() ?: "unknown", e)
+        false
     }
 
+    private class SkippedEvent(val type: String, val cause: Exception)
+
     private fun withCustomAtRoot(event: String): String {
         val fields = rawFields(event)
         val custom = fields["custom"]?.takeIf { it.trimStart().startsWith("{") }?.let(::rawFields).orEmpty()
 
@@ -2962,11 +2962,11 @@ internal class MoshiChatApiTest {
     @Test
     fun `A synced event that can't be read is skipped and the rest are replayed`() = runTest {
         val api = mock<SyncApi>()
-        whenever(api.sync(any(), any()))
+        whenever(api.sync(any(), any(), any()))
             .doReturn(RetroSuccess(SYNCED_UNREADABLE_EVENT.toResponseBody()).toRetrofitCall())
         val sut = Fixture().withSyncApi(api).get()
 
-        val result = sut.getSyncHistory(listOf("messaging:general"), "2026-10-14T11:13:25.614650759Z").await()
+        val result = sut.getSyncHistory(listOf("messaging:general"), "2026-10-14T11:13:25.614650759Z", watch = false).await()
 
         val event = (result as Result.Success).value.single() as UnknownEvent
         event.type `should be equal to` "friendship_request"
 
@@ -178,12 +178,40 @@ internal class SyncManagerTest {
 
     @ParameterizedTest
     @CsvSource(
-        "2026-10-14T11:13:25.61465Z, 2026-10-14T11:13:25.614650000Z",
-        "2026-10-14T11:13:25Z, 2026-10-14T11:13:25.000000000Z",
+        "2026-10-14T11:13:25.61465Z, 2026-10-14T11:13:25.614650000Z, true",
+        "2026-10-14T11:13:25Z, 2026-10-14T11:13:25.000000000Z, true",
+        "2026-10-14T11:13:25.614650759Z, 2026-10-14T11:13:25.614650759Z, true",
+        "2026-10-14T11:13:25.61465Z, 2026-10-14T11:13:25.614651000Z, false",
+        "2026-10-14T11:13:25.61465Z, 2026-10-14T11:13:26.61465Z, false",
+        // Dates that don't parse are compared as written.
+        ", , true",
+        "not a date, not a date, true",
+        "2026-10-14T11:13:25Z, , false",
+    )
+    fun `sameInstant compares raw dates whatever the precision of their fraction`(
+        raw: String?,
+        other: String?,
+        expected: Boolean,
+    ) {
+        assertEquals(expected, sameInstant(raw, other))
+        assertEquals(expected, sameInstant(other, raw))
+    }
+
+    /**
+     * The SDK must not handle the event at the sync cursor on every sync: it wastes resources, and some events are not
+     * idempotent. The cursor's date can be written with another precision than the replayed event's.
+     */
+    @ParameterizedTest
+    @CsvSource(
+        "2026-10-14T11:13:25.614650759Z, 2026-10-14T11:13:25.614650759Z, false",
+        "2026-10-14T11:13:25.61465Z, 2026-10-14T11:13:25.614650000Z, false",
+        "2026-10-14T11:13:25Z, 2026-10-14T11:13:25.000000000Z, false",
+        "2026-10-14T11:13:25.61465Z, 2026-10-14T11:13:25.614651000Z, true",
     )
-    fun `an event at the cursor's instant is not propagated when its date is written with a different precision`(
+    fun `a synced event is propagated only when it is not at the cursor's instant`(
         rawLastSyncedAt: String,
         rawCreatedAt: String,
+        propagated: Boolean,
     ) = runTest(testDispatcher) {
         val createdAt = localDate()
         val testSyncState = SyncState(
@@ -201,7 +229,7 @@ internal class SyncManagerTest {
         whenever(repositoryFacade.selectMessages(any())) doReturn listOf(randomMessage())
         whenever(repositoryFacade.selectChannels(any())) doReturn listOf(randomChannel())
         whenever(repositoryFacade.selectSyncState(any())) doReturn testSyncState
-        whenever(chatClient.getSyncHistory(any(), any<String>())) doReturn TestCall(
+        whenever(chatClient.getSyncHistoryInternal(any(), any<String>(), any())) doReturn TestCall(
             Result.Success(listOf(mockedChatEvent)),
         )
         val connectingEvent = ConnectedEvent(
@@ -215,74 +243,10 @@ internal class SyncManagerTest {
         _syncEvents.test {
             syncManager.onEvent(connectingEvent)
 
-            expectNoEvents()
+            if (propagated) assertEquals(listOf(mockedChatEvent), awaitItem()) else expectNoEvents()
         }
     }
 
-    @ParameterizedTest
-    @CsvSource(
-        "2026-10-14T11:13:25.61465Z, 2026-10-14T11:13:25.614650000Z, true",
-        "2026-10-14T11:13:25Z, 2026-10-14T11:13:25.000000000Z, true",
-        "2026-10-14T11:13:25.614650759Z, 2026-10-14T11:13:25.614650759Z, true",
-        "2026-10-14T11:13:25.61465Z, 2026-10-14T11:13:25.614651000Z, false",
-        "2026-10-14T11:13:25.61465Z, 2026-10-14T11:13:26.61465Z, false",
-    )
-    fun `sameInstant compares raw dates whatever the precision of their fraction`(
-        raw: String,
-        other: String,
-        expected: Boolean,
-    ) {
-        assertEquals(expected, sameInstant(raw, other))
-        assertEquals(expected, sameInstant(other, raw))
-    }
-
-    @Test
-    fun `when one event of exact same raw time of last sync arrive, it should not be propagated`() =
-        runTest(testDispatcher) {
-            /*
-             *  This checks if the SDK is avoiding loops in the sync. We don't want to handle the same event on every sync,
-             *  because this can waste resource and/or some events may not be idempotent.
-             */
-            val createdAt = localDate()
-            val rawCreatedAt = streamDateFormatter.format(createdAt)
-            val testSyncState = SyncState(
-                userId = randomString(),
-                activeChannelIds = emptyList(),
-                lastSyncedAt = createdAt,
-                rawLastSyncedAt = rawCreatedAt,
-                markedAllReadAt = createdAt,
-            )
-
-            val syncManager = buildSyncManager()
-
-            val mockedChatEvent: ChatEvent = mock {
-                on(it.createdAt) doReturn createdAt
-                on(it.rawCreatedAt) doReturn rawCreatedAt
-            }
-
-            whenever(repositoryFacade.selectMessages(any())) doReturn listOf(randomMessage())
-            whenever(repositoryFacade.selectChannels(any())) doReturn listOf(randomChannel())
-            whenever(repositoryFacade.selectSyncState(any())) doReturn testSyncState
-
-            whenever(chatClient.getSyncHistoryInternal(any(), any<String>(), any())) doReturn TestCall(
-                Result.Success(listOf(mockedChatEvent)),
-            )
-            val connectingEvent = ConnectedEvent(
-                type = "type",
-                createdAt = createdAt,
-                rawCreatedAt = rawCreatedAt,
-                connectionId = randomString(),
-                me = randomUser(),
-            )
-
-            _syncEvents.test {
-                syncManager.onEvent(connectingEvent)
-
-                expectNoEvents()
-            }
-            verify(chatClient).getSyncHistoryInternal(any(), eq(rawCreatedAt), any())
-        }
-
     @Test
     fun `test initial syncing when rawLastSyncedAt is null`() = runTest(testDispatcher) {
         /* Given */
 
@@ -341,6 +341,23 @@ internal class V2EventParserTest {
         sync(body) shouldBeEqualTo listOf(v2(typing))
     }
 
+    @Test
+    fun `A sync response of whose events none can be read fails`() {
+        val unreadable = Frame(Wire.V2).event("channel.hidden", "cid" to CID)
+        val body = mapOf("events" to listOf(unreadable, unreadable)).toJson()
+
+        assertThrows<JsonDataException> { sync(body) }
+    }
+
+    @Test
+    fun `A synced event the SDK ignores counts as read next to one that can't be`() {
+        val feeds = Frame(Wire.V2).event("feeds.feed.created", "fid" to "user:filip")
+        val unreadable = Frame(Wire.V2).event("channel.hidden", "cid" to CID)
+        val body = mapOf("events" to listOf(feeds, unreadable)).toJson()
+
+        sync(body).shouldBeEmpty()
+    }
+
     @Test
     fun `A sync response whose envelope can't be read fails`() {
         assertThrows<JsonDataException> { sync("""{"events": {}}""") }