@sanity/sdk-react 2.10.0 → 2.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/sdk-react",
-  "version": "2.10.0",
+  "version": "2.11.0",
   "private": false,
   "description": "Sanity SDK React toolkit for Content OS",
   "keywords": [
@@ -50,7 +50,7 @@
     "react-compiler-runtime": "19.1.0-rc.2",
     "react-error-boundary": "^5.0.0",
     "rxjs": "^7.8.2",
-    "@sanity/sdk": "2.10.0"
+    "@sanity/sdk": "2.11.0"
   },
   "devDependencies": {
     "@sanity/browserslist-config": "^1.0.5",
@@ -63,7 +63,7 @@
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^4.7.0",
-    "@vitest/coverage-v8": "3.2.4",
+    "@vitest/coverage-v8": "4.1.5",
     "babel-plugin-react-compiler": "19.1.0-rc.1",
     "eslint": "^9.22.0",
     "groq-js": "^1.22.0",
@@ -74,20 +74,17 @@
     "rollup-plugin-visualizer": "^5.14.0",
     "typescript": "^5.8.3",
     "vite": "^7.0.0",
-    "vitest": "^3.2.4",
-    "@repo/config-eslint": "0.0.0",
+    "vitest": "^4.1.4",
     "@repo/config-test": "0.0.1",
+    "@repo/package.bundle": "3.82.0",
     "@repo/package.config": "0.0.1",
     "@repo/tsconfig": "0.0.1",
-    "@repo/package.bundle": "3.82.0"
+    "@repo/config-eslint": "0.0.0"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0"
   },
-  "engines": {
-    "node": ">=20.19"
-  },
   "publishConfig": {
     "access": "public"
   },

package/src/_exports/index.ts

@@ -1,2 +1,4 @@
 export * from './sdk-react.ts'
 export * from '@sanity/sdk'
+// React-layer handles shadow core equivalents when imported from @sanity/sdk-react
+export type {DocumentHandle, DocumentTypeHandle, ResourceHandle} from './sdk-react.ts'

package/src/_exports/sdk-react.ts

@@ -4,6 +4,7 @@
 export {AuthBoundary, type AuthBoundaryProps} from '../components/auth/AuthBoundary'
 export {SanityApp, type SanityAppProps} from '../components/SanityApp'
 export {SDKProvider, type SDKProviderProps} from '../components/SDKProvider'
+export {type DocumentHandle, type DocumentTypeHandle, type ResourceHandle} from '../config/handles'
 export {ComlinkTokenRefreshProvider} from '../context/ComlinkTokenRefresh'
 export {renderSanityApp} from '../context/renderSanityApp'
 export {ResourceProvider, type ResourceProviderProps} from '../context/ResourceProvider'
@@ -44,6 +45,7 @@ export {
   type WindowConnection,
   type WindowMessageHandler,
 } from '../hooks/comlink/useWindowConnection'
+export {useResource} from '../hooks/context/useResource'
 export {useSanityInstance} from '../hooks/context/useSanityInstance'
 export {useDashboardNavigate} from '../hooks/dashboard/useDashboardNavigate'
 export {useDispatchIntent} from '../hooks/dashboard/useDispatchIntent'
@@ -67,6 +69,8 @@ export {
   type DocumentsResponse,
   useDocuments,
 } from '../hooks/documents/useDocuments'
+export {useOrganization} from '../hooks/organizations/useOrganization'
+export {useOrganizations} from '../hooks/organizations/useOrganizations'
 export {
   type PaginatedDocumentsOptions,
   type PaginatedDocumentsResponse,

package/src/components/SDKProvider.test.tsx

@@ -62,7 +62,7 @@ describe('SDKProvider', () => {
     })
   })
 
-  it('renders nested ResourceProviders with AuthBoundary for multiple configs', () => {
+  it('renders a single ResourceProvider using the first config when multiple configs are provided', () => {
     const configs = [
       {
         projectId: 'project-1',
@@ -80,22 +80,15 @@ describe('SDKProvider', () => {
       </SDKProvider>,
     )
 
-    // Should create two nested ResourceProviders
+    // Should create a single ResourceProvider using the first config
     const providers = getAllByTestId('resource-provider')
-    expect(providers.length).toBe(2)
+    expect(providers.length).toBe(1)
 
-    // Should create an AuthBoundary inside the innermost provider
+    // Should create an AuthBoundary inside
     expect(getByTestId('auth-boundary')).toBeInTheDocument()
 
-    // Verify each provider has the correct config - order is based on how SDKProvider creates nestings
-    // The first provider contains config[1]
+    // Verify the provider uses the first config
     expect(JSON.parse(providers[0].getAttribute('data-config') || '{}')).toEqual({
-      projectId: 'project-2',
-      dataset: 'staging',
-    })
-
-    // The second provider contains config[0]
-    expect(JSON.parse(providers[1].getAttribute('data-config') || '{}')).toEqual({
       projectId: 'project-1',
       dataset: 'production',
     })

package/src/components/SDKProvider.tsx

@@ -2,6 +2,7 @@ import {type DocumentResource, isImportError, type SanityConfig} from '@sanity/s
 import {type ReactElement, type ReactNode, useEffect, useMemo} from 'react'
 import {ErrorBoundary, type FallbackProps} from 'react-error-boundary'
 
+import {DEFAULT_RESOURCE_NAME} from '../constants'
 import {ResourceProvider} from '../context/ResourceProvider'
 import {ResourcesContext} from '../context/ResourcesContext'
 import {AuthBoundary, type AuthBoundaryProps} from './auth/AuthBoundary'
@@ -34,8 +35,6 @@ function ResetChunkReloadFlagOnMount(): null {
  * @internal
  *
  * Top-level context provider that provides access to the Sanity SDK.
- * Creates a hierarchy of ResourceProviders, each providing a SanityInstance that can be
- * accessed by hooks. The first configuration in the array becomes the default instance.
  */
 export function SDKProvider({
   children,
@@ -43,35 +42,38 @@ export function SDKProvider({
   fallback,
   ...props
 }: SDKProviderProps): ReactElement {
-  // reverse because we want the first config to be the default, but the
-  // ResourceProvider nesting makes the last one the default
-  const configs = (Array.isArray(config) ? config : [config]).slice().reverse()
-  const projectIds = configs.map((c) => c.projectId).filter((id): id is string => !!id)
+  const allConfigs = Array.isArray(config) ? config : [config]
+  const resolvedConfig = allConfigs[0]
+  const projectIds = allConfigs.map((c) => c.projectId).filter((id): id is string => !!id)
 
-  // Memoize resources to prevent creating a new empty object on every render
-  const resourcesValue = useMemo(() => props.resources ?? {}, [props.resources])
+  // Extract static fields so the memo below doesn't take a reference dependency
+  // on `config` — inline config objects change identity on every render.
+  const singleConfig = Array.isArray(config) ? null : config
+  const defaultProjectId = singleConfig?.projectId
+  const defaultDataset = singleConfig?.dataset
 
-  // Create a nested structure of ResourceProviders for each config
-  const createNestedProviders = (index: number): ReactElement => {
-    if (index >= configs.length) {
-      return (
-        <AuthBoundary {...props} projectIds={projectIds}>
-          <ResourcesContext.Provider value={resourcesValue}>{children}</ResourcesContext.Provider>
-        </AuthBoundary>
-      )
+  // For a single config, synthesize a 'default' resource from its projectId/dataset
+  // so that hooks can resolve it via resourceName: 'default' or fall back to it
+  // automatically when no resource info is provided.
+  const resourcesValue = useMemo(() => {
+    const explicit = props.resources ?? {}
+    if (defaultProjectId && defaultDataset && !Object.hasOwn(explicit, DEFAULT_RESOURCE_NAME)) {
+      return {
+        [DEFAULT_RESOURCE_NAME]: {projectId: defaultProjectId, dataset: defaultDataset},
+        ...explicit,
+      }
     }
-
-    return (
-      <ResourceProvider {...configs[index]} fallback={fallback}>
-        {createNestedProviders(index + 1)}
-      </ResourceProvider>
-    )
-  }
+    return explicit
+  }, [defaultProjectId, defaultDataset, props.resources])
 
   return (
     <ErrorBoundary FallbackComponent={ChunkAwareFallback}>
       <ResetChunkReloadFlagOnMount />
-      {createNestedProviders(0)}
+      <ResourceProvider {...resolvedConfig} fallback={fallback}>
+        <AuthBoundary {...props} projectIds={projectIds}>
+          <ResourcesContext.Provider value={resourcesValue}>{children}</ResourcesContext.Provider>
+        </AuthBoundary>
+      </ResourceProvider>
     </ErrorBoundary>
   )
 }

package/src/config/handles.ts

@@ -0,0 +1,55 @@
+import {
+  type DatasetHandle,
+  type DocumentHandle as CoreDocumentHandle,
+  type DocumentTypeHandle as CoreDocumentTypeHandle,
+} from '@sanity/sdk'
+
+/**
+ * React SDK resource handle — extends the core DatasetHandle with `resourceName`
+ * for context-based resource resolution.
+ *
+ * Use this (or its subtypes) as the options type for custom hooks that need to
+ * accept a resource. It accepts a `resource` object, a `resourceName` registered
+ * via the `resources` prop on `<SanityApp>`, or a bare `projectId`/`dataset` pair
+ * for backward compatibility.
+ *
+ * @public
+ */
+export interface ResourceHandle<
+  TDataset extends string = string,
+  TProjectId extends string = string,
+> extends DatasetHandle<TDataset, TProjectId> {
+  /**
+   * Name of a resource registered via the `resources` prop on `<SanityApp>`.
+   * Resolved to a `DocumentResource` at the React layer.
+   */
+  resourceName?: string
+}
+
+/**
+ * React SDK document-type handle. Adds `resourceName` to the core `DocumentTypeHandle`.
+ * @public
+ */
+export interface DocumentTypeHandle<
+  TDocumentType extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+> extends CoreDocumentTypeHandle<TDocumentType, TDataset, TProjectId> {
+  resourceName?: string
+}
+
+/**
+ * React SDK document handle. Adds `resourceName` to the core `DocumentHandle`.
+ *
+ * Import from `@sanity/sdk-react` (not `@sanity/sdk`) when writing option types
+ * for hooks — this version understands `resourceName` resolution.
+ *
+ * @public
+ */
+export interface DocumentHandle<
+  TDocumentType extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+> extends CoreDocumentHandle<TDocumentType, TDataset, TProjectId> {
+  resourceName?: string
+}

package/src/constants.ts

@@ -0,0 +1,5 @@
+/**
+ * The name of the resource automatically registered from a single-config `<SanityApp>`.
+ * Hooks that receive no resource information fall back to this named resource.
+ */
+export const DEFAULT_RESOURCE_NAME = 'default'

package/src/context/DefaultResourceContext.ts

@@ -0,0 +1,10 @@
+import {type DocumentResource} from '@sanity/sdk'
+import {createContext} from 'react'
+
+/**
+ * Provides the active DocumentResource for a subtree.
+ * Set by ResourceProvider; read by useNormalizedResourceOptions as a fallback
+ * when hooks receive no explicit resource or resourceName.
+ * @internal
+ */
+export const ResourceContext = createContext<DocumentResource | undefined>(undefined)

package/src/context/PerspectiveContext.ts

@@ -0,0 +1,12 @@
+import {type PerspectiveHandle} from '@sanity/sdk'
+import {createContext} from 'react'
+
+/**
+ * Provides the active perspective for a subtree.
+ * Set by ResourceProvider; injected by useNormalizedResourceOptions when
+ * the hook's options don't include an explicit perspective.
+ * @internal
+ */
+export const PerspectiveContext = createContext<PerspectiveHandle['perspective'] | undefined>(
+  undefined,
+)

package/src/context/ResourceProvider.test.tsx

@@ -78,7 +78,7 @@ describe('ResourceProvider', () => {
     })
   })
 
-  it('creates child instance when parent context exists', async () => {
+  it('reuses instance when parent context exists', async () => {
     const parentConfig: SanityConfig = {...testConfig, dataset: 'parent-dataset'}
     const child = promiseWithResolvers<SanityInstance | null>()
 
@@ -97,7 +97,7 @@ describe('ResourceProvider', () => {
     )
 
     const childInstance = await child.promise
-    expect(childInstance?.config).toEqual(testConfig)
+    expect(childInstance?.config).toEqual(parentConfig)
     expect(childInstance?.isDisposed()).toBe(false)
   })
 

package/src/context/ResourceProvider.tsx

@@ -1,7 +1,16 @@
-import {createSanityInstance, type SanityConfig, type SanityInstance} from '@sanity/sdk'
+import {
+  createSanityInstance,
+  type DatasetResource,
+  type DocumentResource,
+  isDatasetResource,
+  type SanityConfig,
+  type SanityInstance,
+} from '@sanity/sdk'
 import {initTelemetry} from '@sanity/sdk/_internal'
-import {useContext, useEffect, useMemo, useRef} from 'react'
+import {useContext, useEffect, useMemo, useRef, useState} from 'react'
 
+import {ResourceContext} from './DefaultResourceContext'
+import {PerspectiveContext} from './PerspectiveContext'
 import {SanityInstanceContext} from './SanityInstanceContext'
 import {SanityInstanceProvider} from './SanityInstanceProvider'
 
@@ -17,73 +26,63 @@ const DEFAULT_FALLBACK = (
  */
 export interface ResourceProviderProps extends SanityConfig {
   /**
-   * React node to show while content is loading
-   * Used as the fallback for the internal Suspense boundary
+   * The document resource (project/dataset, media library, or canvas)
+   * for this subtree. Hooks that don't specify an explicit resource will
+   * use this value.
+   */
+  resource?: DocumentResource
+  /**
+   * React node to show while content is loading.
+   * Used as the fallback for the internal Suspense boundary.
    */
   fallback: React.ReactNode
   children: React.ReactNode
 }
 
 /**
- * Provides a Sanity instance to child components through React Context
+ * Provides Sanity configuration to child components through React Context.
  *
  * @internal
  *
- * @remarks
- * The ResourceProvider creates a hierarchical structure of Sanity instances:
- * - When used as a root provider, it creates a new Sanity instance with the given config
- * - When nested inside another ResourceProvider, it creates a child instance that
- *   inherits and extends the parent's configuration
- *
- * Features:
- * - Automatically manages the lifecycle of Sanity instances
- * - Disposes instances when the component unmounts
- * - Includes a Suspense boundary for data loading
- * - Enables hierarchical configuration inheritance
- *
- * Use this component to:
- * - Set up project/dataset configuration for an application
- * - Override specific configuration values in a section of your app
- * - Create isolated instance hierarchies for different features
- *
- * @example Creating a root provider
+ * @example
  * ```tsx
  * <ResourceProvider
- *   projectId="your-project-id"
- *   dataset="production"
+ *   resource={{ projectId: 'your-project-id', dataset: 'production' }}
  *   fallback={<LoadingSpinner />}
  * >
  *   <YourApp />
  * </ResourceProvider>
  * ```
- *
- * @example Creating nested providers with configuration inheritance
- * ```tsx
- * // Root provider with production config with nested provider for preview features with custom dataset
- * <ResourceProvider projectId="abc123" dataset="production" fallback={<Loading />}>
- *   <div>...Main app content</div>
- *   <Dashboard />
- *   <ResourceProvider dataset="preview" fallback={<Loading />}>
- *     <PreviewFeatures />
- *   </ResourceProvider>
- * </ResourceProvider>
- * ```
  */
 export function ResourceProvider({
   children,
   fallback,
+  resource,
   ...config
 }: ResourceProviderProps): React.ReactNode {
-  const parent = useContext(SanityInstanceContext)
-  const instance = useMemo(
-    () => (parent ? parent.createChild(config) : createSanityInstance(config)),
-    [config, parent],
-  )
+  const parentPerspective = useContext(PerspectiveContext)
+  const parentResource = useContext(ResourceContext)
+  const parentInstance = useContext(SanityInstanceContext)
+
+  const {projectId, dataset, perspective} = config
+
+  const [instance] = useState<SanityInstance>(() => parentInstance ?? createSanityInstance(config))
 
-  const projectId = config.projectId ?? ''
-  useMemo(() => {
-    if (projectId && !parent) initTelemetry(instance, projectId)
-  }, [instance, projectId, parent])
+  const configResource: DatasetResource | undefined = useMemo(() => {
+    if (projectId && dataset) {
+      return {projectId, dataset}
+    }
+    return undefined
+  }, [projectId, dataset])
+
+  const effectiveResource = useMemo(() => {
+    return resource ?? configResource ?? parentResource
+  }, [resource, configResource, parentResource])
+
+  useEffect(() => {
+    if (effectiveResource && isDatasetResource(effectiveResource))
+      initTelemetry(instance, effectiveResource.projectId)
+  }, [instance, effectiveResource])
 
   // Ref to hold the scheduled disposal timer.
   const disposal = useRef<{
@@ -102,17 +101,22 @@ export function ResourceProvider({
       disposal.current = {
         instance,
         timeoutId: setTimeout(() => {
-          if (!instance.isDisposed()) {
+          // don't dispose the parent instance when this unmounts
+          if (!instance.isDisposed() && instance !== parentInstance) {
             instance.dispose()
           }
         }, 0),
       }
     }
-  }, [instance])
+  }, [instance, parentInstance])
 
   return (
     <SanityInstanceProvider instance={instance} fallback={fallback ?? DEFAULT_FALLBACK}>
-      {children}
+      <ResourceContext.Provider value={effectiveResource}>
+        <PerspectiveContext.Provider value={perspective ?? parentPerspective}>
+          {children}
+        </PerspectiveContext.Provider>
+      </ResourceContext.Provider>
     </SanityInstanceProvider>
   )
 }

package/src/hooks/agent/agentActions.ts

@@ -11,11 +11,13 @@ import {
   type AgentTransformOptions,
   agentTranslate,
   type AgentTranslateOptions,
-  type SanityInstance,
 } from '@sanity/sdk'
+import {useCallback} from 'react'
 import {firstValueFrom} from 'rxjs'
 
-import {createCallbackHook} from '../helpers/createCallbackHook'
+import {type ResourceHandle} from '../../config/handles'
+import {useSanityInstance} from '../context/useSanityInstance'
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 
 interface Subscription {
   unsubscribe(): void
@@ -103,10 +105,17 @@ interface Subscribable<T> {
  *
  * @category Agent Actions
  */
-export const useAgentGenerate: () => (options: AgentGenerateOptions) => Subscribable<unknown> =
-  createCallbackHook(agentGenerate) as unknown as () => (
-    options: AgentGenerateOptions,
-  ) => Subscribable<unknown>
+export function useAgentGenerate(
+  resourceHandle?: ResourceHandle,
+): (options: AgentGenerateOptions) => Subscribable<unknown> {
+  const instance = useSanityInstance()
+  const {resource} = useNormalizedResourceOptions(resourceHandle ?? {})
+  return useCallback(
+    (options: AgentGenerateOptions) =>
+      agentGenerate(instance, options, resource) as unknown as Subscribable<unknown>,
+    [instance, resource],
+  )
+}
 
 /**
  * @alpha
@@ -179,10 +188,17 @@ export const useAgentGenerate: () => (options: AgentGenerateOptions) => Subscrib
  *
  * @category Agent Actions
  */
-export const useAgentTransform: () => (options: AgentTransformOptions) => Subscribable<unknown> =
-  createCallbackHook(agentTransform) as unknown as () => (
-    options: AgentTransformOptions,
-  ) => Subscribable<unknown>
+export function useAgentTransform(
+  resourceHandle?: ResourceHandle,
+): (options: AgentTransformOptions) => Subscribable<unknown> {
+  const instance = useSanityInstance()
+  const {resource} = useNormalizedResourceOptions(resourceHandle ?? {})
+  return useCallback(
+    (options: AgentTransformOptions) =>
+      agentTransform(instance, options, resource) as unknown as Subscribable<unknown>,
+    [instance, resource],
+  )
+}
 
 /**
  * @alpha
@@ -274,20 +290,16 @@ export const useAgentTransform: () => (options: AgentTransformOptions) => Subscr
  *
  * @category Agent Actions
  */
-export const useAgentTranslate: () => (options: AgentTranslateOptions) => Subscribable<unknown> =
-  createCallbackHook(agentTranslate) as unknown as () => (
-    options: AgentTranslateOptions,
-  ) => Subscribable<unknown>
-
-/**
- * @internal
- * Adapter to convert the agentPrompt observable to a Promise.
- */
-function promptAdapter(
-  instance: SanityInstance,
-  options: AgentPromptOptions,
-): Promise<AgentPromptResult> {
-  return firstValueFrom(agentPrompt(instance, options))
+export function useAgentTranslate(
+  resourceHandle?: ResourceHandle,
+): (options: AgentTranslateOptions) => Subscribable<unknown> {
+  const instance = useSanityInstance()
+  const {resource} = useNormalizedResourceOptions(resourceHandle ?? {})
+  return useCallback(
+    (options: AgentTranslateOptions) =>
+      agentTranslate(instance, options, resource) as unknown as Subscribable<unknown>,
+    [instance, resource],
+  )
 }
 
 /**
@@ -384,18 +396,15 @@ function promptAdapter(
  *
  * @category Agent Actions
  */
-export const useAgentPrompt: () => (options: AgentPromptOptions) => Promise<AgentPromptResult> =
-  createCallbackHook(promptAdapter)
-
-/**
- * @internal
- * Adapter to convert the agentPatch observable to a Promise.
- */
-function patchAdapter(
-  instance: SanityInstance,
-  options: AgentPatchOptions,
-): Promise<AgentPatchResult> {
-  return firstValueFrom(agentPatch(instance, options))
+export function useAgentPrompt(
+  resourceHandle?: ResourceHandle,
+): (options: AgentPromptOptions) => Promise<AgentPromptResult> {
+  const instance = useSanityInstance()
+  const {resource} = useNormalizedResourceOptions(resourceHandle ?? {})
+  return useCallback(
+    (options: AgentPromptOptions) => firstValueFrom(agentPrompt(instance, options, resource)),
+    [instance, resource],
+  )
 }
 
 /**
@@ -547,5 +556,13 @@ function patchAdapter(
  *
  * @category Agent Actions
  */
-export const useAgentPatch: () => (options: AgentPatchOptions) => Promise<AgentPatchResult> =
-  createCallbackHook(patchAdapter)
+export function useAgentPatch(
+  resourceHandle?: ResourceHandle,
+): (options: AgentPatchOptions) => Promise<AgentPatchResult> {
+  const instance = useSanityInstance()
+  const {resource} = useNormalizedResourceOptions(resourceHandle ?? {})
+  return useCallback(
+    (options: AgentPatchOptions) => firstValueFrom(agentPatch(instance, options, resource)),
+    [instance, resource],
+  )
+}

package/src/hooks/context/useResource.test.tsx

@@ -0,0 +1,32 @@
+import {renderHook as reactRenderHook} from '@testing-library/react'
+import {type ReactNode} from 'react'
+import {describe, expect, it} from 'vitest'
+
+import {renderHook} from '../../../test/test-utils'
+import {ResourceProvider} from '../../context/ResourceProvider'
+import {useResource} from './useResource'
+
+describe('useResource', () => {
+  it('returns the resource from the instance config when no explicit resource is set', () => {
+    // test-utils wraps with ResourceProvider projectId="test" dataset="test"
+    const {result} = renderHook(() => useResource())
+    expect(result.current).toEqual({projectId: 'test', dataset: 'test'})
+  })
+
+  it('returns the explicit resource when ResourceProvider has a resource prop', () => {
+    const resource = {projectId: 'explicit-project', dataset: 'explicit-dataset'}
+    const {result} = reactRenderHook(() => useResource(), {
+      wrapper: ({children}: {children: ReactNode}) => (
+        <ResourceProvider resource={resource} fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
+    expect(result.current).toEqual(resource)
+  })
+
+  it('returns undefined when no resource or instance config is available', () => {
+    const {result} = reactRenderHook(() => useResource())
+    expect(result.current).toBeUndefined()
+  })
+})

package/src/hooks/context/useResource.ts

@@ -0,0 +1,24 @@
+import {type DocumentResource} from '@sanity/sdk'
+
+import {useEffectiveContextResource} from '../helpers/useNormalizedResourceOptions'
+
+/**
+ * Returns the currently active `DocumentResource` for the nearest resource context.
+ *
+ * Resolves in priority order:
+ * 1. A `resource` prop on the nearest `<ResourceProvider>`
+ * 2. The `projectId`/`dataset` from the current `SanityInstance` config
+ * 3. `undefined` when neither is available
+ *
+ * @public
+ * @category Platform
+ *
+ * @example
+ * ```tsx
+ * const resource = useResource()
+ * console.log(resource?.projectId, resource?.dataset)
+ * ```
+ */
+export function useResource(): DocumentResource | undefined {
+  return useEffectiveContextResource()
+}