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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/sdk-react",
-  "version": "3.0.0-rc.1",
+  "version": "3.0.0-rc.2",
   "private": false,
   "description": "Sanity SDK React toolkit for Content OS",
   "keywords": [
@@ -33,32 +33,28 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": {
-      "source": "./src/_exports/index.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    },
+    ".": "./dist/index.js",
     "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@sanity/client": "^7.23.2",
-    "@sanity/message-protocol": "^0.23.0",
-    "@sanity/types": "^6.5.0",
+    "@sanity/client": "^7.26.2",
+    "@sanity/message-protocol": "^0.24.0",
+    "@sanity/types": "^6.9.1",
     "@sanity/workbench": "0.1.0-alpha.24",
     "groq": "3.88.1-typegen-experimental.0",
     "react-compiler-runtime": "^1.0.0",
     "react-error-boundary": "^6.1.2",
     "rxjs": "^7.8.2",
     "xstate": "^5.31.0",
-    "@sanity/sdk": "3.0.0-rc.1"
+    "@sanity/sdk": "3.0.0-rc.2"
   },
   "devDependencies": {
     "@sanity/browserslist-config": "^1.0.5",
-    "@sanity/comlink": "^4.0.1",
-    "@sanity/pkg-utils": "^10.9.2",
+    "@sanity/comlink": "^4.0.3",
+    "@sanity/pkg-utils": "^12.1.0",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.2",
     "@types/node": "^24.13.3",
@@ -73,13 +69,13 @@
     "oxfmt": "^0.58.0",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
-    "rollup-plugin-visualizer": "^7.0.1",
+    "rolldown": "^1.2.3",
     "typescript": "^6.0.3",
     "vite": "^8.1.5",
     "vitest": "^4.1.10",
+    "@repo/package.bundle": "3.82.0",
     "@repo/config-eslint": "0.0.0",
     "@repo/config-test": "0.0.1",
-    "@repo/package.bundle": "3.82.0",
     "@repo/package.config": "0.0.1",
     "@repo/tsconfig": "0.0.1"
   },
@@ -88,6 +84,9 @@
     "react-dom": "^18.0.0 || ^19.0.0"
   },
   "browserslist": "extends @sanity/browserslist-config",
+  "inlinedDependencies": {
+    "@sanity/comlink": "4.0.3"
+  },
   "scripts": {
     "build": "pkg build --strict --clean --check",
     "build:bundle": "vite build --configLoader runner --config package.bundle.ts",

package/src/_exports/sdk-react.ts

@@ -27,13 +27,8 @@ export {
 } from '../hooks/agent/useAgentResourceContext'
 export {useApplication} from '../hooks/applications/useApplication'
 export {useApplications} from '../hooks/applications/useApplications'
-export {useCreateUserApplication} from '../hooks/applications/useCreateUserApplication'
 export {useDeleteApplication} from '../hooks/applications/useDeleteApplication'
-export {useDeleteUserApplication} from '../hooks/applications/useDeleteUserApplication'
 export {useUpdateApplication} from '../hooks/applications/useUpdateApplication'
-export {useUpdateUserApplication} from '../hooks/applications/useUpdateUserApplication'
-export {useUserApplication} from '../hooks/applications/useUserApplication'
-export {useUserApplications} from '../hooks/applications/useUserApplications'
 export {useAuthState} from '../hooks/auth/useAuthState'
 export {useAuthToken} from '../hooks/auth/useAuthToken'
 export {useCurrentUser} from '../hooks/auth/useCurrentUser'
@@ -55,6 +50,9 @@ export {
   type WindowConnection,
   type WindowMessageHandler,
 } from '../hooks/comlink/useWindowConnection'
+export {type CommentActions, useCommentActions} from '../hooks/comments/useCommentActions'
+export {useComments, type UseCommentsResult} from '../hooks/comments/useComments'
+export {useCommentThreads, type UseCommentThreadsResult} from '../hooks/comments/useCommentThreads'
 export {useResource} from '../hooks/context/useResource'
 export {useSanityInstance} from '../hooks/context/useSanityInstance'
 export {useDashboardNavigate} from '../hooks/dashboard/useDashboardNavigate'
@@ -91,6 +89,11 @@ export {
   usePaginatedDocuments,
 } from '../hooks/paginatedDocuments/usePaginatedDocuments'
 export {usePresence} from '../hooks/presence/usePresence'
+export {
+  usePresenceForDocument,
+  type UsePresenceForDocumentOptions,
+} from '../hooks/presence/usePresenceForDocument'
+export {useReportPresence, type UseReportPresenceOptions} from '../hooks/presence/useReportPresence'
 export {
   useDocumentPreview,
   type useDocumentPreviewOptions,
@@ -102,7 +105,7 @@ export {
   type useDocumentProjectionResults,
 } from '../hooks/projection/useDocumentProjection'
 export {useProject} from '../hooks/projects/useProject'
-export {type ProjectWithoutMembers, useProjects} from '../hooks/projects/useProjects'
+export {useProjects} from '../hooks/projects/useProjects'
 export {useQuery} from '../hooks/query/useQuery'
 export {useActiveReleases} from '../hooks/releases/useActiveReleases'
 export {useAllReleases} from '../hooks/releases/useAllReleases'

package/src/components/SanityApp.tsx

@@ -1,4 +1,5 @@
-import {type DocumentResource, isStudioConfig, type SanityConfig} from '@sanity/sdk'
+import {type DocumentResource, type SanityConfig} from '@sanity/sdk'
+import {isStudioConfig} from '@sanity/sdk/_internal'
 import {type ReactElement, useContext, useEffect, useMemo} from 'react'
 
 import {SDKStudioContext, type StudioWorkspaceHandle} from '../context/SDKStudioContext'
@@ -17,8 +18,6 @@ export interface SanityAppProps {
    * automatically.
    */
   config?: SanityConfig | SanityConfig[]
-  /** @deprecated use the `config` prop instead. */
-  sanityConfigs?: SanityConfig[]
   resources?: Record<string, DocumentResource>
   children: React.ReactNode
   /* Fallback content to show when child components are suspending. Same as the `fallback` prop for React Suspense. */

package/src/components/auth/AuthBoundary.test.tsx

@@ -1,4 +1,4 @@
-import {AuthStateType, type SanityConfig} from '@sanity/sdk'
+import {AuthStateType} from '@sanity/sdk'
 import {render, screen, waitFor} from '@testing-library/react'
 import React from 'react'
 import {type FallbackProps} from 'react-error-boundary'
@@ -110,24 +110,6 @@ describe('AuthBoundary', () => {
   const mockUseVerifyOrgProjects = vi.mocked(useVerifyOrgProjects)
   const testProjectIds = ['proj-test'] // Example project ID for tests
 
-  // Mock Sanity instance
-  const mockSanityInstance = {
-    instanceId: 'test-instance-id',
-    config: {
-      projectId: 'test-project',
-      dataset: 'test-dataset',
-    },
-    isDisposed: () => false,
-    dispose: () => {},
-    onDispose: () => () => {},
-    getParent: () => undefined,
-    createChild: (config: SanityConfig) => ({
-      ...mockSanityInstance,
-      config: {...mockSanityInstance.config, ...config},
-    }),
-    match: () => undefined,
-  }
-
   beforeEach(() => {
     vi.clearAllMocks()
     consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})

package/src/components/auth/AuthBoundary.tsx

@@ -1,5 +1,6 @@
 import {CorsOriginError} from '@sanity/client'
-import {AuthStateType, getCorsErrorProjectId, isImportError, isStudioConfig} from '@sanity/sdk'
+import {AuthStateType, getCorsErrorProjectId, isImportError} from '@sanity/sdk'
+import {isStudioConfig} from '@sanity/sdk/_internal'
 import {useEffect, useMemo} from 'react'
 import {ErrorBoundary, type FallbackProps} from 'react-error-boundary'
 

package/src/components/auth/LoginError.tsx

@@ -1,11 +1,10 @@
 import {ClientError} from '@sanity/client'
+import {AuthStateType, getIsInDashboardState} from '@sanity/sdk'
 import {
-  AuthStateType,
   getClientErrorApiBody,
   getClientErrorApiDescription,
-  getIsInDashboardState,
   isProjectUserNotFoundClientError,
-} from '@sanity/sdk'
+} from '@sanity/sdk/_internal'
 import {Suspense, useCallback, useEffect, useMemo, useRef} from 'react'
 import {type FallbackProps} from 'react-error-boundary'
 

package/src/context/ComlinkTokenRefresh.tsx

@@ -1,15 +1,13 @@
 import {type ClientError} from '@sanity/client'
 import {SDK_CHANNEL_NAME, SDK_NODE_NAME} from '@sanity/message-protocol'
+import {AuthStateType, getIsInDashboardState, setAuthToken} from '@sanity/sdk'
+import {isStudioConfig} from '@sanity/sdk/_internal'
 import {
-  AuthStateType,
   type FrameMessage,
-  getIsInDashboardState,
-  isStudioConfig,
   type NewTokenResponseMessage,
   type RequestNewTokenMessage,
-  setAuthToken,
   type WindowMessage,
-} from '@sanity/sdk'
+} from '@sanity/sdk/comlink'
 import React, {type PropsWithChildren, useCallback, useEffect, useMemo, useRef} from 'react'
 
 import {useAuthState} from '../hooks/auth/useAuthState'

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/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/agent/useAgentResourceContext.ts

@@ -1,5 +1,5 @@
 import {type Events, SDK_CHANNEL_NAME, SDK_NODE_NAME} from '@sanity/message-protocol'
-import {type FrameMessage} from '@sanity/sdk'
+import {type FrameMessage} from '@sanity/sdk/comlink'
 import {useCallback, useEffect, useRef} from 'react'
 
 import {useWindowConnection} from '../comlink/useWindowConnection'

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'
 

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'}),
+    )
+  })
+})

package/src/hooks/comments/useCommentActions.ts

@@ -0,0 +1,109 @@
+import {
+  type Comment,
+  createComment,
+  type CreateCommentOptions,
+  type DocumentResource,
+  type PerspectiveHandle,
+  removeComment,
+  type RemoveCommentOptions,
+  replyToComment,
+  type ReplyToCommentOptions,
+  setCommentStatus,
+  type SetCommentStatusOptions,
+  updateComment,
+  type UpdateCommentOptions,
+} from '@sanity/sdk'
+import {useContext, useMemo} from 'react'
+
+import {PerspectiveContext} from '../../context/PerspectiveContext'
+import {ResourcesContext} from '../../context/ResourcesContext'
+import {useSanityInstance} from '../context/useSanityInstance'
+import {
+  normalizeResourceOptions,
+  useEffectiveContextResource,
+  type WithResourceNameSupport,
+} from '../helpers/useNormalizedResourceOptions'
+import {trackHookUsage} from '../helpers/useTrackHookUsage'
+
+/**
+ * @public
+ * @category Types
+ */
+export interface CommentActions {
+  /** Starts a thread on a document, or on one of its fields. */
+  createComment: (options: WithResourceNameSupport<CreateCommentOptions>) => Promise<Comment>
+  /** Adds a reply to an existing thread. */
+  replyToComment: (options: WithResourceNameSupport<ReplyToCommentOptions>) => Promise<Comment>
+  /** Rewrites a comment's message. */
+  updateComment: (options: WithResourceNameSupport<UpdateCommentOptions>) => Promise<void>
+  /** Resolves or reopens a thread. Pass the thread's first comment. */
+  setCommentStatus: (options: WithResourceNameSupport<SetCommentStatusOptions>) => Promise<void>
+  /** Deletes a comment, and its replies when it starts a thread. */
+  removeComment: (options: WithResourceNameSupport<RemoveCommentOptions>) => Promise<void>
+}
+
+type Resolvable = {
+  resource?: DocumentResource
+  resourceName?: string
+  projectId?: string
+  dataset?: string
+  perspective?: PerspectiveHandle['perspective']
+}
+
+/**
+ * Returns the five comment write actions, bound to the current instance.
+ *
+ * Each writes optimistically: the change shows immediately and is rolled back
+ * if the server rejects it, so an app can render straight from
+ * {@link useComments} without tracking pending state itself.
+ *
+ * Creating is the exception, and `replyToComment` counts as creating. A comment
+ * that fails to post stays on screen carrying `_state.createError` rather than
+ * disappearing, so passing the same `commentId` again retries it instead of
+ * losing what someone typed.
+ *
+ * The resource is resolved when an action is called rather than when the hook
+ * runs, so one set of callbacks works across several resources. Pass `resource`
+ * or `resourceName` per call to choose; otherwise the surrounding
+ * `ResourceProvider` decides.
+ *
+ * @category Comments
+ * @function
+ * @returns The five write actions
+ *
+ * @example Resolve a thread
+ * ```tsx
+ * function ResolveButton({commentId}: {commentId: string}) {
+ *   const {setCommentStatus} = useCommentActions()
+ *
+ *   return (
+ *     <button onClick={() => setCommentStatus({commentId, status: 'resolved'})}>
+ *       Resolve
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @public
+ */
+export function useCommentActions(): CommentActions {
+  const instance = useSanityInstance()
+  trackHookUsage(instance, 'useCommentActions')
+
+  const resources = useContext(ResourcesContext)
+  const contextResource = useEffectiveContextResource()
+  const contextPerspective = useContext(PerspectiveContext)
+
+  return useMemo(() => {
+    const resolve = <T extends Resolvable>(options: T) =>
+      normalizeResourceOptions(options, resources, contextResource, contextPerspective)
+
+    return {
+      createComment: (options) => createComment(instance, resolve(options)),
+      replyToComment: (options) => replyToComment(instance, resolve(options)),
+      updateComment: (options) => updateComment(instance, resolve(options)),
+      setCommentStatus: (options) => setCommentStatus(instance, resolve(options)),
+      removeComment: (options) => removeComment(instance, resolve(options)),
+    }
+  }, [contextPerspective, contextResource, instance, resources])
+}