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

package/src/hooks/document/useDocument.ts

@@ -1,13 +1,15 @@
-import {type DocumentOptions, getDocumentState, resolveDocument} from '@sanity/sdk'
-import {type SanityDocument} from '@sanity/types'
+import {type DocumentOptions, getDocumentState, type JsonMatch, resolveDocument} from '@sanity/sdk'
+import {type SanityDocument} from 'groq'
+import {identity} from 'rxjs'
 
 import {type DocumentHandle} from '../../config/handles'
 import {createStateSourceHook} from '../helpers/createStateSourceHook'
 import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
+import {useTrackHookUsage} from '../helpers/useTrackHookUsage'
 // used in an `{@link useDocumentProjection}` and `{@link useQuery}`
-// eslint-disable-next-line import/consistent-type-specifier-style, unused-imports/no-unused-imports
+// eslint-disable-next-line import-x/consistent-type-specifier-style
 import type {useDocumentProjection} from '../projection/useDocumentProjection'
-// eslint-disable-next-line import/consistent-type-specifier-style, unused-imports/no-unused-imports
+// eslint-disable-next-line import-x/consistent-type-specifier-style
 import type {useQuery} from '../query/useQuery'
 
 const useDocumentValue = createStateSourceHook({
@@ -20,6 +22,9 @@ const useDocumentValue = createStateSourceHook({
   // Extract handle part for resolveDocument
   suspender: (instance, options: DocumentOptions<string | undefined>) =>
     resolveDocument(instance, options),
+  getConfig: identity as (
+    options: DocumentOptions<string | undefined>,
+  ) => DocumentOptions<string | undefined>,
 })
 
 const wrapHookWithData = <TParams extends unknown[], TReturn>(
@@ -39,108 +44,168 @@ type UseDocumentOptions<
 > = DocumentHandle<TDocumentType, TDataset, TProjectId> & {path?: TPath}
 
 interface UseDocument {
+  /** @internal */
+  <TDocumentType extends string, TDataset extends string, TProjectId extends string = string>(
+    options: UseDocumentOptions<undefined, TDocumentType, TDataset, TProjectId>,
+  ): {data: SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`> | null}
+
+  /** @internal */
+  <
+    TPath extends string,
+    TDocumentType extends string,
+    TDataset extends string = string,
+    TProjectId extends string = string,
+  >(
+    options: UseDocumentOptions<TPath, TDocumentType>,
+  ): {
+    data: JsonMatch<SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`>, TPath> | undefined
+  }
+
+  /** @internal */
+  <TData>(options: DocumentOptions<undefined>): {data: TData | null}
+  /** @internal */
+  <TData>(options: DocumentOptions<string>): {data: TData | undefined}
+
   /**
+   * ## useDocument via Type Inference (Recommended)
+   *
    * @public
    *
-   * ## useDocument with Explicit Types (no path)
+   * The preferred way to use this hook when working with Sanity Typegen.
    *
-   * Provide an explicit type parameter `TData` to type the returned document data.
-   * You can define your own interfaces or use types generated by your Sanity Studio.
+   * Features:
+   * - Automatically infers document types from your schema
+   * - Provides type-safe access to documents and nested fields
+   * - Supports project/dataset-specific type inference
+   * - Works seamlessly with Typegen-generated types
    *
-   * This hook will suspend while the document data is being fetched.
+   * This hook will suspend while the document data is being fetched and loaded.
+   *
+   * When fetching a full document:
+   * - Returns the complete document object if it exists
+   * - Returns `null` if the document doesn't exist
    *
-   * @typeParam TData - The explicit type for the document
+   * When fetching with a path:
+   * - Returns the value at the specified path if both the document and path exist
+   * - Returns `undefined` if either the document doesn't exist or the path doesn't exist in the document
+   *
+   * @category Documents
    * @param options - Configuration including `documentId`, `documentType`, and optionally:
+   *   - `path`: To select a nested value (returns typed value at path)
    *   - `projectId`/`dataset`: For multi-project/dataset setups
-   * @returns The document state
+   * @returns The document state (or nested value if path provided).
    *
-   * @example Basic document fetch with explicit type
+   * @example Basic document fetch
    * ```tsx
-   * import {useDocument, type DocumentHandle, type SanityDocument} from '@sanity/sdk-react'
-   *
-   * interface Book extends SanityDocument {
-   *   _type: 'book'
-   *   title: string
-   *   author: string
-   * }
+   * import {useDocument, type DocumentHandle} from '@sanity/sdk-react'
    *
-   * interface BookViewProps {
-   *   doc: DocumentHandle
+   * interface ProductViewProps {
+   *   doc: DocumentHandle<'product'> // Typegen infers product type
    * }
    *
-   * function BookView({doc}: BookViewProps) {
-   *   const {data: book} = useDocument<Book>({...doc})
-   *   return <h1>{book?.title ?? 'Untitled'} by {book?.author ?? 'Unknown'}</h1>
+   * function ProductView({doc}: ProductViewProps) {
+   *   const {data: product} = useDocument({...doc}) // Fully typed product
+   *   return <h1>{product.title ?? 'Untitled'}</h1>
    * }
    * ```
    *
-   * @inlineType DocumentOptions
-   */
-  <TData>(options: UseDocumentOptions<undefined>): {data: TData | null}
-
-  /**
-   * @public
-   *
-   * ## useDocument with Explicit Types (with path)
-   *
-   * Provide an explicit type parameter `TData` to type the returned field data
-   * when using a `path` to select a nested value.
-   *
-   * @typeParam TData - The explicit type for the field
-   * @param options - Configuration including `documentId`, `documentType`, `path`, and optionally:
-   *   - `projectId`/`dataset`: For multi-project/dataset setups
-   * @returns The field value at the specified path
-   *
-   * @example Fetching a specific field with explicit type
+   * @example Fetching a specific field
    * ```tsx
    * import {useDocument, type DocumentHandle} from '@sanity/sdk-react'
    *
-   * function BookTitle({doc}: {doc: DocumentHandle}) {
-   *   const {data: title} = useDocument<string>({...doc, path: 'title'})
+   * interface ProductTitleProps {
+   *   doc: DocumentHandle<'product'>
+   * }
+   *
+   * function ProductTitle({doc}: ProductTitleProps) {
+   *   const {data: title} = useDocument({
+   *     ...doc,
+   *     path: 'title' // Returns just the title field
+   *   })
    *   return <h1>{title ?? 'Untitled'}</h1>
    * }
    * ```
    *
    * @inlineType DocumentOptions
    */
-  <TData>(options: UseDocumentOptions<string>): {data: TData | undefined}
+  <
+    TPath extends string | undefined = undefined,
+    TDocumentType extends string = string,
+    TDataset extends string = string,
+    TProjectId extends string = string,
+  >(
+    options: UseDocumentOptions<TPath, TDocumentType>,
+  ): TPath extends string
+    ? {
+        data:
+          | JsonMatch<SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`>, TPath>
+          | undefined
+      }
+    : {data: SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`> | null}
 
   /**
    * @public
    *
-   * ## useDocument (default)
+   * ## useDocument via Explicit Types
    *
-   * When no explicit type parameter is provided, the hook returns `SanityDocument`.
+   * Use this version when:
+   * - You're not using Sanity Typegen
+   * - You need to manually specify document types
+   * - You're working with dynamic document types
    *
-   * This hook will suspend while the document data is being fetched and loaded.
+   * Key differences from Typegen version:
+   * - Requires manual type specification via `TData`
+   * - Returns `TData | null` for full documents
+   * - Returns `TData | undefined` for nested values
    *
-   * When fetching a full document:
-   * - Returns the complete document object if it exists
-   * - Returns `null` if the document doesn't exist
-   *
-   * When fetching with a path:
-   * - Returns the value at the specified path if both the document and path exist
-   * - Returns `undefined` if either the document doesn't exist or the path doesn't exist in the document
+   * This hook will suspend while the document data is being fetched.
    *
-   * @category Documents
-   * @param options - Configuration including `documentId`, `documentType`, and optionally:
+   * @typeParam TData - The explicit type for the document or field
+   * @typeParam TPath - Optional path to a nested value
+   * @param options - Configuration including `documentId` and optionally:
    *   - `path`: To select a nested value
    *   - `projectId`/`dataset`: For multi-project/dataset setups
-   * @returns The document state (or nested value if path provided).
+   * @returns The document state (or nested value if path provided)
    *
-   * @example Basic document fetch
+   * @example Basic document fetch with explicit type
+   * ```tsx
+   * import {useDocument, type DocumentHandle, type SanityDocument} from '@sanity/sdk-react'
+   *
+   * interface Book extends SanityDocument {
+   *   _type: 'book'
+   *   title: string
+   *   author: string
+   * }
+   *
+   * interface BookViewProps {
+   *   doc: DocumentHandle
+   * }
+   *
+   * function BookView({doc}: BookViewProps) {
+   *   const {data: book} = useDocument<Book>({...doc})
+   *   return <h1>{book?.title ?? 'Untitled'} by {book?.author ?? 'Unknown'}</h1>
+   * }
+   * ```
+   *
+   * @example Fetching a specific field with explicit type
    * ```tsx
    * import {useDocument, type DocumentHandle} from '@sanity/sdk-react'
    *
-   * function ProductView({doc}: {doc: DocumentHandle}) {
-   *   const {data: product} = useDocument({...doc})
-   *   return <h1>{product?.title ?? 'Untitled'}</h1>
+   * interface BookTitleProps {
+   *   doc: DocumentHandle
+   * }
+   *
+   * function BookTitle({doc}: BookTitleProps) {
+   *   const {data: title} = useDocument<string>({...doc, path: 'title'})
+   *   return <h1>{title ?? 'Untitled'}</h1>
    * }
    * ```
    *
    * @inlineType DocumentOptions
    */
-  (options: UseDocumentOptions<undefined>): {data: SanityDocument | null}
+  <TData, TPath extends string>(
+    options: UseDocumentOptions<TPath>,
+  ): TPath extends string ? {data: TData | undefined} : {data: TData | null}
 
   /**
    * @internal
@@ -152,11 +217,10 @@ interface UseDocument {
  * @public
  * Reads and subscribes to a document's realtime state, incorporating both local and remote changes.
  *
- * You can provide an explicit type parameter for full type safety:
- * - `useDocument<MyType>({...})` returns `{data: MyType | null}`
- * - `useDocument<string>({..., path: 'title'})` returns `{data: string | undefined}`
+ * This hook comes in two main flavors to suit your needs:
  *
- * Without a type parameter, data is typed as `SanityDocument`.
+ * 1. **[Type Inference](#usedocument-via-type-inference-recommended)** (Recommended) - Automatically gets types from your Sanity schema
+ * 2. **[Explicit Types](#usedocument-via-explicit-types)** - Manually specify types when needed
  *
  * @remarks
  * `useDocument` is ideal for realtime editing interfaces where you need immediate feedback on changes.
@@ -173,6 +237,7 @@ interface UseDocument {
  * @function
  */
 export const useDocument = wrapHookWithData((options: UseDocumentOptions) => {
+  useTrackHookUsage('useDocument')
   const normalizedOptions = useNormalizedResourceOptions(options)
   return useDocumentValue(normalizedOptions)
 }) as UseDocument

package/src/hooks/document/useDocumentEvent.test.tsx

@@ -1,8 +1,9 @@
 // tests/useDocumentEvent.test.ts
 import {type DocumentEvent, type DocumentHandle, subscribeDocumentEvents} from '@sanity/sdk'
+import {renderHook} from '@testing-library/react'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {renderHook} from '../../../test/test-utils'
+import {ResourceProvider} from '../../context/ResourceProvider'
 import {useDocumentEvent} from './useDocumentEvent'
 
 vi.mock('@sanity/sdk', async (importOriginal) => {
@@ -13,7 +14,6 @@ vi.mock('@sanity/sdk', async (importOriginal) => {
 const docHandle: DocumentHandle = {
   documentId: 'doc1',
   documentType: 'book',
-  resource: {projectId: 'p', dataset: 'd'},
 }
 
 describe('useDocumentEvent hook', () => {
@@ -26,7 +26,13 @@ describe('useDocumentEvent hook', () => {
     const unsubscribe = vi.fn()
     vi.mocked(subscribeDocumentEvents).mockReturnValue(unsubscribe)
 
-    renderHook(() => useDocumentEvent({...docHandle, onEvent: handleEvent}))
+    renderHook(() => useDocumentEvent({...docHandle, onEvent: handleEvent}), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     expect(vi.mocked(subscribeDocumentEvents)).toHaveBeenCalledTimes(1)
     expect(vi.mocked(subscribeDocumentEvents).mock.calls[0][0]).toEqual(expect.any(Object))
@@ -44,7 +50,13 @@ describe('useDocumentEvent hook', () => {
     const unsubscribe = vi.fn()
     vi.mocked(subscribeDocumentEvents).mockReturnValue(unsubscribe)
 
-    const {unmount} = renderHook(() => useDocumentEvent({...docHandle, onEvent: handleEvent}))
+    const {unmount} = renderHook(() => useDocumentEvent({...docHandle, onEvent: handleEvent}), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
     unmount()
     expect(unsubscribe).toHaveBeenCalledTimes(1)
   })

package/src/hooks/document/useDocumentEvent.ts

@@ -4,6 +4,7 @@ import {useCallback, useEffect, useInsertionEffect, useRef} from 'react'
 import {type ResourceHandle} from '../../config/handles'
 import {useSanityInstance} from '../context/useSanityInstance'
 import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
+import {useTrackHookUsage} from '../helpers/useTrackHookUsage'
 
 /**
  * @public
@@ -11,7 +12,7 @@ import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOpti
 export interface UseDocumentEventOptions<
   TDataset extends string = string,
   TProjectId extends string = string,
-> extends ResourceHandle<TProjectId, TDataset> {
+> extends ResourceHandle<TDataset, TProjectId> {
   onEvent: (documentEvent: DocumentEvent) => void
 }
 
@@ -22,19 +23,19 @@ export interface UseDocumentEventOptions<
  * Subscribes an event handler to events in your application's document store.
  *
  * @category Documents
- * @param options - An object containing the event handler (`onEvent`) and optionally a `resource`. If no resource is provided, the nearest resource from context will be used.
+ * @param options - An object containing the event handler (`onEvent`) and optionally a `DatasetHandle` (projectId and dataset). If the handle is not provided, the nearest Sanity instance from context will be used.
  * @example Creating a custom hook for document event toasts
  * ```tsx
- * import {type DocumentResource, type DocumentEvent, useDocumentEvent} from '@sanity/sdk-react'
+ * import {createDatasetHandle, type DatasetHandle, type DocumentEvent, useDocumentEvent} from '@sanity/sdk-react'
  * import {useToast} from './my-ui-library'
  *
- * // Define options for the custom hook
- * interface DocumentToastsOptions {
- *   resource?: DocumentResource
+ * // Define options for the custom hook, extending DatasetHandle
+ * interface DocumentToastsOptions extends DatasetHandle {
+ *   // Could add more options, e.g., { includeEvents: DocumentEvent['type'][] }
  * }
  *
  * // Define the custom hook
- * function useDocumentToasts({resource}: DocumentToastsOptions = {}) {
+ * function useDocumentToasts({...datasetHandle}: DocumentToastsOptions = {}) {
  *   const showToast = useToast() // Get the toast function
  *
  *   // Define the event handler logic to show toasts on specific events
@@ -46,20 +47,24 @@ export interface UseDocumentEventOptions<
  *     } else if (event.type === 'deleted') {
  *       showToast(`Document ${event.documentId} deleted.`)
  *     } else {
+ *       // Optionally log other events for debugging
  *       console.log('Document Event:', event.type, event.documentId)
  *     }
  *   }
  *
+ *   // Call the original hook, spreading the handle properties
  *   useDocumentEvent({
- *     resource,
+ *     ...datasetHandle, // Spread the dataset handle (projectId, dataset)
  *     onEvent: handleEvent,
  *   })
  * }
  *
  * function MyComponentWithToasts() {
- *   useDocumentToasts({resource: {projectId: 'p1', dataset: 'ds1'}})
+ *   // Use the custom hook, passing specific handle info
+ *   const specificHandle = createDatasetHandle({ projectId: 'p1', dataset: 'ds1' })
+ *   useDocumentToasts(specificHandle)
  *
- *   // Or rely on context for the resource:
+ *   // // Or use it relying on context for the handle
  *   // useDocumentToasts()
  *
  *   return <div>...</div>
@@ -73,6 +78,7 @@ export function useDocumentEvent<
   // Single options object parameter
   options: UseDocumentEventOptions<TDataset, TProjectId>,
 ): void {
+  useTrackHookUsage('useDocumentEvent')
   // Destructure handler and datasetHandle from options
   const normalizedOptions = useNormalizedResourceOptions(options)
   const {onEvent, ...datasetHandle} = normalizedOptions

package/src/hooks/document/useDocumentPermissions.test.tsx

@@ -1,6 +1,7 @@
 import {type DocumentAction, type DocumentPermissionsResult, getPermissionsState} from '@sanity/sdk'
+import {renderHook as reactRenderHook} from '@testing-library/react'
 import {BehaviorSubject, firstValueFrom, Observable} from 'rxjs'
-import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+import {afterEach, beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
 
 import {act, renderHook, waitFor} from '../../../test/test-utils'
 import {ResourceProvider} from '../../context/ResourceProvider'
@@ -46,8 +47,8 @@ describe('usePermissions', () => {
   }
 
   let permissionsSubject: BehaviorSubject<DocumentPermissionsResult | undefined>
-  let mockSubscribe: ReturnType<typeof vi.fn>
-  let mockGetCurrent: ReturnType<typeof vi.fn>
+  let mockSubscribe: Mock<(onStoreChanged?: () => void) => () => void>
+  let mockGetCurrent: Mock<() => DocumentPermissionsResult | undefined>
 
   beforeEach(() => {
     vi.clearAllMocks()
@@ -71,7 +72,7 @@ describe('usePermissions', () => {
       observable:
         permissionsSubject.asObservable() as unknown as Observable<DocumentPermissionsResult>,
       subscribe: mockSubscribe,
-      getCurrent: mockGetCurrent,
+      getCurrent: mockGetCurrent as unknown as () => DocumentPermissionsResult,
     })
   })
 
@@ -177,7 +178,7 @@ describe('usePermissions', () => {
     vi.mocked(firstValueFrom).mockReturnValueOnce(mockPromise)
 
     // This should throw the promise and suspend
-    const {result} = renderHook(
+    const {result} = reactRenderHook(
       () => {
         try {
           return useDocumentPermissions(mockAction)
@@ -216,7 +217,7 @@ describe('usePermissions', () => {
   it('throws when no resource is found from action or context', () => {
     // Provide SanityInstance via ResourceProvider but no resource, so contextResource is undefined
     expect(() => {
-      renderHook(
+      reactRenderHook(
         () =>
           useDocumentPermissions({
             type: 'document.publish',
@@ -228,7 +229,7 @@ describe('usePermissions', () => {
           wrapper: ({children}) => <ResourceProvider fallback={null}>{children}</ResourceProvider>,
         },
       )
-    }).toThrow(/resource is required/)
+    }).toThrow(/No resource found/)
   })
 
   it('should react to permission state changes', async () => {

package/src/hooks/document/useDocumentPermissions.ts

@@ -1,11 +1,19 @@
 import {type DocumentAction, type DocumentPermissionsResult, getPermissionsState} from '@sanity/sdk'
+import {isDeepEqual} from '@sanity/sdk/_internal'
 import {useCallback, useContext, useMemo, useSyncExternalStore} from 'react'
 import {filter, firstValueFrom} from 'rxjs'
 
-import {ResourceContext} from '../../context/DefaultResourceContext'
 import {ResourcesContext} from '../../context/ResourcesContext'
 import {useSanityInstance} from '../context/useSanityInstance'
-import {normalizeResourceOptions} from '../helpers/useNormalizedResourceOptions'
+import {
+  normalizeResourceOptions,
+  useEffectiveContextResource,
+  type WithResourceNameSupport,
+} from '../helpers/useNormalizedResourceOptions'
+import {trackHookUsage} from '../helpers/useTrackHookUsage'
+
+const noopSubscribe = () => () => {}
+const returnUndefined = () => undefined
 
 /**
  *
@@ -85,63 +93,87 @@ import {normalizeResourceOptions} from '../helpers/useNormalizedResourceOptions'
  * ```
  */
 export function useDocumentPermissions(
-  actionOrActions: DocumentAction | DocumentAction[],
+  actionOrActions:
+    | WithResourceNameSupport<DocumentAction>
+    | WithResourceNameSupport<DocumentAction>[],
 ): DocumentPermissionsResult {
   const instance = useSanityInstance()
-  const contextResource = useContext(ResourceContext)
+  trackHookUsage(instance, 'useDocumentPermissions')
+  const effectiveContextResource = useEffectiveContextResource()
   const resources = useContext(ResourcesContext)
 
-  const normalizedActions = useMemo(() => {
-    return Array.isArray(actionOrActions)
+  const {
+    actions: normalizedActions,
+    resource: actionResource,
+    error: validationError,
+  } = useMemo(() => {
+    const normalized = Array.isArray(actionOrActions)
       ? actionOrActions.map((action) =>
-          normalizeResourceOptions(action, resources, contextResource),
+          normalizeResourceOptions(action, resources, effectiveContextResource),
         )
-      : [normalizeResourceOptions(actionOrActions, resources, contextResource)]
-  }, [actionOrActions, resources, contextResource])
-
-  // if actions is an array, we need to check that all actions belong to the same resource
-  let resource
+      : [normalizeResourceOptions(actionOrActions, resources, effectiveContextResource)]
 
-  for (const action of normalizedActions) {
-    if (action.resource) {
-      if (!resource) resource = action.resource
-      if (action.resource !== resource) {
-        throw new Error(
-          `Mismatched resources found in actions. All actions must belong to the same resource. Found "${JSON.stringify(action.resource)}" but expected "${JSON.stringify(resource)}".`,
-        )
+    let resource
+    for (const action of normalized) {
+      if (action.resource) {
+        if (!resource) resource = action.resource
+        if (!isDeepEqual(action.resource, resource)) {
+          return {
+            actions: normalized,
+            resource,
+            error: new Error(
+              `Mismatched resources found in actions. All actions must belong to the same resource. Found "${JSON.stringify(action.resource)}" but expected "${JSON.stringify(resource)}".`,
+            ),
+          }
+        }
       }
     }
-  }
+    return {actions: normalized, resource, error: undefined}
+  }, [actionOrActions, resources, effectiveContextResource])
 
-  const effectiveResource = resource ?? contextResource
-
-  if (!effectiveResource) {
-    throw new Error(
-      'No resource found. Provide a resource via the action handle or wrap with a resource context.',
-    )
-  }
+  const effectiveResource = actionResource ?? effectiveContextResource
 
+  // Keep hooks unconditional — validation errors and missing-resource errors are
+  // thrown after all hooks so that the hook call count stays stable across renders.
   const permissionsOptions = useMemo(
-    () => ({resource: effectiveResource, actions: normalizedActions as DocumentAction[]}),
+    () =>
+      effectiveResource
+        ? {
+            resource: effectiveResource,
+            // `Omit<>` on `DocumentAction` loses the discriminant; runtime values are still actions.
+            actions: normalizedActions as DocumentAction[],
+          }
+        : undefined,
     [effectiveResource, normalizedActions],
   )
 
-  const isDocumentReady = useCallback(
-    () => getPermissionsState(instance, permissionsOptions).getCurrent() !== undefined,
+  const stateSource = useMemo(
+    () => (permissionsOptions ? getPermissionsState(instance, permissionsOptions) : undefined),
     [permissionsOptions, instance],
   )
+
+  const isDocumentReady = useCallback(
+    () => stateSource !== undefined && stateSource.getCurrent() !== undefined,
+    [stateSource],
+  )
+
+  const result = useSyncExternalStore(
+    stateSource?.subscribe ?? noopSubscribe,
+    stateSource?.getCurrent ?? returnUndefined,
+  )
+
+  // All hooks have been called — safe to throw now.
+  if (validationError) throw validationError
+  if (!effectiveResource) {
+    throw new Error(
+      'No resource found. Provide a resource via the action handle or wrap with a resource context.',
+    )
+  }
   if (!isDocumentReady()) {
     throw firstValueFrom(
-      getPermissionsState(instance, permissionsOptions).observable.pipe(
-        filter((result) => result !== undefined),
-      ),
+      stateSource!.observable.pipe(filter((permissions) => permissions !== undefined)),
     )
   }
 
-  const {subscribe, getCurrent} = useMemo(
-    () => getPermissionsState(instance, permissionsOptions),
-    [permissionsOptions, instance],
-  )
-
-  return useSyncExternalStore(subscribe, getCurrent) as DocumentPermissionsResult
+  return result as DocumentPermissionsResult
 }

package/src/hooks/document/useDocumentSyncStatus.test.ts

@@ -25,6 +25,7 @@ describe('useDocumentSyncStatus', () => {
         getState: getDocumentSyncStatus,
         shouldSuspend: expect.any(Function),
         suspender: expect.any(Function),
+        getConfig: expect.any(Function),
       }),
     )
     // Verify that the hook was created and can be called