@sanity/sdk 2.18.0 → 2.20.0

package/src/document/patchOperations.test.ts

@@ -565,6 +565,33 @@ describe('diffMatchPatch', () => {
     expect(output).toEqual(input)
   })
 
+  it('applies the patch when its offsets miss a multi-byte boundary', () => {
+    // `\u00f8` is two bytes, so this patch's offsets land inside it and the byte
+    // walk overshoots. The default is to throw, which escapes the rebase loop in
+    // `reducers.ts` and kills the whole outgoing-actions pipeline: the instance
+    // then silently stops writing every document. The patch itself is fine and
+    // still applies.
+    const input = {foo: 'abcdefg\u00f8'}
+    const patch = '@@ -9,1 +9,2 @@\n \u00f8\n+!\n'
+
+    expect(() => diffMatchPatch(input, {foo: patch})).not.toThrow()
+    expect(diffMatchPatch(input, {foo: patch})).toEqual({foo: 'abcdefg\u00f8!'})
+  })
+
+  it('still patches the other properties in the same mutation', () => {
+    const input = {multibyte: 'abcdefg\u00f8', ascii: 'the quick brown fox'}
+
+    const output = diffMatchPatch(input, {
+      multibyte: '@@ -9,1 +9,2 @@\n \u00f8\n+!\n',
+      ascii: '@@ -13,7 +13,7 @@\n own \n-fox\n+cat\n',
+    })
+
+    expect(output).toEqual({
+      multibyte: 'abcdefg\u00f8!',
+      ascii: 'the quick brown cat',
+    })
+  })
+
   it('applies a diff-match-patch that makes no changes', () => {
     const input = {foo: 'unchanged'}
     const patch = '@@ -1,9 +1,9 @@\n unchanged\n'

package/src/document/patchOperations.ts

@@ -617,7 +617,16 @@ export function diffMatchPatch(
         )
       }
 
-      const [nextValue] = applyPatches(parsePatch(dmp), value)
+      // Offsets arrive as UTF-8 byte positions and can overshoot when they
+      // land inside a multi-byte character, which happens once the string a
+      // patch was computed against has diverged. The default is to throw, and
+      // that throw escapes the rebase loop in `reducers.ts`, kills the
+      // outgoing-actions pipeline, and leaves the instance silently dropping
+      // every write. Clamping to the nearest index applies the patch instead,
+      // which is what the Studio and the Portable Text editor already do.
+      const [nextValue] = applyPatches(parsePatch(dmp), value, {
+        allowExceedingIndices: true,
+      })
       return {path, value: nextValue}
     })
     .reduce((acc, {path, value}) => setDeep(acc, path, value), input)

package/src/document/permissions.test.ts

@@ -266,7 +266,9 @@ describe('calculatePermissions', () => {
       _createdAt: '2025-01-01T00:00:00.000Z',
       _updatedAt: '2025-01-01T00:00:00.000Z',
       _rev: 'rev-1',
-      _system: {createdBy},
+      // Content Lake sets `_system.createdBy` on canvas documents; the public
+      // `DocumentSystem` type doesn't declare it, so the literal needs a cast.
+      _system: {createdBy} as SanityDocument['_system'],
     })
 
     const editAction: DocumentAction = {

package/src/document/reducers.test.ts

@@ -632,6 +632,60 @@ describe('revertOutgoingTransaction', () => {
     const docState = newState.documentStates[draftId]
     expect(docState?.unverifiedRevisions && docState.unverifiedRevisions['txnOut']).toBeUndefined()
   })
+
+  it('unregisters the reverted batch subscription ids, making documents with no other subscribers evictable', () => {
+    const draftId = getDraftId(DocumentId('doc1'))
+    const pubId = getPublishedId(DocumentId('doc1'))
+    const state: SyncTransactionState = {
+      queued: [],
+      applied: [],
+      outgoing: {
+        transactionId: 'txnRevert',
+        actions: [
+          {
+            type: 'document.edit',
+            documentId: 'doc1',
+            documentType: 'book',
+            patches: [{set: {foo: 'changed'}}],
+          },
+        ],
+        disableBatching: false,
+        batchedTransactionIds: ['txnRevert'],
+        outgoingActions: [],
+        outgoingMutations: [],
+        base: {},
+        working: {},
+        previous: {},
+        previousRevs: {},
+        timestamp: '2025-02-06T00:04:30.000Z',
+      },
+      grants,
+      documentStates: {
+        // only subscriber is the reverted transaction itself
+        [draftId]: {
+          id: draftId,
+          subscriptions: ['txnRevert'],
+          local: {...exampleDoc, _id: draftId, foo: 'changed', _rev: 'rev2'},
+          remote: {...exampleDoc, _id: draftId, foo: 'old', _rev: 'rev1'},
+        },
+        // also has a UI subscriber, so it should survive with only the
+        // transaction subscription removed
+        [pubId]: {
+          id: pubId,
+          subscriptions: ['txnRevert', 'sub-ui'],
+          local: {...exampleDoc, _id: pubId, foo: 'pub', _rev: 'revPub'},
+          remote: {...exampleDoc, _id: pubId, foo: 'pub', _rev: 'revPub'},
+        },
+      },
+    }
+    const newState = revertOutgoingTransaction(state)
+    expect(newState.outgoing).toBeUndefined()
+    // no subscribers remain, so the document state is evicted entirely
+    expect(newState.documentStates[draftId]).toBeUndefined()
+    // the UI subscription keeps the other document alive, but the reverted
+    // transaction id is gone from its subscriptions
+    expect(newState.documentStates[pubId]?.subscriptions).toEqual(['sub-ui'])
+  })
 })
 
 describe('applyRemoteDocument', () => {
@@ -1124,6 +1178,85 @@ describe('applyRemoteDocument', () => {
     })
   })
 
+  describe('rebase over multi-byte text', () => {
+    it('does not kill the pipeline when a plain edit rebases onto multi-byte text', () => {
+      // The reported production failure: a byte-offset throw from
+      // `@sanity/diff-match-patch` is a plain `Error`, and `createMutationApplier`
+      // only converts to `ActionError` when `preserveOperations` is set. So for an
+      // ordinary `editDocument` it escapes this rebase loop, reaches the rxjs
+      // subscription, and the outgoing-actions pipeline for the whole instance
+      // dies. Every later write is then dropped silently, for every document.
+      const docId = getDraftId(DocumentId('doc1'))
+      const originalDoc: SanityDocument = {
+        ...exampleDoc,
+        _id: docId,
+        _rev: 'rev1',
+        title: 'abcdefg\u00f8',
+      }
+      const locallyEditedDoc: SanityDocument = {
+        ...originalDoc,
+        title: 'abcdefg\u00f8!',
+        _rev: 'txnLocal',
+      }
+
+      const appliedTransaction: AppliedTransaction = {
+        transactionId: 'txnLocal',
+        actions: [
+          {
+            type: 'document.edit',
+            documentId: 'doc1',
+            documentType: 'author',
+            patches: [{diffMatchPatch: {title: '@@ -9,1 +9,2 @@\n \u00f8\n+!\n'}}],
+          },
+        ],
+        previous: {[docId]: originalDoc},
+        base: {[docId]: originalDoc},
+        working: {[docId]: locallyEditedDoc},
+        previousRevs: {[docId]: 'rev1'},
+        timestamp: '2025-02-06T00:16:00.000Z',
+        outgoingActions: [],
+        outgoingMutations: [],
+      }
+
+      const initialState: SyncTransactionState = {
+        queued: [],
+        applied: [appliedTransaction],
+        outgoing: undefined,
+        grants,
+        documentStates: {
+          [docId]: {
+            id: docId,
+            subscriptions: ['sub1'],
+            local: locallyEditedDoc,
+            remote: originalDoc,
+            unverifiedRevisions: {},
+          },
+        },
+      }
+
+      // someone else changed the same field, so the local patch is rebased onto
+      // a base its byte offsets were not computed against
+      const remoteDoc: SanityDocument = {
+        ...originalDoc,
+        title: '\u00f8\u00f8\u00f8\u00f8\u00f8\u00f8',
+        _rev: 'txnForeign',
+      }
+      const remote: RemoteDocument = {
+        type: 'mutation',
+        documentId: docId,
+        document: remoteDoc,
+        revision: 'txnForeign',
+        previousRev: 'rev1',
+        timestamp: '2025-02-06T00:17:00.000Z',
+        mutations: [{patch: {id: docId, set: {title: '\u00f8\u00f8\u00f8\u00f8\u00f8\u00f8'}}}],
+      }
+
+      const events = new Subject<DocumentEvent>()
+
+      expect(() => applyRemoteDocument(initialState, remote, events)).not.toThrow()
+    })
+  })
+
   describe('rebase with preserved operations', () => {
     it('skips a preserved-operations transaction that fails to re-apply and emits rebase-error', () => {
       const docId = getDraftId(DocumentId('doc1'))

package/src/document/reducers.ts

@@ -406,8 +406,23 @@ export function cleanupOutgoingTransaction(prev: SyncTransactionState): SyncTran
 
 export function revertOutgoingTransaction(prev: SyncTransactionState): SyncTransactionState {
   if (!prev.grants) return prev
+
+  // unregister the reverted batch's transaction-held subscriptions, symmetric
+  // with `cleanupOutgoingTransaction` on ack and `removeQueuedTransaction` on
+  // apply failure. without this, a reverted document's subscription IDs are
+  // never released and it can never be evicted
+  let base = prev
+  if (prev.outgoing) {
+    const ids = getDocumentIdsFromHandleLikes(prev.outgoing.actions)
+    for (const transactionId of prev.outgoing.batchedTransactionIds) {
+      for (const documentId of ids) {
+        base = removeSubscriptionIdFromDocument(base, documentId, transactionId)
+      }
+    }
+  }
+
   let working = Object.fromEntries(
-    Object.entries(prev.documentStates).map(([documentId, documentState]) => [
+    Object.entries(base.documentStates).map(([documentId, documentState]) => [
       documentId,
       documentState?.remote,
     ]),
@@ -428,11 +443,11 @@ export function revertOutgoingTransaction(prev: SyncTransactionState): SyncTrans
   }
 
   return {
-    ...prev,
+    ...base,
     applied: nextApplied,
     outgoing: undefined,
     documentStates: Object.fromEntries(
-      Object.entries(prev.documentStates)
+      Object.entries(base.documentStates)
         .filter((e): e is [string, DocumentState] => !!e[1])
         .map(([documentId, {unverifiedRevisions = {}, local, ...documentState}]) => {
           const next: DocumentState = {

package/src/document/util.test.ts

@@ -0,0 +1,46 @@
+import {describe, expect, it} from 'vitest'
+
+import {getEditingDocumentId, getEffectiveDocumentId} from './util'
+
+const PUBLISHED = 'movie-1'
+const DRAFT = 'drafts.movie-1'
+const VERSION = 'versions.autumn.movie-1'
+
+describe('getEditingDocumentId', () => {
+  it('resolves the draft by default, which is what the Studio edits', () => {
+    expect(getEditingDocumentId({documentId: PUBLISHED})).toBe(DRAFT)
+  })
+
+  it("resolves the draft under the 'drafts' perspective", () => {
+    expect(getEditingDocumentId({documentId: PUBLISHED, perspective: 'drafts'})).toBe(DRAFT)
+  })
+
+  it("resolves the published document under the 'published' perspective", () => {
+    expect(getEditingDocumentId({documentId: PUBLISHED, perspective: 'published'})).toBe(PUBLISHED)
+  })
+
+  it('resolves the version under a release perspective', () => {
+    expect(
+      getEditingDocumentId({documentId: PUBLISHED, perspective: {releaseName: 'autumn'}}),
+    ).toBe(VERSION)
+  })
+
+  it('resolves the published document for live edit, which has no draft', () => {
+    expect(getEditingDocumentId({documentId: PUBLISHED, liveEdit: true})).toBe(PUBLISHED)
+  })
+
+  it('is idempotent when handed an already-specific id', () => {
+    expect(getEditingDocumentId({documentId: DRAFT})).toBe(DRAFT)
+    expect(getEditingDocumentId({documentId: VERSION, perspective: 'published'})).toBe(PUBLISHED)
+    expect(getEditingDocumentId({documentId: DRAFT, perspective: {releaseName: 'autumn'}})).toBe(
+      VERSION,
+    )
+  })
+
+  it('differs from getEffectiveDocumentId precisely where it has to', () => {
+    // The canonical key collapses a draft onto its published id, which is right for
+    // storing state and wrong for anything comparing exact ids.
+    expect(getEffectiveDocumentId({documentId: DRAFT, documentType: 'movie'})).toBe(PUBLISHED)
+    expect(getEditingDocumentId({documentId: DRAFT})).toBe(DRAFT)
+  })
+})

package/src/document/util.ts

@@ -1,8 +1,44 @@
-import {DocumentId, getPublishedId, getVersionId} from '@sanity/id-utils'
+import {DocumentId, getDraftId, getPublishedId, getVersionId} from '@sanity/id-utils'
 
 import {type DocumentHandle} from '../config/sanityConfig'
 import {isReleasePerspective} from '../releases/utils/isReleasePerspective'
 
+/**
+ * The id of the specific document a user is editing under a given perspective:
+ * the draft, the published document, or a release version.
+ *
+ * Distinct from {@link getEffectiveDocumentId}, which resolves the canonical key a
+ * document's state is stored under and so collapses a draft onto its published id.
+ * This one keeps them apart, because some things compare the exact id. Presence is
+ * the motivating case: the Studio's field indicators match the id its form is on,
+ * exactly, so an app reporting the published id shows up in the Studio at document
+ * level while never lighting up a single field.
+ *
+ * @remarks
+ * Resolved from the handle alone, which is right whenever a draft or version
+ * exists, so for any document actually being edited. The Studio additionally falls
+ * back to whichever document exists, so for a published document nobody has edited
+ * yet its form sits on the published id where this returns the draft id. Matching
+ * that would mean reading document state, which presence deliberately does not
+ * depend on.
+ *
+ * @internal
+ */
+export function getEditingDocumentId(
+  doc: Pick<DocumentHandle, 'documentId' | 'liveEdit' | 'perspective'>,
+): string {
+  if (doc.liveEdit) {
+    return getPublishedId(DocumentId(doc.documentId))
+  }
+  if (isReleasePerspective(doc.perspective)) {
+    return getVersionId(DocumentId(doc.documentId), doc.perspective.releaseName)
+  }
+  if (doc.perspective === 'published') {
+    return getPublishedId(DocumentId(doc.documentId))
+  }
+  return getDraftId(DocumentId(doc.documentId))
+}
+
 export function getEffectiveDocumentId(doc: DocumentHandle): string {
   if (doc.liveEdit) {
     return doc.documentId

package/src/presence/bifurTransport.test.ts

@@ -1,7 +1,7 @@
 import {fromUrl} from '@sanity/bifur-client'
 import {type SanityClient} from '@sanity/client'
-import {of, Subject} from 'rxjs'
-import {beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
+import {type Observable, of, Subject} from 'rxjs'
+import {afterEach, beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
 
 import {createBifurTransport} from './bifurTransport'
 import {type PresenceLocation, type TransportEvent} from './types'
@@ -39,16 +39,20 @@ describe('createBifurTransport', () => {
   let mockBifurClient: {
     listen: Mock
     request: Mock
+    heartbeats: Observable<Date>
   }
   let mockSanityClient: SanityClient
   let token$: Subject<string | null>
+  let heartbeats$: Subject<Date>
 
   beforeEach(() => {
     vi.useFakeTimers()
     vi.clearAllMocks()
+    heartbeats$ = new Subject<Date>()
     mockBifurClient = {
       listen: vi.fn(() => new Subject<never>()),
       request: vi.fn(() => of(undefined)),
+      heartbeats: heartbeats$.asObservable(),
     }
     fromUrlMock.mockReturnValue(mockBifurClient)
 
@@ -130,6 +134,8 @@ describe('createBifurTransport', () => {
 
     const receivedEvents: TransportEvent[] = []
     incomingEvents$.subscribe((event) => receivedEvents.push(event))
+    // The listener is established per live connection, so bring one up first.
+    heartbeats$.next(new Date())
 
     incomingBifurEvents$.next({
       type: 'rollCall',
@@ -161,6 +167,8 @@ describe('createBifurTransport', () => {
 
     const receivedEvents: TransportEvent[] = []
     incomingEvents$.subscribe((event) => receivedEvents.push(event))
+    // The listener is established per live connection, so bring one up first.
+    heartbeats$.next(new Date())
 
     const locations: PresenceLocation[] = [
       {type: 'document', documentId: 'doc1', path: ['a'], lastActiveAt: new Date().toISOString()},
@@ -200,6 +208,8 @@ describe('createBifurTransport', () => {
 
     const receivedEvents: TransportEvent[] = []
     incomingEvents$.subscribe((event) => receivedEvents.push(event))
+    // The listener is established per live connection, so bring one up first.
+    heartbeats$.next(new Date())
 
     incomingBifurEvents$.next({
       type: 'disconnect',
@@ -233,6 +243,7 @@ describe('createBifurTransport', () => {
     incomingEvents$.subscribe({
       error: (err) => errors.push(err),
     })
+    heartbeats$.next(new Date())
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     incomingBifurEvents$.next({type: 'unknown'} as any)
@@ -242,7 +253,148 @@ describe('createBifurTransport', () => {
     expect(errors[0].message).toContain('Got unknown presence event')
   })
 
-  describe('dispatchMessage', () => {
+  describe('connections', () => {
+    it('emits an incrementing generation each time the socket becomes live', () => {
+      const [, , connections$] = createBifurTransport({
+        client: mockSanityClient,
+        token$,
+        sessionId: 'my-session',
+      })
+
+      const generations: number[] = []
+      connections$.subscribe((generation) => generations.push(generation))
+
+      // Several heartbeats on one live socket are a single generation.
+      heartbeats$.next(new Date())
+      heartbeats$.next(new Date())
+      expect(generations).toEqual([1])
+
+      // bifur-client errors the stream when the socket closes. The transport is
+      // expected to reconnect rather than give up for the life of the page.
+      const reconnected$ = new Subject<Date>()
+      mockBifurClient.heartbeats = reconnected$.asObservable()
+      heartbeats$.error(new Error('WebSocket connection error'))
+
+      // First retry is scheduled 200ms out (2 ** 1 * 100).
+      vi.advanceTimersByTime(200)
+      reconnected$.next(new Date())
+
+      expect(generations).toEqual([1, 2])
+    })
+
+    it('does not resubscribe before the backoff has elapsed', () => {
+      const [, , connections$] = createBifurTransport({
+        client: mockSanityClient,
+        token$,
+        sessionId: 'my-session',
+      })
+
+      const generations: number[] = []
+      connections$.subscribe((generation) => generations.push(generation))
+      heartbeats$.next(new Date())
+
+      const reconnected$ = new Subject<Date>()
+      mockBifurClient.heartbeats = reconnected$.asObservable()
+      heartbeats$.error(new Error('WebSocket connection error'))
+
+      vi.advanceTimersByTime(199)
+      reconnected$.next(new Date())
+      expect(generations).toEqual([1])
+    })
+  })
+
+  describe('incoming events across a reconnect', () => {
+    it('keeps delivering presence after the socket drops', () => {
+      // bifur errors every stream on the same socket close, the inbound listener
+      // included. If only the heartbeat stream recovers, this client re-announces
+      // itself to peers while permanently ceasing to see any of them.
+      const firstListen$ = new Subject<IncomingBifurEvent>()
+      const secondListen$ = new Subject<IncomingBifurEvent>()
+      mockBifurClient.listen.mockReturnValueOnce(firstListen$).mockReturnValueOnce(secondListen$)
+
+      const [incomingEvents$, , connections$] = createBifurTransport({
+        client: mockSanityClient,
+        token$,
+        sessionId: 'my-session',
+      })
+
+      const received: TransportEvent[] = []
+      incomingEvents$.subscribe({
+        next: (event) => received.push(event),
+        error: () => received.push({type: 'rollCall', userId: 'STREAM_DIED', sessionId: ''}),
+      })
+      connections$.subscribe()
+
+      heartbeats$.next(new Date())
+      firstListen$.next({type: 'rollCall', i: 'user-1', session: 'before'})
+      expect(received.map((e) => e.sessionId)).toEqual(['before'])
+
+      // Socket closes: both streams error.
+      const reconnectedHeartbeats$ = new Subject<Date>()
+      mockBifurClient.heartbeats = reconnectedHeartbeats$.asObservable()
+      firstListen$.error(new Error('WebSocket connection error'))
+      heartbeats$.error(new Error('WebSocket connection error'))
+
+      vi.advanceTimersByTime(200)
+      reconnectedHeartbeats$.next(new Date())
+
+      // Peers answer the roll call we send on reconnect. We have to be listening.
+      secondListen$.next({type: 'rollCall', i: 'user-1', session: 'after'})
+
+      expect(received.map((e) => e.sessionId)).toEqual(['before', 'after'])
+    })
+  })
+
+  describe('unload', () => {
+    afterEach(() => {
+      vi.unstubAllGlobals()
+    })
+
+    it('emits on beforeunload and pagehide, and removes its listeners', () => {
+      // These tests run in Node, so stand in a bare EventTarget for `window`.
+      const fakeWindow = new EventTarget()
+      vi.stubGlobal('window', fakeWindow)
+
+      const [, , , unload$] = createBifurTransport({
+        client: mockSanityClient,
+        token$,
+        sessionId: 'my-session',
+      })
+
+      let emissions = 0
+      const subscription = unload$.subscribe(() => {
+        emissions += 1
+      })
+
+      fakeWindow.dispatchEvent(new Event('beforeunload'))
+      expect(emissions).toBe(1)
+
+      // `pagehide` matters on its own: iOS Safari and pages entering the
+      // back/forward cache never fire `beforeunload`.
+      fakeWindow.dispatchEvent(new Event('pagehide'))
+      expect(emissions).toBe(2)
+
+      // The listeners belong to the subscription, so unsubscribing removes them
+      // instead of leaking one per transport for the life of the page.
+      subscription.unsubscribe()
+      fakeWindow.dispatchEvent(new Event('beforeunload'))
+      expect(emissions).toBe(2)
+    })
+
+    it('is inert when there is no window', () => {
+      const [, , , unload$] = createBifurTransport({
+        client: mockSanityClient,
+        token$,
+        sessionId: 'my-session',
+      })
+
+      let completed = false
+      unload$.subscribe({complete: () => (completed = true)})
+      expect(completed).toBe(true)
+    })
+  })
+
+  describe('dispatch', () => {
     it('sends a "rollCall" message', () => {
       const [, dispatchMessage] = createBifurTransport({
         client: mockSanityClient,

package/src/presence/bifurTransport.ts

@@ -1,7 +1,7 @@
 import {type BifurClient, fromUrl} from '@sanity/bifur-client'
 import {type SanityClient} from '@sanity/client'
-import {EMPTY, fromEvent, type Observable} from 'rxjs'
-import {map, share, switchMap} from 'rxjs/operators'
+import {defer, EMPTY, fromEvent, merge, type Observable, timer} from 'rxjs'
+import {catchError, distinctUntilChanged, map, retry, share, switchMap} from 'rxjs/operators'
 
 import {
   type BifurTransportOptions,
@@ -11,6 +11,12 @@ import {
   type TransportMessage,
 } from './types'
 
+/**
+ * Longest gap between reconnection attempts, matching the Studio's presence
+ * transport so both behave the same way on a flaky connection.
+ */
+const CONNECT_RETRY_MAX_DELAY = 1000 * 240
+
 type BifurStateMessage = {
   type: 'state'
   i: string
@@ -91,13 +97,80 @@ const handleIncomingMessage = (event: IncomingBifurEvent): TransportEvent => {
   }
 }
 
+/**
+ * Emits an incrementing generation number each time the socket becomes live.
+ *
+ * `@sanity/bifur-client` does not reconnect on its own — it errors the stream
+ * when the socket closes. Without the `retry` below, presence stops for the
+ * life of the page after the first dropped connection.
+ */
+const createConnections = (bifur: BifurClient): Observable<number> => {
+  let generation = 0
+
+  return defer(() => {
+    const current = ++generation
+    // `heartbeats` emits as soon as the socket is open and authorized, then on
+    // every server heartbeat and every response. Subscribing to it is also what
+    // keeps the socket alive between requests.
+    return bifur.heartbeats.pipe(map(() => current))
+  }).pipe(
+    retry({
+      delay: (_error, retryCount) =>
+        timer(Math.min(CONNECT_RETRY_MAX_DELAY, 2 ** retryCount * 100)),
+      resetOnSuccess: true,
+    }),
+    // After `retry` so that one operator instance spans reconnects, making each
+    // live socket yield exactly one emission.
+    distinctUntilChanged(),
+    share(),
+  )
+}
+
+/**
+ * Presence events from everyone else in the room, re-established on every live
+ * connection.
+ *
+ * A socket close errors this stream just as it errors the heartbeats, so without
+ * re-subscribing the client would keep announcing itself after a reconnect while
+ * never hearing from anyone again. Driving it from `connections$` rather than
+ * giving it its own `retry` keeps a single reconnect loop, instead of two
+ * independent backoffs racing over one refcounted socket.
+ */
+const createIncomingEvents = (
+  bifur: BifurClient,
+  connections$: Observable<number>,
+): Observable<TransportEvent> =>
+  connections$.pipe(
+    switchMap(() =>
+      bifur.listen<IncomingBifurEvent>('presence').pipe(
+        // Let a dead listener go quietly. The next connection replaces it, and
+        // surfacing the error here would tear down the reconnect loop with it.
+        catchError(() => EMPTY),
+      ),
+    ),
+    map(handleIncomingMessage),
+    share(),
+  )
+
+/**
+ * Emits when the page is going away. `pagehide` is needed alongside
+ * `beforeunload` because iOS Safari and pages entering the back/forward cache
+ * never fire `beforeunload`.
+ */
+const createUnload = (): Observable<void> => {
+  if (typeof window === 'undefined') return EMPTY
+
+  return merge(fromEvent(window, 'beforeunload'), fromEvent(window, 'pagehide')).pipe(
+    map(() => undefined),
+  )
+}
+
 export const createBifurTransport = (options: BifurTransportOptions): PresenceTransport => {
   const {client, token$, sessionId} = options
   const bifur = getBifurClient(client, token$)
 
-  const incomingEvents$: Observable<TransportEvent> = bifur
-    .listen<IncomingBifurEvent>('presence')
-    .pipe(map(handleIncomingMessage))
+  const connections$ = createConnections(bifur)
+  const incomingEvents$ = createIncomingEvents(bifur, connections$)
 
   const dispatchMessage = (message: TransportMessage): Observable<void> => {
     switch (message.type) {
@@ -115,11 +188,5 @@ export const createBifurTransport = (options: BifurTransportOptions): PresenceTr
     }
   }
 
-  if (typeof window !== 'undefined') {
-    fromEvent(window, 'beforeunload')
-      .pipe(switchMap(() => dispatchMessage({type: 'disconnect'})))
-      .subscribe()
-  }
-
-  return [incomingEvents$.pipe(share()), dispatchMessage]
+  return [incomingEvents$, dispatchMessage, connections$, createUnload()]
 }