@sanity/sdk 3.0.0-rc.0 → 3.0.0-rc.2

package/src/organizations/organizations.test.ts

@@ -0,0 +1,150 @@
+import {type SanityClient} from '@sanity/client'
+import {of} from 'rxjs'
+import {afterEach, beforeEach, describe, it} from 'vitest'
+
+import {getClientState} from '../client/clientStore'
+import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
+import {getOrganizationsCacheKey, organizations} from './organizations'
+
+vi.mock('../client/clientStore')
+
+describe('organizations', () => {
+  let instance: SanityInstance
+
+  beforeEach(() => {
+    instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+  })
+
+  afterEach(() => {
+    instance.dispose()
+  })
+
+  it('calls `client.observable.request` against `/organizations` and returns the result', async () => {
+    const list = [{id: 'org_1'}, {id: 'org_2'}]
+    const request = vi.fn().mockReturnValue(of(list))
+
+    const mockClient = {
+      observable: {request} as unknown as SanityClient['observable'],
+    } as SanityClient
+
+    vi.mocked(getClientState).mockReturnValue({
+      observable: of(mockClient),
+    } as StateSource<SanityClient>)
+
+    const result = await organizations.resolveState(instance)
+    expect(result).toEqual(list)
+    expect(request).toHaveBeenCalledWith({
+      uri: '/organizations',
+      query: {
+        includeImplicitMemberships: 'false',
+        includeMembers: 'false',
+        includeFeatures: 'false',
+      },
+      tag: 'organizations.list',
+    })
+  })
+
+  it('serializes query params (booleans → strings) and respects flags', async () => {
+    const request = vi.fn().mockReturnValue(of([]))
+    const mockClient = {
+      observable: {request} as unknown as SanityClient['observable'],
+    } as SanityClient
+
+    vi.mocked(getClientState).mockReturnValue({
+      observable: of(mockClient),
+    } as StateSource<SanityClient>)
+
+    await organizations.resolveState(instance, {
+      includeMembers: true,
+      includeFeatures: true,
+      includeImplicitMemberships: true,
+    })
+
+    expect(request).toHaveBeenCalledWith({
+      uri: '/organizations',
+      query: {
+        includeImplicitMemberships: 'true',
+        includeMembers: 'true',
+        includeFeatures: 'true',
+      },
+      tag: 'organizations.list',
+    })
+  })
+})
+
+describe('organizations cache key generation', () => {
+  let instance: SanityInstance
+
+  beforeEach(() => {
+    instance = createSanityInstance({})
+  })
+
+  afterEach(() => {
+    instance.dispose()
+  })
+
+  it('default call excludes all segments (all flags default-false)', () => {
+    expect(getOrganizationsCacheKey(instance)).toBe('organizations')
+  })
+
+  it('treats undefined and the matching default as the same key', () => {
+    expect(getOrganizationsCacheKey(instance)).toBe(
+      getOrganizationsCacheKey(instance, {
+        includeMembers: false,
+        includeFeatures: false,
+        includeImplicitMemberships: false,
+      }),
+    )
+  })
+
+  it('explicit includeMembers: true appends :members', () => {
+    expect(getOrganizationsCacheKey(instance, {includeMembers: true})).toBe('organizations:members')
+  })
+
+  it('explicit includeFeatures: true appends :features', () => {
+    expect(getOrganizationsCacheKey(instance, {includeFeatures: true})).toBe(
+      'organizations:features',
+    )
+  })
+
+  it('explicit includeImplicitMemberships: true appends :implicit', () => {
+    expect(getOrganizationsCacheKey(instance, {includeImplicitMemberships: true})).toBe(
+      'organizations:implicit',
+    )
+  })
+
+  it('combines all segments in order', () => {
+    expect(
+      getOrganizationsCacheKey(instance, {
+        includeMembers: true,
+        includeFeatures: true,
+        includeImplicitMemberships: true,
+      }),
+    ).toBe('organizations:members:features:implicit')
+  })
+
+  it('produces distinct keys for each meaningful option permutation', () => {
+    const keys = new Set([
+      getOrganizationsCacheKey(instance),
+      getOrganizationsCacheKey(instance, {includeMembers: true}),
+      getOrganizationsCacheKey(instance, {includeFeatures: true}),
+      getOrganizationsCacheKey(instance, {includeImplicitMemberships: true}),
+      getOrganizationsCacheKey(instance, {includeMembers: true, includeFeatures: true}),
+      getOrganizationsCacheKey(instance, {
+        includeMembers: true,
+        includeImplicitMemberships: true,
+      }),
+      getOrganizationsCacheKey(instance, {
+        includeFeatures: true,
+        includeImplicitMemberships: true,
+      }),
+      getOrganizationsCacheKey(instance, {
+        includeMembers: true,
+        includeFeatures: true,
+        includeImplicitMemberships: true,
+      }),
+    ])
+    expect(keys.size).toBe(8)
+  })
+})

package/src/organizations/organizations.ts

@@ -0,0 +1,107 @@
+import {switchMap} from 'rxjs'
+
+import {getClientState} from '../client/clientStore'
+import {
+  type OrganizationBase,
+  type OrganizationMember,
+  type OrganizationOptions,
+} from '../organization/organization'
+import {type SanityInstance} from '../store/createSanityInstance'
+import {defineFetcher} from '../store/fetcherStore'
+import {buildQuery} from '../utils/buildQuery'
+
+const API_VERSION = 'v2025-02-19'
+
+/**
+ * The list shape returned from `/organizations`, with `members` and/or
+ * `features` conditionally included based on the query options used.
+ * @public
+ */
+export type Organizations<
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = false,
+> = (Pick<
+  OrganizationBase,
+  | 'id'
+  | 'name'
+  | 'slug'
+  | 'createdAt'
+  | 'updatedAt'
+  | 'defaultRoleName'
+  | 'dashboardStatus'
+  | 'aiFeaturesStatus'
+> &
+  // `boolean extends T` is non-distributive — true only when T is the wide
+  // `boolean`, in which case the field is optional. Literal `true`/`false`
+  // fall through to the strict branch.
+  (boolean extends IncludeMembers
+    ? {members?: OrganizationMember[]}
+    : IncludeMembers extends true
+      ? {members: OrganizationMember[]}
+      : unknown) &
+  (boolean extends IncludeFeatures
+    ? {features?: string[]}
+    : IncludeFeatures extends true
+      ? {features: string[]}
+      : unknown))[]
+
+/** @public */
+export interface OrganizationsOptions<
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = false,
+> extends Omit<OrganizationOptions<IncludeMembers, IncludeFeatures>, 'organizationId'> {
+  /**
+   * When `true`, includes organisations the user has access to via
+   * project-level grants, not just direct organisation memberships.
+   */
+  includeImplicitMemberships?: boolean
+}
+
+function normalizeOrganizationsOptions(options?: OrganizationsOptions<boolean, boolean>) {
+  return {
+    includeImplicitMemberships: options?.includeImplicitMemberships ?? false,
+    includeMembers: options?.includeMembers ?? false,
+    includeFeatures: options?.includeFeatures ?? false,
+  }
+}
+
+/** @internal */
+export function getOrganizationsCacheKey(
+  _instance: SanityInstance,
+  options?: OrganizationsOptions<boolean, boolean>,
+): string {
+  const {includeMembers, includeFeatures, includeImplicitMemberships} =
+    normalizeOrganizationsOptions(options)
+  const membersKey = includeMembers ? ':members' : ''
+  const featuresKey = includeFeatures ? ':features' : ''
+  const implicitKey = includeImplicitMemberships ? ':implicit' : ''
+  return `organizations${membersKey}${featuresKey}${implicitKey}`
+}
+
+/**
+ * Fetcher for the current user's organizations (`GET /organizations`), on the
+ * shared fetcher cache.
+ *
+ * @internal
+ */
+export const organizations = defineFetcher<
+  [options?: OrganizationsOptions<boolean, boolean>],
+  Organizations<boolean, boolean>
+>({
+  name: 'organizations',
+  getKey: getOrganizationsCacheKey,
+  fetch: (instance) => (options) =>
+    getClientState(instance, {apiVersion: API_VERSION, scope: 'global'}).observable.pipe(
+      switchMap((client) =>
+        client.observable.request<Organizations<boolean, boolean>>({
+          uri: '/organizations',
+          query: buildQuery(normalizeOrganizationsOptions(options)),
+          tag: 'organizations.list',
+        }),
+      ),
+    ),
+  tags: (data) => [
+    {type: 'organization', id: 'LIST'},
+    ...data.map((org) => ({type: 'organization', id: org.id})),
+  ],
+})

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,22 +39,28 @@ 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)
 
+    // Default mock is a dataset client using project hostname
     mockSanityClient = {
       config: () => ({
         dataset: 'test-dataset',
-        url: 'http://localhost:3333',
+        url: 'https://test-project.api.sanity.io/v2022-06-30',
         requestTagPrefix: 'test-tag',
       }),
       withConfig: vi.fn().mockReturnThis(),
@@ -63,7 +69,7 @@ describe('createBifurTransport', () => {
     token$ = new Subject<string | null>()
   })
 
-  it('constructs the bifur client with the correct URL', () => {
+  it('constructs the bifur client URL for a dataset resource', () => {
     createBifurTransport({
       client: mockSanityClient,
       token$,
@@ -71,13 +77,51 @@ describe('createBifurTransport', () => {
     })
 
     expect(fromUrlMock).toHaveBeenCalledWith(
-      'ws://localhost:3333/socket/test-dataset?tag=test-tag',
-      {
-        token$,
-      },
+      'wss://test-project.api.sanity.io/v2022-06-30/socket/test-dataset?tag=test-tag',
+      {token$},
+    )
+  })
+
+  it('constructs the bifur client URL for a canvas resource', () => {
+    const canvasClient = {
+      config: () => ({
+        resource: {type: 'canvas', id: 'canvas-123'},
+        url: 'https://api.sanity.io/v2022-06-30',
+        requestTagPrefix: 'test-tag',
+      }),
+      withConfig: vi.fn().mockReturnThis(),
+    } as unknown as SanityClient
+
+    createBifurTransport({
+      client: canvasClient,
+      token$,
+      sessionId: 'session-id-123',
+    })
+
+    expect(fromUrlMock).toHaveBeenCalledWith(
+      'wss://api.sanity.io/v2022-06-30/socket/canvases/canvas-123?tag=test-tag',
+      {token$},
     )
   })
 
+  it('throws when no canvas resource or dataset is configured', () => {
+    const invalidClient = {
+      config: () => ({
+        url: 'https://api.sanity.io/v2022-06-30',
+        requestTagPrefix: 'test-tag',
+      }),
+      withConfig: vi.fn().mockReturnThis(),
+    } as unknown as SanityClient
+
+    expect(() =>
+      createBifurTransport({
+        client: invalidClient,
+        token$,
+        sessionId: 'session-id-123',
+      }),
+    ).toThrow('Unable to determine presence URL')
+  })
+
   it('handles incoming rollCall events', () => {
     const incomingBifurEvents$ = new Subject<IncomingBifurEvent>()
     mockBifurClient.listen.mockReturnValue(incomingBifurEvents$)
@@ -90,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',
@@ -121,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()},
@@ -160,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',
@@ -193,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)
@@ -202,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
@@ -36,8 +42,25 @@ type IncomingBifurEvent = RollCallEvent | BifurStateMessage | BifurDisconnectMes
 
 function getBifurClient(client: SanityClient, token$: Observable<string | null>): BifurClient {
   const bifurVersionedClient = client.withConfig({apiVersion: '2022-06-30'})
-  const {dataset, url: baseUrl, requestTagPrefix = 'sanity.studio'} = bifurVersionedClient.config()
-  const url = `${baseUrl.replace(/\/+$/, '')}/socket/${dataset}`.replace(/^http/, 'ws')
+  const {
+    resource,
+    dataset,
+    url: baseUrl,
+    requestTagPrefix = 'sanity.sdk.presence',
+  } = bifurVersionedClient.config()
+
+  let resourcePath: string
+  if (resource?.type === 'canvas') {
+    resourcePath = `canvases/${resource.id}`
+  } else if (dataset) {
+    // Dataset clients use project hostname — dataset name alone is the socket path
+    resourcePath = dataset
+  } else {
+    throw new Error(`Unable to determine presence URL: no canvas resource or dataset configured`)
+  }
+
+  const url = `${baseUrl}/socket/${resourcePath}`.replace(/^http/, 'ws')
+
   const urlWithTag = `${url}?tag=${requestTagPrefix}`
 
   return fromUrl(urlWithTag, {token$})
@@ -74,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) {
@@ -98,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()]
 }