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

package/src/context/{WorkbenchTokenRefresh.test.tsx → DashboardTokenRefresh.test.tsx}

@@ -4,13 +4,13 @@ import {of} from 'rxjs'
 import {afterEach, beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
 
 import {useAuthState} from '../hooks/auth/useAuthState'
-import {ResourceProvider} from './ResourceProvider'
 import {
-  isWorkbenchEnvironment,
-  observeWorkbenchToken,
-  refreshWorkbenchToken,
-} from './workbenchToken'
-import {WorkbenchTokenRefreshProvider} from './WorkbenchTokenRefresh'
+  isDashboardEnvironment,
+  observeDashboardToken,
+  refreshDashboardToken,
+} from './dashboardToken'
+import {DashboardTokenRefreshProvider} from './DashboardTokenRefresh'
+import {ResourceProvider} from './ResourceProvider'
 
 vi.mock('@sanity/sdk', async () => {
   const actual = await vi.importActual('@sanity/sdk')
@@ -24,28 +24,28 @@ vi.mock('../hooks/auth/useAuthState', () => ({
   useAuthState: vi.fn(),
 }))
 
-vi.mock('./workbenchToken', () => ({
-  isWorkbenchEnvironment: vi.fn(() => false),
-  observeWorkbenchToken: vi.fn(() => undefined),
-  refreshWorkbenchToken: vi.fn(),
+vi.mock('./dashboardToken', () => ({
+  isDashboardEnvironment: vi.fn(() => false),
+  observeDashboardToken: vi.fn(() => undefined),
+  refreshDashboardToken: vi.fn(),
 }))
 
 const mockSetAuthToken = setAuthToken as Mock
 const mockUseAuthState = useAuthState as Mock
-const mockIsWorkbenchEnvironment = isWorkbenchEnvironment as Mock
-const mockObserveWorkbenchToken = observeWorkbenchToken as Mock
-const mockRefreshWorkbenchToken = refreshWorkbenchToken as Mock
+const mockIsDashboardEnvironment = isDashboardEnvironment as Mock
+const mockObserveDashboardToken = observeDashboardToken as Mock
+const mockRefreshDashboardToken = refreshDashboardToken as Mock
 
 const renderProvider = () =>
   render(
     <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-      <WorkbenchTokenRefreshProvider>
+      <DashboardTokenRefreshProvider>
         <div>Test</div>
-      </WorkbenchTokenRefreshProvider>
+      </DashboardTokenRefreshProvider>
     </ResourceProvider>,
   )
 
-describe('WorkbenchTokenRefreshProvider', () => {
+describe('DashboardTokenRefreshProvider', () => {
   beforeEach(() => {
     mockUseAuthState.mockReturnValue({type: AuthStateType.LOGGED_IN})
   })
@@ -54,9 +54,9 @@ describe('WorkbenchTokenRefreshProvider', () => {
     vi.clearAllMocks()
   })
 
-  describe('when not in the workbench', () => {
+  describe('when not in the dashboard', () => {
     it('does not subscribe to the OS token', () => {
-      mockIsWorkbenchEnvironment.mockReturnValue(false)
+      mockIsDashboardEnvironment.mockReturnValue(false)
 
       act(() => {
         renderProvider()
@@ -66,23 +66,23 @@ describe('WorkbenchTokenRefreshProvider', () => {
     })
   })
 
-  describe('when in the workbench', () => {
+  describe('when in the dashboard', () => {
     beforeEach(() => {
-      mockIsWorkbenchEnvironment.mockReturnValue(true)
+      mockIsDashboardEnvironment.mockReturnValue(true)
     })
 
     it('mirrors the OS token into the auth store', () => {
-      mockObserveWorkbenchToken.mockReturnValue(of('workbench-token'))
+      mockObserveDashboardToken.mockReturnValue(of('dashboard-token'))
 
       act(() => {
         renderProvider()
       })
 
-      expect(mockSetAuthToken).toHaveBeenCalledWith(expect.anything(), 'workbench-token')
+      expect(mockSetAuthToken).toHaveBeenCalledWith(expect.anything(), 'dashboard-token')
     })
 
     it('asks the OS to reissue the token on a 401', () => {
-      mockObserveWorkbenchToken.mockReturnValue(of('workbench-token'))
+      mockObserveDashboardToken.mockReturnValue(of('dashboard-token'))
 
       const {rerender} = renderProvider()
 
@@ -93,14 +93,14 @@ describe('WorkbenchTokenRefreshProvider', () => {
       act(() => {
         rerender(
           <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-            <WorkbenchTokenRefreshProvider>
+            <DashboardTokenRefreshProvider>
               <div>Test</div>
-            </WorkbenchTokenRefreshProvider>
+            </DashboardTokenRefreshProvider>
           </ResourceProvider>,
         )
       })
 
-      expect(mockRefreshWorkbenchToken).toHaveBeenCalledTimes(1)
+      expect(mockRefreshDashboardToken).toHaveBeenCalledTimes(1)
     })
   })
 })

package/src/context/{WorkbenchTokenRefresh.tsx → DashboardTokenRefresh.tsx}

@@ -5,28 +5,28 @@ import React, {type PropsWithChildren, useEffect, useRef} from 'react'
 import {useAuthState} from '../hooks/auth/useAuthState'
 import {useSanityInstance} from '../hooks/context/useSanityInstance'
 import {
-  isWorkbenchEnvironment,
-  observeWorkbenchToken,
-  refreshWorkbenchToken,
-} from './workbenchToken'
+  isDashboardEnvironment,
+  observeDashboardToken,
+  refreshDashboardToken,
+} from './dashboardToken'
 
 /**
- * Keeps the SDK auth token in sync with the workbench "OS".
+ * Keeps the SDK auth token in sync with the dashboard "OS".
  *
- * When running as a federated remote inside the workbench the OS owns the
+ * When running as a federated remote inside the dashboard the OS owns the
  * session, so we subscribe to its `auth.token` stream and mirror each value into
  * the auth store — a token logs us in, `null` logs us out, and later OS
  * sign-in/out propagates automatically. When a request is rejected with a 401
  * (the token expired), we ask the OS to reissue rather than tearing the session
  * down; the new token arrives back through the same subscription.
  */
-function WorkbenchTokenRefresh({children}: PropsWithChildren) {
+function DashboardTokenRefresh({children}: PropsWithChildren) {
   const instance = useSanityInstance()
   const authState = useAuthState()
   const processed401ErrorRef = useRef<unknown | null>(null)
 
   useEffect(() => {
-    const token$ = observeWorkbenchToken()
+    const token$ = observeDashboardToken()
     if (!token$) return undefined
     const subscription = token$.subscribe((token) => setAuthToken(instance, token))
     return () => subscription.unsubscribe()
@@ -38,7 +38,7 @@ function WorkbenchTokenRefresh({children}: PropsWithChildren) {
 
     if (has401Error && processed401ErrorRef.current !== authState.error) {
       processed401ErrorRef.current = authState.error
-      refreshWorkbenchToken()
+      refreshDashboardToken()
     } else if (!has401Error) {
       processed401ErrorRef.current = null
     }
@@ -48,13 +48,13 @@ function WorkbenchTokenRefresh({children}: PropsWithChildren) {
 }
 
 /**
- * Provides workbench OS token refresh. No-op outside the workbench, where the
+ * Provides dashboard OS token refresh. No-op outside the dashboard, where the
  * app uses its normal auth flow.
- * @public
+ * @internal
  */
-export const WorkbenchTokenRefreshProvider: React.FC<PropsWithChildren> = ({children}) => {
-  if (isWorkbenchEnvironment()) {
-    return <WorkbenchTokenRefresh>{children}</WorkbenchTokenRefresh>
+export const DashboardTokenRefreshProvider: React.FC<PropsWithChildren> = ({children}) => {
+  if (isDashboardEnvironment()) {
+    return <DashboardTokenRefresh>{children}</DashboardTokenRefresh>
   }
 
   return children

package/src/context/OrganizationResourcesProvider.test.tsx

@@ -3,7 +3,7 @@ import {act, render} from '@testing-library/react'
 import {type ReactNode, Suspense, useContext, useEffect} from 'react'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {useDashboardOrganizationId} from '../hooks/auth/useDashboardOrganizationId'
+import {useOrganizationId} from '../hooks/dashboard/useOrganizationId'
 import {resolveOrgResources} from '../utils/resolveOrgResources'
 import {OrganizationResourcesProvider} from './OrganizationResourcesProvider'
 import {ResourcesContext} from './ResourcesContext'
@@ -28,8 +28,8 @@ vi.mock('../hooks/context/useSanityInstance', () => {
   return {useSanityInstance: () => instance}
 })
 
-vi.mock('../hooks/auth/useDashboardOrganizationId', () => ({
-  useDashboardOrganizationId: vi.fn(),
+vi.mock('../hooks/dashboard/useOrganizationId', () => ({
+  useOrganizationId: vi.fn(),
 }))
 
 vi.mock('../utils/resolveOrgResources', () => ({
@@ -37,14 +37,14 @@ vi.mock('../utils/resolveOrgResources', () => ({
 }))
 
 const mockResolveOrgResources = vi.mocked(resolveOrgResources)
-const mockUseDashboardOrganizationId = vi.mocked(useDashboardOrganizationId)
+const mockUseOrganizationId = vi.mocked(useOrganizationId)
 
 describe('OrganizationResourcesProvider', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     instance = createSanityInstance()
     mockResolveOrgResources.mockResolvedValue({})
-    mockUseDashboardOrganizationId.mockReturnValue(undefined)
+    mockUseOrganizationId.mockReturnValue(undefined)
   })
 
   // Captures ResourcesContext via useEffect (side-effect territory, not render)
@@ -91,7 +91,7 @@ describe('OrganizationResourcesProvider', () => {
   })
 
   it('suspends children while org resources are being fetched, then renders with resolved resources', async () => {
-    mockUseDashboardOrganizationId.mockReturnValue('org-suspend-test')
+    mockUseOrganizationId.mockReturnValue('org-suspend-test')
     const {promise, resolve} = promiseWithResolvers<void>()
     mockResolveOrgResources.mockReturnValue(
       promise.then(() => ({
@@ -115,7 +115,7 @@ describe('OrganizationResourcesProvider', () => {
   })
 
   it('renders without inferred entries and logs a warning when resolveOrgResources rejects', async () => {
-    mockUseDashboardOrganizationId.mockReturnValue('org-warn-test')
+    mockUseOrganizationId.mockReturnValue('org-warn-test')
     const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
     mockResolveOrgResources.mockRejectedValue(new Error('fetch failed'))
 
@@ -135,7 +135,7 @@ describe('OrganizationResourcesProvider', () => {
   })
 
   it('caches Promise references across providers for the same instance', () => {
-    mockUseDashboardOrganizationId.mockReturnValue('org-cache-test')
+    mockUseOrganizationId.mockReturnValue('org-cache-test')
     render(
       <Suspense fallback={null}>
         <OrganizationResourcesProvider inferMediaLibraryAndCanvas>
@@ -168,7 +168,7 @@ describe('OrganizationResourcesProvider', () => {
   })
 
   it('explicit resources take precedence over inferred ones', async () => {
-    mockUseDashboardOrganizationId.mockReturnValue('org-override-test')
+    mockUseOrganizationId.mockReturnValue('org-override-test')
     mockResolveOrgResources.mockResolvedValue({
       mediaLibrary: {mediaLibraryId: 'inferred-ml'},
       canvas: {canvasId: 'inferred-canvas'},

package/src/context/OrganizationResourcesProvider.tsx

@@ -1,8 +1,8 @@
 import {type DocumentResource, type SanityInstance} from '@sanity/sdk'
 import {type ReactElement, type ReactNode, use, useMemo} from 'react'
 
-import {useDashboardOrganizationId} from '../hooks/auth/useDashboardOrganizationId'
 import {useSanityInstance} from '../hooks/context/useSanityInstance'
+import {useOrganizationId} from '../hooks/dashboard/useOrganizationId'
 import {resolveOrgResources} from '../utils/resolveOrgResources'
 import {ResourcesContext} from './ResourcesContext'
 
@@ -91,7 +91,7 @@ export function OrganizationResourcesProvider({
   children: ReactNode
 }): ReactElement {
   const instance = useSanityInstance()
-  const orgId = useDashboardOrganizationId()
+  const orgId = useOrganizationId()
 
   if (!inferMediaLibraryAndCanvas || !orgId) {
     return (

package/src/context/ResourceProvider.test.tsx

@@ -59,6 +59,27 @@ describe('ResourceProvider', () => {
     consoleSpy.mockRestore()
   })
 
+  it('renders nothing during loading when fallback is null', async () => {
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const {promise, resolve} = promiseWithResolvers()
+    function SuspendingChild(): React.ReactNode {
+      throw promise
+    }
+
+    const {container} = render(
+      <ResourceProvider {...testConfig} fallback={null}>
+        <SuspendingChild />
+      </ResourceProvider>,
+    )
+
+    expect(container).toBeEmptyDOMElement()
+    act(() => {
+      resolve()
+    })
+    await new Promise((r) => setTimeout(r, 0))
+    consoleSpy.mockRestore()
+  })
+
   it('creates root instance when no parent context exists', async () => {
     const {promise, resolve} = promiseWithResolvers<SanityInstance | null>()
 

package/src/context/ResourceProvider.tsx

@@ -130,7 +130,10 @@ export function ResourceProvider({
   }, [instance, parentInstance])
 
   return (
-    <SanityInstanceProvider instance={instance} fallback={fallback ?? DEFAULT_FALLBACK}>
+    <SanityInstanceProvider
+      instance={instance}
+      fallback={fallback === undefined ? DEFAULT_FALLBACK : fallback}
+    >
       <ResourceContext.Provider value={effectiveResource}>
         <ProjectContext.Provider value={effectiveProjectId}>
           <PerspectiveContext.Provider value={perspective ?? parentPerspective}>

package/src/context/{workbenchToken.ts → dashboardToken.ts}

@@ -1,13 +1,13 @@
 import {from, type Observable, of} from 'rxjs'
 import {catchError, switchMap} from 'rxjs/operators'
 
-// The workbench host installs its shared message bus on this well-known global
+// The dashboard host installs its shared message bus on this well-known global
 // symbol before it loads federated remotes. It must match the key used by
 // `@sanity/workbench` (`Symbol.for('sanity.os.bus')`).
 const OS_BUS_KEY = Symbol.for('sanity.os.bus')
 
 /**
- * Whether this app is running as a federated remote inside the workbench.
+ * Whether this app is running as a federated remote inside the dashboard.
  *
  * Federation shares the host's realm, so the installed bus is visible on
  * `globalThis`. This is `false` in a standalone app, where we must never import
@@ -18,16 +18,16 @@ const OS_BUS_KEY = Symbol.for('sanity.os.bus')
  *
  * @internal
  */
-export function isWorkbenchEnvironment(): boolean {
+export function isDashboardEnvironment(): boolean {
   return typeof globalThis === 'object' && OS_BUS_KEY in globalThis
 }
 
 /**
- * Observes the session token issued by the workbench "OS", tracking the OS auth
+ * Observes the session token issued by the dashboard "OS", tracking the OS auth
  * state over time.
  *
- * Returns `undefined` when the app is not embedded in the workbench, so the
- * caller uses its normal auth flow. Inside the workbench, subscribes to the
+ * Returns `undefined` when the app is not embedded in the dashboard, so the
+ * caller uses its normal auth flow. Inside the dashboard, subscribes to the
  * `auth.token` state topic, emitting the current token — or `null` when the OS
  * is signed out — and re-emitting as the OS auth state changes, so sign-in/out
  * propagates instead of being captured once. Any bus error is treated as "no
@@ -35,8 +35,8 @@ export function isWorkbenchEnvironment(): boolean {
  *
  * @internal
  */
-export function observeWorkbenchToken(): Observable<string | null> | undefined {
-  if (!isWorkbenchEnvironment()) return undefined
+export function observeDashboardToken(): Observable<string | null> | undefined {
+  if (!isDashboardEnvironment()) return undefined
 
   return from(import('@sanity/workbench')).pipe(
     switchMap(({os}) => os.subscribe('auth.token')),
@@ -46,15 +46,15 @@ export function observeWorkbenchToken(): Observable<string | null> | undefined {
 }
 
 /**
- * Asks the workbench "OS" to reissue the session token, e.g. after its current
+ * Asks the dashboard "OS" to reissue the session token, e.g. after its current
  * one was rejected with a 401. Fire-and-forget: the reissued token arrives via
- * the `auth.token` subscription in {@link observeWorkbenchToken}. No-op outside
- * the workbench.
+ * the `auth.token` subscription in {@link observeDashboardToken}. No-op outside
+ * the dashboard.
  *
  * @internal
  */
-export function refreshWorkbenchToken(): void {
-  if (!isWorkbenchEnvironment()) return
+export function refreshDashboardToken(): void {
+  if (!isDashboardEnvironment()) return
 
   void import('@sanity/workbench').then(
     ({os}) => os.emit('auth.token.refresh', undefined),

package/src/hooks/agent/agentActions.test.tsx

@@ -12,7 +12,7 @@ import {
   useAgentTranslate,
 } from './agentActions'
 
-vi.mock('@sanity/sdk', async (orig) => {
+vi.mock('@sanity/sdk/agent', async (orig) => {
   const actual = await orig()
   return {
     ...(actual as Record<string, any>),

package/src/hooks/agent/agentActions.ts

@@ -11,7 +11,7 @@ import {
   type AgentTransformOptions,
   agentTranslate,
   type AgentTranslateOptions,
-} from '@sanity/sdk'
+} from '@sanity/sdk/agent'
 import {useCallback} from 'react'
 import {firstValueFrom} from 'rxjs'
 

package/src/hooks/comlink/useFrameConnection.test.tsx

@@ -4,7 +4,7 @@ import {beforeEach, describe, expect, it, vi} from 'vitest'
 import {act, renderHook} from '../../../test/test-utils'
 import {useFrameConnection} from './useFrameConnection'
 
-vi.mock(import('@sanity/sdk'), async (importOriginal) => {
+vi.mock(import('@sanity/sdk/comlink'), async (importOriginal) => {
   const actual = await importOriginal()
   return {
     ...actual,
@@ -14,7 +14,8 @@ vi.mock(import('@sanity/sdk'), async (importOriginal) => {
   }
 })
 
-const {getOrCreateChannel, getOrCreateController, releaseChannel} = await import('@sanity/sdk')
+const {getOrCreateChannel, getOrCreateController, releaseChannel} =
+  await import('@sanity/sdk/comlink')
 
 interface TestControllerMessage {
   type: 'TEST_MESSAGE'

package/src/hooks/comlink/useFrameConnection.ts

@@ -5,7 +5,7 @@ import {
   getOrCreateController,
   releaseChannel,
   type WindowMessage,
-} from '@sanity/sdk'
+} from '@sanity/sdk/comlink'
 import {useCallback, useEffect, useRef} from 'react'
 
 import {useSanityInstance} from '../context/useSanityInstance'

package/src/hooks/comlink/useWindowConnection.test.tsx

@@ -1,5 +1,6 @@
 import {type Message, type Node} from '@sanity/comlink'
-import {getNodeState, type NodeState, type StateSource} from '@sanity/sdk'
+import {type StateSource} from '@sanity/sdk'
+import {getNodeState, type NodeState} from '@sanity/sdk/comlink'
 import {screen} from '@testing-library/react'
 import {Suspense} from 'react'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
@@ -7,8 +8,8 @@ import {beforeEach, describe, expect, it, vi} from 'vitest'
 import {render, renderHook} from '../../../test/test-utils'
 import {useWindowConnection} from './useWindowConnection'
 
-vi.mock('@sanity/sdk', async () => {
-  const actual = await vi.importActual('@sanity/sdk')
+vi.mock('@sanity/sdk/comlink', async () => {
+  const actual = await vi.importActual('@sanity/sdk/comlink')
   return {
     ...actual,
     getNodeState: vi.fn(),

package/src/hooks/comlink/useWindowConnection.ts

@@ -1,12 +1,11 @@
 import {type MessageData, type NodeInput} from '@sanity/comlink'
+import {type SanityInstance, type StateSource} from '@sanity/sdk'
 import {
   type FrameMessage,
   getNodeState,
   type NodeState,
-  type SanityInstance,
-  type StateSource,
   type WindowMessage,
-} from '@sanity/sdk'
+} from '@sanity/sdk/comlink'
 import {useCallback, useEffect, useRef} from 'react'
 import {filter, firstValueFrom} from 'rxjs'
 
@@ -67,7 +66,7 @@ const useNodeState = createStateSourceHook({
  * as well as sharing a single node between invocations if they share the same name.
  *
  * Generally not to be used directly, but to be used as a dependency of
- * Comlink-powered hooks like `useManageFavorite`.
+ * Comlink-powered hooks like `useStudioWorkspacesByProjectIdDataset`.
  */
 export function useWindowConnection<
   TWindowMessage extends WindowMessage,

package/src/hooks/comments/useCommentActions.test.tsx

@@ -0,0 +1,150 @@
+import {
+  createComment,
+  removeComment,
+  replyToComment,
+  setCommentStatus,
+  updateComment,
+} from '@sanity/sdk'
+import {renderHook} from '@testing-library/react'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {ResourceProvider} from '../../context/ResourceProvider'
+import {ResourcesContext} from '../../context/ResourcesContext'
+import {useCommentActions} from './useCommentActions'
+
+vi.mock('@sanity/sdk', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@sanity/sdk')>()
+  return {
+    ...original,
+    createComment: vi.fn(),
+    replyToComment: vi.fn(),
+    updateComment: vi.fn(),
+    setCommentStatus: vi.fn(),
+    removeComment: vi.fn(),
+  }
+})
+
+const HANDLE = {documentId: 'doc-1', documentType: 'author'}
+
+/** Creates name a field, since a comment with no path is refused. */
+const CREATE = {...HANDLE, fieldPath: 'name'}
+
+// Hoisted: an inline object here would be a new value on every render, and the
+// callbacks are memoised against it.
+const RESOURCES = {other: {projectId: 'p2', dataset: 'd2'}}
+
+/** Hoisted for the same reason as `RESOURCES`. */
+const RELEASE_PERSPECTIVE = {releaseName: 'summer'}
+
+function Wrapper({children}: {children: React.ReactNode}) {
+  return (
+    <ResourceProvider projectId="p" dataset="d" fallback={null}>
+      <ResourcesContext.Provider value={RESOURCES}>{children}</ResourcesContext.Provider>
+    </ResourceProvider>
+  )
+}
+
+function PerspectiveWrapper({children}: {children: React.ReactNode}) {
+  return (
+    <ResourceProvider projectId="p" dataset="d" perspective={RELEASE_PERSPECTIVE} fallback={null}>
+      <ResourcesContext.Provider value={RESOURCES}>{children}</ResourcesContext.Provider>
+    </ResourceProvider>
+  )
+}
+
+function setup(wrapper: typeof Wrapper = Wrapper) {
+  return renderHook(() => useCommentActions(), {wrapper})
+}
+
+describe('useCommentActions', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+  })
+
+  it('keeps the callbacks stable across renders', () => {
+    const {result, rerender} = setup()
+    const first = result.current
+
+    rerender()
+
+    expect(result.current).toBe(first)
+  })
+
+  it('forwards each action to the store', () => {
+    const {result} = setup()
+
+    result.current.createComment({...CREATE, message: null})
+    result.current.replyToComment({...HANDLE, parentCommentId: 'p1', message: null})
+    result.current.updateComment({commentId: 'c1', message: null})
+    result.current.setCommentStatus({commentId: 'c1', status: 'resolved'})
+    result.current.removeComment({commentId: 'c1'})
+
+    expect(createComment).toHaveBeenCalledOnce()
+    expect(replyToComment).toHaveBeenCalledOnce()
+    expect(updateComment).toHaveBeenCalledOnce()
+    expect(setCommentStatus).toHaveBeenCalledOnce()
+    expect(removeComment).toHaveBeenCalledOnce()
+  })
+
+  it('fills in the resource from context', () => {
+    const {result} = setup()
+
+    result.current.createComment({...CREATE, message: null})
+
+    expect(createComment).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({resource: {projectId: 'p', dataset: 'd'}}),
+    )
+  })
+
+  it('lets a call choose a different named resource', () => {
+    // Resolution happens per call, so one set of callbacks serves several
+    // resources.
+    const {result} = setup()
+
+    result.current.removeComment({commentId: 'c1', resourceName: 'other'})
+
+    expect(removeComment).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({resource: {projectId: 'p2', dataset: 'd2'}}),
+    )
+  })
+
+  it('rejects a call naming a resource that is not in context', () => {
+    const {result} = setup()
+
+    expect(() => result.current.removeComment({commentId: 'c1', resourceName: 'missing'})).toThrow(
+      /no resource named "missing"/,
+    )
+  })
+
+  it('fills in the perspective from context', () => {
+    // Core turns a release perspective into `target.documentVersionId`, so
+    // losing it here files the comment against the wrong release and nothing
+    // reports an error.
+    const {result} = setup(PerspectiveWrapper)
+
+    result.current.createComment({...CREATE, message: null})
+    result.current.replyToComment({...HANDLE, parentCommentId: 'p1', message: null})
+
+    expect(createComment).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({perspective: RELEASE_PERSPECTIVE}),
+    )
+    expect(replyToComment).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({perspective: RELEASE_PERSPECTIVE}),
+    )
+  })
+
+  it('lets a call override the perspective from context', () => {
+    const {result} = setup(PerspectiveWrapper)
+
+    result.current.createComment({...CREATE, message: null, perspective: 'published'})
+
+    expect(createComment).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({perspective: 'published'}),
+    )
+  })
+})