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

package/src/hooks/{auth/useDashboardOrganizationId.test.tsx → dashboard/useOrganizationId.test.tsx}

@@ -4,14 +4,14 @@ import {throwError} from 'rxjs'
 import {describe, expect, it, vi} from 'vitest'
 
 import {ResourceProvider} from '../../context/ResourceProvider'
-import {useDashboardOrganizationId} from './useDashboardOrganizationId'
+import {useOrganizationId} from './useOrganizationId'
 
 vi.mock('@sanity/sdk', async (importOriginal) => {
   const actual = await importOriginal()
   return {...(actual || {}), getDashboardOrganizationId: vi.fn()}
 })
 
-describe('useDashboardOrganizationId', () => {
+describe('useOrganizationId', () => {
   it('should return undefined when no organization ID is set', () => {
     const subscribe = vi.fn()
     vi.mocked(getDashboardOrganizationId).mockReturnValue({
@@ -20,7 +20,7 @@ describe('useDashboardOrganizationId', () => {
       observable: throwError(() => new Error('Unexpected usage of observable')),
     })
 
-    const {result} = renderHook(() => useDashboardOrganizationId(), {
+    const {result} = renderHook(() => useOrganizationId(), {
       wrapper: ({children}) => (
         <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
           {children}
@@ -39,7 +39,7 @@ describe('useDashboardOrganizationId', () => {
       observable: throwError(() => new Error('Unexpected usage of observable')),
     })
 
-    const {result} = renderHook(() => useDashboardOrganizationId(), {
+    const {result} = renderHook(() => useOrganizationId(), {
       wrapper: ({children}) => (
         <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
           {children}

package/src/hooks/{auth/useDashboardOrganizationId.tsx → dashboard/useOrganizationId.tsx}

@@ -11,7 +11,7 @@ import {useSanityInstance} from '../context/useSanityInstance'
  * @example
  * ```tsx
  * function DashboardComponent() {
- *   const orgId = useDashboardOrganizationId()
+ *   const orgId = useOrganizationId()
  *
  *   if (!orgId) return null
  *
@@ -22,7 +22,7 @@ import {useSanityInstance} from '../context/useSanityInstance'
  * @category Dashboard
  * @returns The dashboard organization ID (string | undefined)
  */
-export function useDashboardOrganizationId(): string | undefined {
+export function useOrganizationId(): string | undefined {
   const instance = useSanityInstance()
   const {subscribe, getCurrent} = useMemo(() => getDashboardOrganizationId(instance), [instance])
 

package/src/hooks/dashboard/useUpdateFavorite.test.tsx

@@ -0,0 +1,146 @@
+import {type FavoriteStatusResponse, setFavorite} from '@sanity/sdk'
+import {type MutationResult} from '@sanity/sdk/_internal'
+import {act, renderHook, waitFor} from '@testing-library/react'
+import {type ReactNode} from 'react'
+import {afterEach, beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
+
+import {ResourceProvider} from '../../context/ResourceProvider'
+import {useUpdateFavorite} from './useUpdateFavorite'
+
+vi.mock(import('@sanity/sdk'), async (importOriginal) => {
+  const actual = await importOriginal()
+  return {
+    ...actual,
+    setFavorite: vi.fn(),
+  }
+})
+
+type SetFavorite = typeof setFavorite
+
+describe('useUpdateFavorite', () => {
+  const mockSetFavorite = setFavorite as Mock
+
+  const handle = {
+    documentId: 'mock-id',
+    documentType: 'mock-type',
+    resourceType: 'studio' as const,
+  }
+
+  const makeWrapper = (projectId?: string, dataset?: string) => {
+    return function Wrapper({children}: {children: ReactNode}) {
+      return (
+        <ResourceProvider projectId={projectId} dataset={dataset} fallback={null}>
+          {children}
+        </ResourceProvider>
+      )
+    }
+  }
+  const wrapper = makeWrapper('test', 'test')
+
+  beforeEach(() => {
+    mockSetFavorite.mockImplementation((async (_instance, input) => ({
+      data: {isFavorited: input.isFavorited},
+      invalidated: Promise.resolve(),
+    })) as SetFavorite)
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('sends the added event with the resolved studio resourceId', async () => {
+    const {result} = renderHook(() => useUpdateFavorite(handle), {wrapper})
+
+    await act(async () => {
+      await result.current.favorite()
+    })
+
+    expect(setFavorite).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        documentId: 'mock-id',
+        documentType: 'mock-type',
+        resourceId: 'test.test',
+        resourceType: 'studio',
+        isFavorited: true,
+      }),
+    )
+  })
+
+  it('sends the removed event when unfavoriting', async () => {
+    const {result} = renderHook(() => useUpdateFavorite(handle), {wrapper})
+
+    await act(async () => {
+      await result.current.unfavorite()
+    })
+
+    expect(setFavorite).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({isFavorited: false}),
+    )
+  })
+
+  it('passes schemaName through when provided', async () => {
+    const {result} = renderHook(() => useUpdateFavorite({...handle, schemaName: 'testSchema'}), {
+      wrapper,
+    })
+
+    await act(async () => {
+      await result.current.favorite()
+    })
+
+    expect(setFavorite).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({schemaName: 'testSchema', isFavorited: true}),
+    )
+  })
+
+  it('tracks isPending across the mutation lifecycle', async () => {
+    let resolveMutation!: (value: MutationResult<FavoriteStatusResponse>) => void
+    mockSetFavorite.mockReturnValue(
+      new Promise<MutationResult<FavoriteStatusResponse>>((resolve) => {
+        resolveMutation = resolve
+      }),
+    )
+
+    const {result} = renderHook(() => useUpdateFavorite(handle), {wrapper})
+    expect(result.current.isPending).toBe(false)
+
+    act(() => {
+      void result.current.favorite()
+    })
+    expect(result.current.isPending).toBe(true)
+
+    await act(async () => {
+      resolveMutation({data: {isFavorited: true}, invalidated: Promise.resolve()})
+    })
+    expect(result.current.isPending).toBe(false)
+  })
+
+  it('surfaces mutation failures on error', async () => {
+    mockSetFavorite.mockRejectedValue(new Error('mutate failed'))
+
+    const {result} = renderHook(() => useUpdateFavorite(handle), {wrapper})
+
+    await act(async () => {
+      await expect(result.current.favorite()).rejects.toThrow('mutate failed')
+    })
+
+    await waitFor(() => expect(result.current.error).toBeInstanceOf(Error))
+  })
+
+  it('throws when a studio resource is missing projectId or dataset', () => {
+    expect(() =>
+      renderHook(() => useUpdateFavorite(handle), {wrapper: makeWrapper(undefined, undefined)}),
+    ).toThrow('projectId and dataset are required for studio resources')
+  })
+
+  it('throws when resourceId is missing for non-studio resources', () => {
+    expect(() =>
+      renderHook(
+        () => useUpdateFavorite({...handle, resourceType: 'media-library', resourceId: undefined}),
+        {wrapper},
+      ),
+    ).toThrow('resourceId is required for media-library and canvas resources')
+  })
+})

package/src/hooks/dashboard/useUpdateFavorite.ts

@@ -0,0 +1,74 @@
+import {type FavoriteStatusResponse, setFavorite} from '@sanity/sdk'
+import {useCallback} from 'react'
+
+import {createMutationHook} from '../helpers/createMutationHook'
+import {useFavoriteContext, type UseFavoriteProps} from './useFavoriteContext'
+
+const useSetFavorite = createMutationHook(setFavorite)
+
+/**
+ * The value returned by {@link useUpdateFavorite}.
+ *
+ * @internal
+ */
+export interface UpdateFavorite {
+  /** Adds the document to favorites. */
+  favorite: () => Promise<FavoriteStatusResponse>
+  /** Removes the document from favorites. */
+  unfavorite: () => Promise<FavoriteStatusResponse>
+  /** A favorite or unfavorite mutation is currently in flight. */
+  isPending: boolean
+  /** The most recent failure; cleared by the next call or `reset`. */
+  error: unknown
+  /** Clears error and pending state back to idle. */
+  reset: () => void
+}
+
+/**
+ * @internal
+ *
+ * Adds or removes a document from favorites. The read-side counterpart is
+ * {@link useFavorite}, which reflects the change once the mutation settles.
+ *
+ * Unlike {@link useFavorite}, this hook does not suspend.
+ *
+ * @param props - The document handle plus the resource it lives in.
+ * @returns `favorite`/`unfavorite` actions and the `{isPending, error, reset}`
+ *   mutation state.
+ *
+ * @example
+ * ```tsx
+ * function FavoriteButton(props: DocumentActionProps) {
+ *   const {documentId, documentType} = props
+ *   const handle = {documentId, documentType, resourceType: 'studio'} as const
+ *   const isFavorited = useFavorite(handle)
+ *   const {favorite, unfavorite, isPending} = useUpdateFavorite(handle)
+ *
+ *   return (
+ *     <Button
+ *       disabled={isPending}
+ *       onClick={() => (isFavorited ? unfavorite() : favorite())}
+ *       text={isFavorited ? 'Remove from favorites' : 'Add to favorites'}
+ *     />
+ *   )
+ * }
+ *
+ * // Wrap the component with Suspense since useFavorite suspends
+ * function MyDocumentAction(props: DocumentActionProps) {
+ *   return (
+ *     <Suspense fallback={<Button text="Loading..." disabled />}>
+ *       <FavoriteButton {...props} />
+ *     </Suspense>
+ *   )
+ * }
+ * ```
+ */
+export function useUpdateFavorite(props: UseFavoriteProps): UpdateFavorite {
+  const context = useFavoriteContext(props)
+  const {mutate, isPending, error, reset} = useSetFavorite()
+
+  const favorite = useCallback(() => mutate({...context, isFavorited: true}), [mutate, context])
+  const unfavorite = useCallback(() => mutate({...context, isFavorited: false}), [mutate, context])
+
+  return {favorite, unfavorite, isPending, error, reset}
+}

package/src/hooks/dashboard/useWindowTitle.ts

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

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

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

package/src/hooks/datasets/useDatasets.ts

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

package/src/hooks/document/useCreateDocument.ts

@@ -1,4 +1,5 @@
 import {createDocument} from '@sanity/sdk'
+import {randomUuid} from '@sanity/sdk/_internal'
 import {type SanityDocument} from 'groq'
 
 import {type DocumentHandle, type DocumentTypeHandle} from '../../config/handles'
@@ -109,7 +110,7 @@ export function useCreateDocument(
   const apply = useApplyDocumentActions()
 
   return async (initialValue, overrides) => {
-    const documentId = overrides?.documentId ?? options.documentId ?? crypto.randomUUID()
+    const documentId = overrides?.documentId ?? options.documentId ?? randomUuid()
     const handle: DocumentHandle = {...options, documentId}
     await apply(createDocument(handle, initialValue))
     return handle

package/src/utils/resolveOrgResources.test.ts

@@ -52,10 +52,10 @@ describe('resolveOrgResources', () => {
     await resolveOrgResources(mockInstance, ORG_ID)
 
     expect(mockRequest).toHaveBeenCalledWith(
-      expect.objectContaining({uri: '/media-libraries', query: {organizationId: ORG_ID}}),
+      expect.objectContaining({url: '/media-libraries', query: {organizationId: ORG_ID}}),
     )
     expect(mockRequest).toHaveBeenCalledWith(
-      expect.objectContaining({uri: '/canvases', query: {organizationId: ORG_ID}}),
+      expect.objectContaining({url: '/canvases', query: {organizationId: ORG_ID}}),
     )
   })
 

package/src/utils/resolveOrgResources.ts

@@ -48,12 +48,12 @@ export async function resolveOrgResources(
 
   const [mediaLibrariesResult, canvasesResult] = await Promise.allSettled([
     client.request<OrgResourcesApiResponse>({
-      uri: `/media-libraries`,
+      url: `/media-libraries`,
       query: {organizationId},
       tag: 'org-resources.media-libraries',
     }),
     client.request<OrgResourcesApiResponse>({
-      uri: `/canvases`,
+      url: `/canvases`,
       query: {organizationId},
       tag: 'org-resources.canvases',
     }),

package/src/context/WorkbenchTokenRefresh.tsx

@@ -1,61 +0,0 @@
-import {type ClientError} from '@sanity/client'
-import {AuthStateType, setAuthToken} from '@sanity/sdk'
-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'
-
-/**
- * Keeps the SDK auth token in sync with the workbench "OS".
- *
- * When running as a federated remote inside the workbench 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) {
-  const instance = useSanityInstance()
-  const authState = useAuthState()
-  const processed401ErrorRef = useRef<unknown | null>(null)
-
-  useEffect(() => {
-    const token$ = observeWorkbenchToken()
-    if (!token$) return undefined
-    const subscription = token$.subscribe((token) => setAuthToken(instance, token))
-    return () => subscription.unsubscribe()
-  }, [instance])
-
-  useEffect(() => {
-    const has401Error =
-      authState.type === AuthStateType.ERROR && (authState.error as ClientError)?.statusCode === 401
-
-    if (has401Error && processed401ErrorRef.current !== authState.error) {
-      processed401ErrorRef.current = authState.error
-      refreshWorkbenchToken()
-    } else if (!has401Error) {
-      processed401ErrorRef.current = null
-    }
-  }, [authState])
-
-  return children
-}
-
-/**
- * Provides workbench OS token refresh. No-op outside the workbench, where the
- * app uses its normal auth flow.
- * @public
- */
-export const WorkbenchTokenRefreshProvider: React.FC<PropsWithChildren> = ({children}) => {
-  if (isWorkbenchEnvironment()) {
-    return <WorkbenchTokenRefresh>{children}</WorkbenchTokenRefresh>
-  }
-
-  return children
-}

package/src/context/workbenchToken.ts

@@ -1,63 +0,0 @@
-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
-// 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.
- *
- * 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
- * `@sanity/workbench` (it would install a bus and add bundle weight for no
- * reason). Note: this is a different embedding model to the Core UI iframe,
- * which is detected separately via the dashboard context — that signal is not
- * set on the federation path.
- *
- * @internal
- */
-export function isWorkbenchEnvironment(): boolean {
-  return typeof globalThis === 'object' && OS_BUS_KEY in globalThis
-}
-
-/**
- * Observes the session token issued by the workbench "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
- * `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
- * token" (`null`). The token is used in-memory only and never persisted.
- *
- * @internal
- */
-export function observeWorkbenchToken(): Observable<string | null> | undefined {
-  if (!isWorkbenchEnvironment()) return undefined
-
-  return from(import('@sanity/workbench')).pipe(
-    switchMap(({os}) => os.subscribe('auth.token')),
-    // Any failure (importing the host bundle, or the subscription) means "no OS token".
-    catchError(() => of(null)),
-  )
-}
-
-/**
- * Asks the workbench "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.
- *
- * @internal
- */
-export function refreshWorkbenchToken(): void {
-  if (!isWorkbenchEnvironment()) return
-
-  void import('@sanity/workbench').then(
-    ({os}) => os.emit('auth.token.refresh', undefined),
-    () => {},
-  )
-}