@sanity/sdk-react 3.0.0-rc.1 → 3.0.0

package/src/hooks/dashboard/useWindowTitle.ts

@@ -42,7 +42,7 @@ function resolveAppTitle(resource: ContextResource): string | undefined {
  *
  * @example
  * ```tsx
- * import {useWindowTitle} from '@sanity/sdk-react'
+ * import {useWindowTitle} from '@sanity/sdk-react/dashboard'
  *
  * function MoviesList() {
  *   useWindowTitle('Movies')

package/src/hooks/datasets/useDatasets.test.tsx

@@ -1,10 +1,6 @@
 import {type DatasetsResponse} from '@sanity/client'
-import {
-  createSanityInstance,
-  getDatasetsState,
-  resolveDatasets,
-  type StateSource,
-} from '@sanity/sdk'
+import {createSanityInstance, datasets, type StateSource} from '@sanity/sdk'
+import {type FetcherSnapshot} from '@sanity/sdk/_internal'
 import {type ReactNode} from 'react'
 import {type Observable} from 'rxjs'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
@@ -16,32 +12,43 @@ import {useDatasets} from './useDatasets'
 
 vi.mock('@sanity/sdk', async (importOriginal) => {
   const original = await importOriginal<typeof import('@sanity/sdk')>()
-  return {...original, getDatasetsState: vi.fn(), resolveDatasets: vi.fn()}
+  return {...original, datasets: {getState: vi.fn(), resolveState: vi.fn()}}
 })
 
 const stateSource = (
   current: DatasetsResponse | undefined,
-): StateSource<DatasetsResponse | undefined> =>
-  ({
-    getCurrent: vi.fn(() => current),
-    subscribe: vi.fn(),
+): StateSource<FetcherSnapshot<DatasetsResponse>> => {
+  // Cache the snapshot: useSyncExternalStore requires a referentially stable current value.
+  const snapshot = current
+    ? {status: 'success', data: current, error: undefined, isFetching: false, dataUpdatedAt: 1}
+    : {
+        status: 'pending',
+        data: undefined,
+        error: undefined,
+        isFetching: true,
+        dataUpdatedAt: undefined,
+      }
+  return {
+    getCurrent: vi.fn(() => snapshot),
+    subscribe: vi.fn(() => () => {}),
     get observable(): Observable<unknown> {
       throw new Error('Not implemented')
     },
-  }) as unknown as StateSource<DatasetsResponse | undefined>
+  } as unknown as StateSource<FetcherSnapshot<DatasetsResponse>>
+}
 
 const sanityInstance = expect.objectContaining({config: expect.any(Object)})
 
 describe('useDatasets', () => {
   beforeEach(() => {
     vi.clearAllMocks()
-    vi.mocked(getDatasetsState).mockReturnValue(stateSource([] as unknown as DatasetsResponse))
+    vi.mocked(datasets.getState).mockReturnValue(stateSource([] as unknown as DatasetsResponse))
   })
 
   it('resolves the projectId from the instance config resource', () => {
     // test-utils wraps with ResourceProvider projectId="test" dataset="test".
     renderHook(() => useDatasets())
-    expect(getDatasetsState).toHaveBeenCalledWith(
+    expect(datasets.getState).toHaveBeenCalledWith(
       sanityInstance,
       expect.objectContaining({projectId: 'test'}),
     )
@@ -49,7 +56,7 @@ describe('useDatasets', () => {
 
   it('lets an explicit projectId override the ambient resource', () => {
     renderHook(() => useDatasets({projectId: 'explicit-project'}))
-    expect(getDatasetsState).toHaveBeenCalledWith(
+    expect(datasets.getState).toHaveBeenCalledWith(
       sanityInstance,
       expect.objectContaining({projectId: 'explicit-project'}),
     )
@@ -66,7 +73,7 @@ describe('useDatasets', () => {
         </ResourceProvider>
       ),
     })
-    expect(getDatasetsState).toHaveBeenCalledWith(
+    expect(datasets.getState).toHaveBeenCalledWith(
       sanityInstance,
       expect.objectContaining({projectId: 'resource-project'}),
     )
@@ -82,7 +89,7 @@ describe('useDatasets', () => {
     })
     // A dataset-less config can't form a DatasetResource; the projectId is carried
     // via ProjectContext and injected so project-scoped reads still resolve it.
-    expect(getDatasetsState).toHaveBeenCalledWith(
+    expect(datasets.getState).toHaveBeenCalledWith(
       sanityInstance,
       expect.objectContaining({projectId: 'config-project'}),
     )
@@ -101,16 +108,16 @@ describe('useDatasets', () => {
         </SanityInstanceContext.Provider>
       ),
     })
-    expect(getDatasetsState).toHaveBeenCalledWith(
+    expect(datasets.getState).toHaveBeenCalledWith(
       emptyInstance,
       expect.objectContaining({projectId: 'bare-project'}),
     )
   })
 
-  it('suspends via resolveDatasets until dataset data is available', () => {
-    vi.mocked(getDatasetsState).mockReturnValue(stateSource(undefined))
-    vi.mocked(resolveDatasets).mockReturnValue(new Promise(() => {}))
+  it('suspends via the datasets fetcher until dataset data is available', () => {
+    vi.mocked(datasets.getState).mockReturnValue(stateSource(undefined))
+    vi.mocked(datasets.resolveState).mockReturnValue(new Promise(() => {}))
     renderHook(() => useDatasets())
-    expect(resolveDatasets).toHaveBeenCalled()
+    expect(datasets.resolveState).toHaveBeenCalled()
   })
 })

package/src/hooks/datasets/useDatasets.ts

@@ -1,64 +1,42 @@
 import {type DatasetsResponse} from '@sanity/client'
-import {
-  getDatasetsState,
-  type ProjectHandle,
-  resolveDatasets,
-  type SanityInstance,
-  type StateSource,
-} from '@sanity/sdk'
+import {datasets, type ProjectHandle} from '@sanity/sdk'
 
-import {createStateSourceHook} from '../helpers/createStateSourceHook'
+import {createFetcherHook, type FetcherHookResult} from '../helpers/createFetcherHook'
 import {useResolvedProjectId} from '../helpers/useResolvedProjectId'
 
-type UseDatasets = {
-  /**
-   *
-   * Returns metadata for each dataset the current user has access to.
-   *
-   * @category Datasets
-   * @param options - Optional project/resource to read datasets for. Defaults to
-   *   the resource named in `ResourceProvider`/`SDKProvider`.
-   * @returns The metadata for your the datasets
-   *
-   * @example
-   * ```tsx
-   * const datasets = useDatasets()
-   *
-   * return (
-   *   <select>
-   *     {datasets.map((dataset) => (
-   *       <option key={dataset.name}>{dataset.name}</option>
-   *     ))}
-   *   </select>
-   * )
-   * ```
-   *
-   * @remarks
-   * The `projectId` is resolved in order from:
-   * 1. an explicit `projectId` option
-   * 2. A legacy ProjectContext (e.g. a `<ResourceProvider projectId="…">` with no dataset), then
-   * 3. The active resource (`ResourceProvider`/`SDKProvider`)
-   * 4. `instance.config`.
-   */
-  (options?: ProjectHandle): DatasetsResponse
-}
-
-const useDatasetsBase = createStateSourceHook({
-  getState: getDatasetsState as (
-    instance: SanityInstance,
-    projectHandle?: ProjectHandle,
-  ) => StateSource<DatasetsResponse>,
-  shouldSuspend: (instance, projectHandle?: ProjectHandle) =>
-    // remove `undefined` since we're suspending when that is the case
-    getDatasetsState(instance, projectHandle).getCurrent() === undefined,
-  suspender: resolveDatasets,
-})
+const useDatasetsBase = createFetcherHook(datasets)
 
 /**
+ * Returns metadata for each dataset the current user has access to.
+ *
+ * @category Datasets
+ * @param options - Optional project/resource to read datasets for. Defaults to
+ *   the resource named in `ResourceProvider`/`SDKProvider`.
+ * @returns A {@link FetcherHookResult} whose `data` is the metadata for the
+ *   datasets.
+ *
+ * @example
+ * ```tsx
+ * const {data: datasets} = useDatasets()
+ *
+ * return (
+ *   <select>
+ *     {datasets.map((dataset) => (
+ *       <option key={dataset.name}>{dataset.name}</option>
+ *     ))}
+ *   </select>
+ * )
+ * ```
+ *
+ * @remarks
+ * The `projectId` is resolved in order from:
+ * 1. an explicit `projectId` option
+ * 2. A legacy ProjectContext (e.g. a `<ResourceProvider projectId="…">` with no dataset), then
+ * 3. The active resource (`ResourceProvider`/`SDKProvider`)
+ * 4. `instance.config`.
  * @public
- * @function
  */
-export const useDatasets: UseDatasets = (options) => {
+export function useDatasets(options?: ProjectHandle): FetcherHookResult<DatasetsResponse> {
   const projectId = useResolvedProjectId(options)
   return useDatasetsBase(projectId ? {...options, projectId} : options)
 }

package/src/hooks/documents/useDocuments.ts

@@ -1,10 +1,5 @@
-import {
-  createGroqSearchFilter,
-  type DocumentHandle,
-  isDatasetResource,
-  type QueryOptions,
-} from '@sanity/sdk'
-import {pickProperties} from '@sanity/sdk/_internal'
+import {type DocumentHandle, isDatasetResource, type QueryOptions} from '@sanity/sdk'
+import {createGroqSearchFilter, pickProperties} from '@sanity/sdk/_internal'
 import {type SortOrderingItem} from '@sanity/types'
 import {useCallback, useMemo, useState} from 'react'
 

package/src/hooks/helpers/useNormalizedResourceOptions.test.tsx

@@ -91,21 +91,6 @@ describe('useNormalizedResourceOptions', () => {
         ),
       ).toThrow()
     })
-
-    it('resolves deprecated `source` as `resource`', () => {
-      const {result} = renderHook(() =>
-        useNormalizedResourceOptions({source: {projectId: 'src', dataset: 'src-ds'}}),
-      )
-      expect(result.current.resource).toEqual({projectId: 'src', dataset: 'src-ds'})
-    })
-
-    it('resolves deprecated `sourceName` as `resourceName`', () => {
-      const {result} = renderHook(() => useNormalizedResourceOptions({sourceName: 'dataset'}))
-      expect(result.current.resource).toEqual({
-        projectId: 'resource-project-id',
-        dataset: 'resource-dataset',
-      })
-    })
   })
 
   describe('tier 2 — bare projectId/dataset in options', () => {
@@ -232,18 +217,6 @@ describe('useNormalizedResourceOptions', () => {
       expect(result.current).not.toHaveProperty('dataset')
     })
 
-    it('strips deprecated source from the result', () => {
-      const {result} = renderHook(() =>
-        useNormalizedResourceOptions({source: {projectId: 'src', dataset: 'src-ds'}}),
-      )
-      expect(result.current).not.toHaveProperty('source')
-    })
-
-    it('strips deprecated sourceName from the result', () => {
-      const {result} = renderHook(() => useNormalizedResourceOptions({sourceName: 'dataset'}))
-      expect(result.current).not.toHaveProperty('sourceName')
-    })
-
     it('preserves unrelated fields', () => {
       const opts: DocumentHandle = {documentId: 'doc-1', documentType: 'article'}
       const {result} = renderHook(() => useNormalizedResourceOptions(opts))

package/src/hooks/helpers/useNormalizedResourceOptions.ts

@@ -6,7 +6,7 @@ import {PerspectiveContext} from '../../context/PerspectiveContext'
 import {ResourcesContext} from '../../context/ResourcesContext'
 import {SanityInstanceContext} from '../../context/SanityInstanceContext'
 
-type NormalizedResourceFields = 'resourceName' | 'source' | 'sourceName' | 'projectId' | 'dataset'
+type NormalizedResourceFields = 'resourceName' | 'projectId' | 'dataset'
 
 /**
  * Adds React hook support (resourceName resolution) to core types.
@@ -24,11 +24,6 @@ export type WithResourceNameSupport<T extends {resource?: DocumentResource}> = T
    * @beta
    */
   resourceName?: string
-  /**
-   * @deprecated Use `resourceName` instead.
-   * @beta
-   */
-  sourceName?: string
 }
 
 /**
@@ -48,8 +43,6 @@ export function normalizeResourceOptions<
   T extends {
     resource?: DocumentResource
     resourceName?: string
-    source?: DocumentResource
-    sourceName?: string
     projectId?: string
     dataset?: string
     perspective?: unknown
@@ -60,30 +53,27 @@ export function normalizeResourceOptions<
   contextResource?: DocumentResource,
   contextPerspective?: PerspectiveHandle['perspective'],
 ): Omit<T, NormalizedResourceFields> {
-  const {resourceName, sourceName, source, projectId, dataset, ...rest} = options
-
-  // Coalesce deprecated aliases to their canonical equivalents
-  const effectiveResourceName = resourceName ?? sourceName
-  const effectiveResource = options.resource ?? source
+  const {resourceName, projectId, dataset, ...rest} = options
+  const resource = options.resource
 
-  if (effectiveResourceName && effectiveResource) {
+  if (resourceName && resource) {
     throw new Error(
-      `Resource name ${JSON.stringify(effectiveResourceName)} and resource ${JSON.stringify(effectiveResource)} cannot be used together.`,
+      `Resource name ${JSON.stringify(resourceName)} and resource ${JSON.stringify(resource)} cannot be used together.`,
     )
   }
 
   let resolvedResource: DocumentResource | undefined
 
   // Tier (a): explicit resource object or resourceName lookup
-  if (effectiveResource) {
-    resolvedResource = effectiveResource
-  } else if (effectiveResourceName) {
-    if (!Object.hasOwn(resources, effectiveResourceName)) {
+  if (resource) {
+    resolvedResource = resource
+  } else if (resourceName) {
+    if (!Object.hasOwn(resources, resourceName)) {
       throw new Error(
-        `There's no resource named ${JSON.stringify(effectiveResourceName)} in context. Please use <ResourceProvider>.`,
+        `There's no resource named ${JSON.stringify(resourceName)} in context. Please use <ResourceProvider>.`,
       )
     }
-    resolvedResource = resources[effectiveResourceName]
+    resolvedResource = resources[resourceName]
   }
 
   // Tier (b): projectId or dataset in options → synthesize a resource
@@ -121,13 +111,14 @@ export function normalizeResourceOptions<
 export function useEffectiveContextResource(): DocumentResource | undefined {
   const contextResource = useContext(ResourceContext)
   const instance = useContext(SanityInstanceContext)
-  const {projectId, dataset} = instance?.config ?? {}
+  const {projectId, dataset, resource: configResource} = instance?.config ?? {}
 
   return useMemo(() => {
     if (contextResource) return contextResource
+    if (configResource) return configResource
     if (projectId && dataset) return {projectId, dataset}
     return undefined
-  }, [contextResource, projectId, dataset])
+  }, [contextResource, configResource, projectId, dataset])
 }
 
 /**
@@ -149,8 +140,6 @@ export function useNormalizedResourceOptions<
   T extends {
     resource?: DocumentResource
     resourceName?: string
-    source?: DocumentResource
-    sourceName?: string
     projectId?: string
     dataset?: string
     perspective?: PerspectiveHandle['perspective']

package/src/hooks/paginatedDocuments/usePaginatedDocuments.ts

@@ -1,10 +1,5 @@
-import {
-  createGroqSearchFilter,
-  type DocumentHandle,
-  isDatasetResource,
-  type QueryOptions,
-} from '@sanity/sdk'
-import {pickProperties} from '@sanity/sdk/_internal'
+import {type DocumentHandle, isDatasetResource, type QueryOptions} from '@sanity/sdk'
+import {createGroqSearchFilter, pickProperties} from '@sanity/sdk/_internal'
 import {type SortOrderingItem} from '@sanity/types'
 import {useCallback, useMemo, useState} from 'react'
 

package/src/hooks/presence/usePresence.ts

@@ -7,7 +7,20 @@ import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOpti
 import {trackHookUsage} from '../helpers/useTrackHookUsage'
 
 /**
- * A hook for subscribing to presence information for the current project or Canvas.
+ * Every participant in the current project and dataset, or Canvas.
+ *
+ * Reading presence never announces anything. Call `useReportPresence` to make the
+ * current user visible to others, including to the Studio, which shares the same
+ * presence room.
+ *
+ * This returns everyone in the whole resource and leaves the filtering to you.
+ * Prefer `usePresenceForDocument` when you care about one document: it scopes and
+ * flattens the result for rendering. Note that participants are counted by session,
+ * so one person in two tabs appears twice.
+ *
+ * Presence is scoped to a single project and dataset. It is not a list of everyone
+ * signed in to your organization.
+ *
  * @public
  */
 export function usePresence(options: ResourceHandle = {}): {

package/src/hooks/presence/usePresenceForDocument.test.tsx

@@ -0,0 +1,141 @@
+import {type DocumentPresence, getDocumentPresence} from '@sanity/sdk'
+import {act, renderHook} from '@testing-library/react'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {ResourceProvider} from '../../context/ResourceProvider'
+import {usePresenceForDocument} from './usePresenceForDocument'
+
+vi.mock('@sanity/sdk', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@sanity/sdk')>()
+  return {...actual, getDocumentPresence: vi.fn()}
+})
+
+const entry = (sessionId: string): DocumentPresence =>
+  ({
+    sessionId,
+    documentId: 'movie-1',
+    path: ['title'],
+    lastActiveAt: '2026-07-30T12:00:00Z',
+    user: {sanityUserId: 'u1', profile: {id: 'u1'}, memberships: []},
+  }) as unknown as DocumentPresence
+
+/** A minimal StateSource stand-in whose value can be pushed. */
+function createSource(initial: DocumentPresence[]) {
+  let current = initial
+  const listeners = new Set<() => void>()
+  return {
+    source: {
+      getCurrent: () => current,
+      subscribe: (cb: () => void) => {
+        listeners.add(cb)
+        return () => listeners.delete(cb)
+      },
+    },
+    push: (next: DocumentPresence[]) => {
+      current = next
+      listeners.forEach((cb) => cb())
+    },
+  }
+}
+
+const wrapper = ({children}: {children: React.ReactNode}) => (
+  <ResourceProvider projectId="p" dataset="d" fallback={null}>
+    {children}
+  </ResourceProvider>
+)
+
+describe('usePresenceForDocument', () => {
+  beforeEach(() => {
+    // Without this, `mock.calls[0]` is whatever the previous test did.
+    vi.clearAllMocks()
+  })
+
+  it('returns presence and updates when the store changes', () => {
+    const {source, push} = createSource([entry('s1')])
+    vi.mocked(getDocumentPresence).mockReturnValue(source as never)
+
+    const {result} = renderHook(
+      () => usePresenceForDocument({documentId: 'movie-1', documentType: 'movie'}),
+      {wrapper},
+    )
+
+    expect(result.current.presence).toHaveLength(1)
+
+    act(() => push([entry('s1'), entry('s2')]))
+    expect(result.current.presence).toHaveLength(2)
+  })
+
+  it('passes the document, path, and excludeVersions through', () => {
+    const {source} = createSource([])
+    vi.mocked(getDocumentPresence).mockReturnValue(source as never)
+
+    renderHook(
+      () =>
+        usePresenceForDocument({
+          documentId: 'drafts.movie-1',
+          documentType: 'movie',
+          path: ['cast', {_key: 'm1'}],
+          excludeVersions: true,
+        }),
+      {wrapper},
+    )
+
+    // Already a draft id, so resolution leaves it alone.
+    expect(vi.mocked(getDocumentPresence).mock.calls[0][1]).toMatchObject({
+      documentId: 'drafts.movie-1',
+      path: ['cast', {_key: 'm1'}],
+      excludeVersions: true,
+    })
+  })
+
+  it('reads the same id useReportPresence writes, or reads never match writes', () => {
+    const {source} = createSource([])
+    vi.mocked(getDocumentPresence).mockReturnValue(source as never)
+
+    // Forwarded unresolved, exactly as `useReportPresence` forwards it, so core
+    // resolves both the same way. If these diverged, field-level presence would
+    // silently never match.
+    renderHook(
+      () =>
+        usePresenceForDocument({
+          documentId: 'movie-1',
+          documentType: 'movie',
+          perspective: 'published',
+        }),
+      {wrapper},
+    )
+
+    expect(vi.mocked(getDocumentPresence).mock.calls[0][1]).toMatchObject({
+      documentId: 'movie-1',
+      perspective: 'published',
+    })
+  })
+
+  it('does not rebuild the source when a caller passes a fresh path each render', () => {
+    const {source} = createSource([])
+    vi.mocked(getDocumentPresence).mockReturnValue(source as never)
+
+    const {rerender} = renderHook(
+      // A new array identity every render, which is what real callers write.
+      () => usePresenceForDocument({documentId: 'movie-1', documentType: 'movie', path: ['title']}),
+      {wrapper},
+    )
+
+    rerender()
+    rerender()
+
+    expect(vi.mocked(getDocumentPresence)).toHaveBeenCalledTimes(1)
+  })
+
+  it('returns an empty array rather than undefined before anything arrives', () => {
+    const {source} = createSource(undefined as unknown as DocumentPresence[])
+    vi.mocked(getDocumentPresence).mockReturnValue(source as never)
+
+    const {result} = renderHook(
+      () => usePresenceForDocument({documentId: 'movie-1', documentType: 'movie'}),
+      {wrapper},
+    )
+
+    expect(result.current.presence).toEqual([])
+  })
+})

package/src/hooks/presence/usePresenceForDocument.ts

@@ -0,0 +1,104 @@
+import {type DocumentPresence, getDocumentPresence, isMediaLibraryResource} from '@sanity/sdk'
+import {type Path} from '@sanity/types'
+import {useCallback, useMemo, useSyncExternalStore} from 'react'
+
+import {type DocumentHandle} from '../../config/handles'
+import {useSanityInstance} from '../context/useSanityInstance'
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
+import {trackHookUsage} from '../helpers/useTrackHookUsage'
+
+/** @beta */
+export interface UsePresenceForDocumentOptions extends DocumentHandle {
+  /**
+   * Narrows to participants at or below this field path, which is what a field
+   * indicator wants. Omit it for everyone in the document.
+   */
+  path?: Path
+
+  /**
+   * By default a draft, its published version, and any release versions count as
+   * the same document, which is what document lists want. Set this to compare ids
+   * exactly, so that a draft and a release version do not bleed into each other.
+   */
+  excludeVersions?: boolean
+}
+
+/**
+ * Who else is in a document, flattened to one entry per participant per location
+ * so it can be rendered straight against a field.
+ *
+ * Reading presence never announces anything. Use `useReportPresence` to make the
+ * current user visible to others.
+ *
+ * Prefer this over `usePresence` when you care about one document: `usePresence`
+ * returns every participant in the whole project and dataset, leaving the filtering
+ * to you.
+ *
+ * Resolves the document through its perspective exactly as `useReportPresence` does,
+ * so reads match writes. Participants are counted by session, so one person in two
+ * tabs appears twice.
+ *
+ * @example Avatars on a document
+ * ```tsx
+ * const {presence} = usePresenceForDocument({documentId, documentType})
+ * return presence.map((p) => <Avatar key={p.sessionId} user={p.user} />)
+ * ```
+ *
+ * @example Avatars on a single field
+ * ```tsx
+ * const {presence} = usePresenceForDocument({
+ *   documentId,
+ *   documentType,
+ *   path: ['title'],
+ *   excludeVersions: true,
+ * })
+ * ```
+ *
+ * @beta
+ */
+export function usePresenceForDocument(options: UsePresenceForDocumentOptions): {
+  presence: DocumentPresence[]
+} {
+  const {path, excludeVersions, ...handle} = options
+
+  const normalizedOptions = useNormalizedResourceOptions(handle)
+  if (normalizedOptions.resource && isMediaLibraryResource(normalizedOptions.resource)) {
+    throw new Error(
+      'usePresenceForDocument() does not support media library resources. Presence tracking requires a canvas or dataset resource.',
+    )
+  }
+
+  const sanityInstance = useSanityInstance()
+  trackHookUsage(sanityInstance, 'usePresenceForDocument')
+
+  const {resource, perspective} = normalizedOptions
+  const {documentId, liveEdit} = options
+
+  // Serialized so a caller passing a fresh `path` array each render does not
+  // rebuild the state source every render.
+  const pathKey = useMemo(() => JSON.stringify(path ?? null), [path])
+
+  const source = useMemo(
+    () =>
+      getDocumentPresence(sanityInstance, {
+        ...(resource ? {resource} : {}),
+        documentId,
+        // Forwarded, not resolved here, so this matches what `useReportPresence`
+        // sends. Core owns turning a perspective into a specific document id.
+        ...(perspective ? {perspective} : {}),
+        ...(liveEdit ? {liveEdit} : {}),
+        ...(pathKey === 'null' ? {} : {path: JSON.parse(pathKey) as Path}),
+        ...(excludeVersions === undefined ? {} : {excludeVersions}),
+      }),
+    [sanityInstance, resource, documentId, perspective, liveEdit, pathKey, excludeVersions],
+  )
+
+  const subscribe = useCallback((callback: () => void) => source.subscribe(callback), [source])
+  const presence = useSyncExternalStore(
+    subscribe,
+    () => source.getCurrent(),
+    () => source.getCurrent(),
+  )
+
+  return {presence: presence || []}
+}