@sanity/sdk 2.15.0 → 2.17.0

package/src/query/reducers.test.ts

@@ -2,8 +2,6 @@ import {describe, expect, it} from 'vitest'
 
 import {
   addSubscriber,
-  cancelQuery,
-  initializeQuery,
   type QueryStoreState,
   removeSubscriber,
   setLastLiveEventId,
@@ -109,44 +107,4 @@ describe('Query Reducers', () => {
       expect(newState.queries).not.toHaveProperty('q8')
     })
   })
-
-  describe('cancelQuery', () => {
-    it('should return state unchanged if key does not exist', () => {
-      const state: QueryStoreState = {queries: {}}
-      const reducer = cancelQuery('nonexistent')
-      const newState = reducer(state)
-      expect(newState).toBe(state)
-    })
-
-    it('should return state unchanged if query has subscribers', () => {
-      const state: QueryStoreState = {queries: {q9: {subscribers: ['sub1']}}}
-      const reducer = cancelQuery('q9')
-      const newState = reducer(state)
-      expect(newState).toBe(state)
-    })
-
-    it('should remove the query if no subscribers exist', () => {
-      const state: QueryStoreState = {queries: {q10: {subscribers: []}}}
-      const reducer = cancelQuery('q10')
-      const newState = reducer(state)
-      expect(newState.queries).not.toHaveProperty('q10')
-    })
-  })
-
-  describe('initializeQuery', () => {
-    it('should return state unchanged if query already exists', () => {
-      const existing = {subscribers: ['sub1']}
-      const state: QueryStoreState = {queries: {q11: existing}}
-      const reducer = initializeQuery('q11')
-      const newState = reducer(state)
-      expect(newState).toBe(state)
-    })
-
-    it('should add the query with empty subscribers if it does not exist', () => {
-      const state: QueryStoreState = {queries: {}}
-      const reducer = initializeQuery('q12')
-      const newState = reducer(state)
-      expect(newState.queries['q12']).toEqual({subscribers: []})
-    })
-  })
 })

package/src/query/reducers.ts

@@ -57,19 +57,3 @@ export const removeSubscriber =
     if (!subscribers.length) return {...prev, queries: omitProperty(prev.queries, key)}
     return {...prev, queries: {...prev.queries, [key]: {...prevQuery, subscribers}}}
   }
-
-export const cancelQuery =
-  (key: string) =>
-  (prev: QueryStoreState): QueryStoreState => {
-    const prevQuery = prev.queries[key]
-    if (!prevQuery) return prev
-    if (prevQuery.subscribers.length) return prev
-    return {...prev, queries: omitProperty(prev.queries, key)}
-  }
-
-export const initializeQuery =
-  (key: string) =>
-  (prev: QueryStoreState): QueryStoreState => {
-    if (prev.queries[key]) return prev
-    return {...prev, queries: {...prev.queries, [key]: {subscribers: []}}}
-  }

package/src/releases/getPerspectiveState.test.ts

@@ -3,12 +3,11 @@ import {filter, firstValueFrom, of, Subject, take} from 'rxjs'
 import {describe, expect, it, vi} from 'vitest'
 
 import {type PerspectiveHandle, type ReleasePerspective} from '../config/sanityConfig'
-import {getQueryState} from '../query/queryStore'
 import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
-import {type StateSource} from '../store/createStateSourceAction'
 import {getPerspectiveState} from './getPerspectiveState'
+import {observeReleases} from './observeReleases'
 
-vi.mock('../query/queryStore')
+vi.mock('./observeReleases')
 
 vi.mock('../client/clientStore', () => ({
   getClientState: vi.fn(() => ({
@@ -44,11 +43,7 @@ describe('getPerspectiveState', () => {
     instance = createSanityInstance({projectId: 'test', dataset: 'test'})
 
     mockReleasesQuerySubject = new Subject<ReleaseDocument[] | undefined>()
-    vi.mocked(getQueryState).mockReturnValue({
-      subscribe: () => () => {},
-      getCurrent: () => undefined,
-      observable: mockReleasesQuerySubject.asObservable(),
-    } as StateSource<ReleaseDocument[] | undefined>)
+    vi.mocked(observeReleases).mockReturnValue(mockReleasesQuerySubject.asObservable())
   })
 
   afterEach(() => {

package/src/releases/getPerspectiveState.ts

@@ -3,14 +3,6 @@ import {createSelector} from 'reselect'
 import {type DocumentResource, type PerspectiveHandle} from '../config/sanityConfig'
 import {bindActionByResource, type BoundStoreAction} from '../store/createActionBinder'
 import {createStateSourceAction, type SelectorContext} from '../store/createStateSourceAction'
-/*
- * Although this is an import dependency cycle, it is not a logical cycle:
- * 1. getPerspectiveState uses releasesStore as a data source
- * 2. releasesStore uses queryStore as a data source
- * 3. queryStore calls getPerspectiveState for computing release perspectives
- * 4. however, queryStore does not use getPerspectiveState for the perspective used in releasesStore ("raw")
- */
-// eslint-disable-next-line import/no-cycle
 import {releasesStore, type ReleasesStoreState} from './releasesStore'
 import {isReleasePerspective} from './utils/isReleasePerspective'
 import {sortReleases} from './utils/sortReleases'
@@ -53,7 +45,6 @@ const memoizedOptionsSelector = createSelector(
   },
 )
 
-// Lazily bind the action itself to avoid circular import initialization issues with `releasesStore`
 const _getPerspectiveStateSelector = createStateSourceAction({
   selector: createSelector(
     [selectInstancePerspective, selectActiveReleases, memoizedOptionsSelector],
@@ -89,7 +80,10 @@ type BoundGetPerspectiveState = BoundStoreAction<
   ReturnType<typeof _getPerspectiveStateSelector>
 >
 
-let _boundGetPerspectiveState: BoundGetPerspectiveState | undefined
+const _boundGetPerspectiveState = bindActionByResource(
+  releasesStore,
+  _getPerspectiveStateSelector,
+) as BoundGetPerspectiveState
 
 /**
  * Provides a subscribable state source for a "perspective" for the Sanity client,
@@ -103,13 +97,6 @@ let _boundGetPerspectiveState: BoundGetPerspectiveState | undefined
  *
  * @public
  */
-export const getPerspectiveState: BoundGetPerspectiveState = (instance, ...rest) => {
-  if (!_boundGetPerspectiveState) {
-    _boundGetPerspectiveState = bindActionByResource(
-      releasesStore,
-      _getPerspectiveStateSelector,
-    ) as BoundGetPerspectiveState
-  }
+export const getPerspectiveState: BoundGetPerspectiveState = (instance, ...rest) =>
   // bindActionByResource keyFn destructures { resource } from the first param, so pass {} when no options
-  return _boundGetPerspectiveState(instance, ...(rest.length ? rest : [{}]))
-}
+  _boundGetPerspectiveState(instance, ...(rest.length ? rest : [{}]))

package/src/releases/observeReleases.test.ts

@@ -0,0 +1,127 @@
+import {type LiveEventMessage, type ReleaseDocument, type SanityClient} from '@sanity/client'
+import {of, Subject} from 'rxjs'
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {getClientState} from '../client/clientStore'
+import {observeLiveEvents} from '../client/liveEvents'
+import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
+import {observeReleases} from './observeReleases'
+
+vi.mock('../client/clientStore', () => ({getClientState: vi.fn()}))
+vi.mock('../client/liveEvents', () => ({observeLiveEvents: vi.fn()}))
+
+describe('observeReleases', () => {
+  let instance: SanityInstance
+  let liveMessages: Subject<LiveEventMessage>
+  let fetch: ReturnType<typeof vi.fn>
+
+  const release = {
+    _id: 'r1',
+    _type: 'system.release',
+    name: 'r1',
+    metadata: {title: 'R1', releaseType: 'asap'},
+  } as ReleaseDocument
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    instance = createSanityInstance({projectId: 'test', dataset: 'test'})
+    liveMessages = new Subject<LiveEventMessage>()
+
+    fetch = vi.fn().mockReturnValue(of({result: [release], syncTags: ['s1:tag']}))
+    vi.mocked(getClientState).mockReturnValue({
+      observable: of({observable: {fetch}} as unknown as SanityClient),
+    } as StateSource<SanityClient>)
+    vi.mocked(observeLiveEvents).mockReturnValue(liveMessages.asObservable())
+  })
+
+  afterEach(() => {
+    instance.dispose()
+  })
+
+  it('emits undefined synchronously, then fetches releases through the raw perspective', () => {
+    const releases$ = observeReleases(instance, {onCorsError: vi.fn()})
+    const emissions: (ReleaseDocument[] | undefined)[] = []
+    const subscription = releases$.subscribe((releases) => emissions.push(releases))
+
+    // the synchronous undefined lets the releases store immediately record an
+    // empty list, so consumers (e.g. suspending React hooks) never hang on a
+    // fetch that has not resolved yet
+    expect(emissions).toEqual([undefined, [release]])
+    expect(fetch).toHaveBeenCalledWith(
+      'releases::all()',
+      {},
+      expect.objectContaining({
+        perspective: 'raw',
+        tag: 'releases',
+        lastLiveEventId: undefined,
+      }),
+    )
+    subscription.unsubscribe()
+  })
+
+  it('refetches with the live event id when a message matches the sync tags', () => {
+    const releases$ = observeReleases(instance, {onCorsError: vi.fn()})
+    const emissions: (ReleaseDocument[] | undefined)[] = []
+    const subscription = releases$.subscribe((releases) => emissions.push(releases))
+
+    liveMessages.next({type: 'message', id: 'event-1', tags: ['s1:tag']} as LiveEventMessage)
+
+    expect(fetch).toHaveBeenCalledTimes(2)
+    expect(fetch).toHaveBeenLastCalledWith(
+      'releases::all()',
+      {},
+      expect.objectContaining({lastLiveEventId: 'event-1'}),
+    )
+    expect(emissions).toHaveLength(3) // initial undefined + two fetch results
+    subscription.unsubscribe()
+  })
+
+  it('ignores live events that do not match the sync tags', () => {
+    const releases$ = observeReleases(instance, {onCorsError: vi.fn()})
+    const subscription = releases$.subscribe()
+
+    liveMessages.next({type: 'message', id: 'event-1', tags: ['s1:other']} as LiveEventMessage)
+
+    expect(fetch).toHaveBeenCalledTimes(1)
+    subscription.unsubscribe()
+  })
+
+  it('refetches for a matching message that arrived while a fetch was still in flight', () => {
+    const fetchResponses: Subject<{result: ReleaseDocument[]; syncTags: string[]}>[] = []
+    fetch.mockImplementation(() => {
+      const response$ = new Subject<{result: ReleaseDocument[]; syncTags: string[]}>()
+      fetchResponses.push(response$)
+      return response$
+    })
+
+    const releases$ = observeReleases(instance, {onCorsError: vi.fn()})
+    const emissions: (ReleaseDocument[] | undefined)[] = []
+    const subscription = releases$.subscribe((releases) => emissions.push(releases))
+
+    expect(fetch).toHaveBeenCalledTimes(1)
+
+    // A message lands while the initial fetch is in flight — its sync tags are
+    // not known yet, so it can't be evaluated right away…
+    liveMessages.next({type: 'message', id: 'event-1', tags: ['s1:tag']} as LiveEventMessage)
+    expect(fetch).toHaveBeenCalledTimes(1)
+
+    // …but once the fetch completes with matching tags, it must trigger a
+    // refetch instead of being dropped (which would leave the store stale)
+    fetchResponses[0].next({result: [release], syncTags: ['s1:tag']})
+    fetchResponses[0].complete()
+
+    expect(fetch).toHaveBeenCalledTimes(2)
+    expect(fetch).toHaveBeenLastCalledWith(
+      'releases::all()',
+      {},
+      expect.objectContaining({lastLiveEventId: 'event-1'}),
+    )
+
+    fetchResponses[1].next({result: [release], syncTags: ['s1:tag']})
+    fetchResponses[1].complete()
+    expect(emissions).toHaveLength(3) // initial undefined + two fetch results
+
+    subscription.unsubscribe()
+  })
+})

package/src/releases/observeReleases.ts

@@ -0,0 +1,102 @@
+import {type ReleaseDocument, type SyncTag} from '@sanity/client'
+import {
+  BehaviorSubject,
+  combineLatest,
+  distinctUntilChanged,
+  filter,
+  map,
+  type Observable,
+  startWith,
+  switchMap,
+  tap,
+} from 'rxjs'
+
+import {getClientState} from '../client/clientStore'
+import {observeLiveEvents} from '../client/liveEvents'
+import {type DocumentResource} from '../config/sanityConfig'
+import {type SanityInstance} from '../store/createSanityInstance'
+
+const RELEASES_QUERY = 'releases::all()'
+const RELEASES_API_VERSION = 'v2025-05-06'
+
+/**
+ * Options for {@link observeReleases}.
+ * @internal
+ */
+export interface ObserveReleasesOptions {
+  /** Resource to scope the underlying client and live connection to. */
+  resource?: DocumentResource
+  /**
+   * Called when the live events connection fails due to a CORS
+   * misconfiguration. See `observeLiveEvents`.
+   */
+  onCorsError: (error: unknown) => void
+}
+
+/**
+ * Emits every release document (including archived and published), refetching
+ * whenever a Live Content API event matches the query's sync tags.
+ *
+ * This fetches directly through the client store — deliberately not via the
+ * query store — because release data is itself an input to query perspective
+ * resolution (`getPerspectiveState`); fetching through the query store would
+ * make the two stores mutually dependent.
+ *
+ * @internal
+ */
+export function observeReleases(
+  instance: SanityInstance,
+  {resource, onCorsError}: ObserveReleasesOptions,
+): Observable<ReleaseDocument[] | undefined> {
+  const client$ = getClientState(instance, {
+    apiVersion: RELEASES_API_VERSION,
+    resource,
+  }).observable
+
+  return client$.pipe(
+    switchMap((client) => {
+      const syncTags$ = new BehaviorSubject<SyncTag[] | undefined>(undefined)
+
+      // Pair the latest live message with the latest known sync tags so that
+      // a message arriving while a fetch is still in flight is re-evaluated
+      // (and refetched if it matches) once that fetch's tags land — instead
+      // of being dropped and leaving the store stale until the next event.
+      const refetchEventId$ = combineLatest([
+        observeLiveEvents(instance, {resource, onCorsError}).pipe(startWith(undefined)),
+        syncTags$,
+      ]).pipe(
+        filter(
+          ([message, syncTags]) =>
+            message === undefined || message.tags.some((tag) => syncTags?.includes(tag)),
+        ),
+        map(([message]) => message?.id),
+        distinctUntilChanged(),
+      )
+
+      return refetchEventId$.pipe(
+        switchMap((lastLiveEventId) =>
+          client.observable.fetch<ReleaseDocument[]>(
+            RELEASES_QUERY,
+            {},
+            {
+              perspective: 'raw',
+              filterResponse: false,
+              returnQuery: false,
+              lastLiveEventId,
+              tag: 'releases',
+            },
+          ),
+        ),
+        tap((response) => {
+          syncTags$.next(response.syncTags)
+        }),
+        map((response) => response.result),
+      )
+    }),
+    // Emit synchronously on subscribe (mirroring StateSource semantics, which
+    // the releases store previously consumed) so the store can immediately
+    // record an empty list: consumers distinguish "no releases yet" from
+    // "never loaded", and the React hooks don't suspend on first load.
+    startWith(undefined),
+  )
+}

package/src/releases/releasesStore.test.ts

@@ -2,13 +2,12 @@ import {type ReleaseDocument} from '@sanity/client'
 import {NEVER, Observable, type Observer, of, Subject} from 'rxjs'
 import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {getQueryState, resolveQuery} from '../query/queryStore'
 import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
-import {type StateSource} from '../store/createStateSourceAction'
+import {observeReleases} from './observeReleases'
 import {getActiveReleasesState, getAllReleasesState} from './releasesStore'
 
 // Mock dependencies
-vi.mock('../query/queryStore')
+vi.mock('./observeReleases')
 
 describe('releasesStore', () => {
   let instance: SanityInstance
@@ -18,13 +17,7 @@ describe('releasesStore', () => {
 
     instance = createSanityInstance({projectId: 'test', dataset: 'test'})
 
-    vi.mocked(getQueryState).mockReturnValue({
-      subscribe: () => () => {},
-      getCurrent: () => undefined,
-      observable: NEVER as Observable<ReleaseDocument[] | undefined>,
-    } as StateSource<ReleaseDocument[] | undefined>)
-
-    vi.mocked(resolveQuery).mockResolvedValue(undefined)
+    vi.mocked(observeReleases).mockReturnValue(NEVER as Observable<ReleaseDocument[] | undefined>)
   })
 
   afterEach(() => {
@@ -35,13 +28,11 @@ describe('releasesStore', () => {
     const state = getActiveReleasesState(instance)
 
     expect(state.getCurrent()).toBeUndefined()
-    expect(getQueryState).toHaveBeenCalledWith(
+    expect(observeReleases).toHaveBeenCalledWith(
       instance,
       expect.objectContaining({
-        query: 'releases::all()',
-        perspective: 'raw',
-        tag: 'releases',
         resource: {dataset: 'test', projectId: 'test'},
+        onCorsError: expect.any(Function),
       }),
     )
   })
@@ -52,11 +43,7 @@ describe('releasesStore', () => {
       .fn<(observer: Observer<ReleaseDocument[] | undefined>) => () => void>()
       .mockReturnValue(teardown)
 
-    vi.mocked(getQueryState).mockReturnValue({
-      subscribe: () => () => {},
-      getCurrent: () => undefined,
-      observable: new Observable(subscriber),
-    } as StateSource<ReleaseDocument[] | undefined>)
+    vi.mocked(observeReleases).mockReturnValue(new Observable(subscriber))
 
     // note that the order of the releases is important here -- they get sorted
     const mockReleases: ReleaseDocument[] = [
@@ -87,11 +74,7 @@ describe('releasesStore', () => {
 
   it('should update active releases state when the query emits new data', async () => {
     const releasesSubject = new Subject<ReleaseDocument[]>()
-    vi.mocked(getQueryState).mockReturnValue({
-      subscribe: () => () => {},
-      getCurrent: () => undefined,
-      observable: releasesSubject.asObservable(),
-    } as StateSource<ReleaseDocument[] | undefined>)
+    vi.mocked(observeReleases).mockReturnValue(releasesSubject.asObservable())
 
     const state = getActiveReleasesState(instance, {resource: {projectId: 'test', dataset: 'test'}})
 
@@ -133,12 +116,8 @@ describe('releasesStore', () => {
   })
 
   it('should handle empty array from the query', async () => {
-    // Configure query to return an empty array
-    vi.mocked(getQueryState).mockReturnValue({
-      subscribe: () => () => {},
-      getCurrent: () => [],
-      observable: of([]),
-    } as StateSource<ReleaseDocument[] | undefined>)
+    // Configure the releases source to return an empty array
+    vi.mocked(observeReleases).mockReturnValue(of([]))
 
     const state = getActiveReleasesState(instance, {resource: {projectId: 'test', dataset: 'test'}})
 
@@ -149,32 +128,20 @@ describe('releasesStore', () => {
 
   it('should handle null/undefined from the query by defaulting to empty array', async () => {
     // Test null case
-    vi.mocked(getQueryState).mockReturnValue({
-      subscribe: () => () => {},
-      getCurrent: () => null as unknown as ReleaseDocument[] | undefined,
-      observable: of(null as unknown as ReleaseDocument[] | undefined),
-    } as StateSource<ReleaseDocument[] | undefined>)
+    vi.mocked(observeReleases).mockReturnValue(of(null as unknown as ReleaseDocument[] | undefined))
     const state = getActiveReleasesState(instance, {resource: {projectId: 'test', dataset: 'test'}})
     await new Promise((resolve) => setTimeout(resolve, 0))
     expect(state.getCurrent()).toEqual([])
 
     // Test undefined case
-    vi.mocked(getQueryState).mockReturnValue({
-      subscribe: () => () => {},
-      getCurrent: () => undefined,
-      observable: of(undefined),
-    } as StateSource<ReleaseDocument[] | undefined>)
+    vi.mocked(observeReleases).mockReturnValue(of(undefined))
     await new Promise((resolve) => setTimeout(resolve, 0))
     expect(state.getCurrent()).toEqual([])
   })
 
   it('exposes archived/published releases through getAllReleasesState but filters them out of getActiveReleasesState', async () => {
     const subject = new Subject<ReleaseDocument[]>()
-    vi.mocked(getQueryState).mockReturnValue({
-      subscribe: () => () => {},
-      getCurrent: () => undefined,
-      observable: subject.asObservable(),
-    } as StateSource<ReleaseDocument[] | undefined>)
+    vi.mocked(observeReleases).mockReturnValue(subject.asObservable())
 
     const active = getActiveReleasesState(instance, {
       resource: {projectId: 'test', dataset: 'test'},
@@ -216,20 +183,51 @@ describe('releasesStore', () => {
     expect(allNames).toHaveLength(3)
   })
 
-  it('should not crash when the releases query errors', async () => {
+  it('surfaces CORS errors from the live connection as a store-wide error', async () => {
     const subject = new Subject<ReleaseDocument[]>()
-    vi.mocked(getQueryState).mockReturnValue({
-      subscribe: () => () => {},
-      getCurrent: () => undefined,
-      observable: subject.asObservable(),
-    } as StateSource<ReleaseDocument[] | undefined>)
+    vi.mocked(observeReleases).mockReturnValue(subject.asObservable())
 
     const state = getActiveReleasesState(instance, {resource: {projectId: 'test', dataset: 'test'}})
 
-    subject.error(new Error('Query failed'))
+    subject.next([
+      {
+        _id: 'r1',
+        _type: 'system.release',
+        name: 'r1',
+        state: 'active',
+        metadata: {releaseType: 'asap'},
+      } as ReleaseDocument,
+    ])
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(state.getCurrent()).toHaveLength(1)
+
+    const [, options] = vi.mocked(observeReleases).mock.lastCall!
+    const corsError = new Error('CORS misconfiguration')
+    options.onCorsError(corsError)
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    // the CORS error is recorded as store state so the releases selector
+    // rethrows it (handled by the Cors Error component)
+    expect(() => state.getCurrent()).toThrow(corsError)
+  })
+
+  it('should surface the error when the releases query errors', async () => {
+    const subject = new Subject<ReleaseDocument[]>()
+    vi.mocked(observeReleases).mockReturnValue(subject.asObservable())
+
+    const active = getActiveReleasesState(instance, {
+      resource: {projectId: 'test', dataset: 'test'},
+    })
+    const all = getAllReleasesState(instance, {resource: {projectId: 'test', dataset: 'test'}})
+
+    const error = new Error('Query failed')
+    subject.error(error)
 
     await new Promise((resolve) => setTimeout(resolve, 0))
 
-    expect(state.getCurrent()).toEqual(undefined)
+    // The error must be surfaced (thrown) rather than silently swallowed,
+    // otherwise consumers just see an empty list with no signal.
+    expect(() => active.getCurrent()).toThrow(error)
+    expect(() => all.getCurrent()).toThrow(error)
   })
 })

package/src/releases/releasesStore.ts

@@ -2,19 +2,11 @@ import {type ReleaseDocument} from '@sanity/client'
 import {map} from 'rxjs'
 
 import {type DocumentResource} from '../config/sanityConfig'
-/*
- * Although this is an import dependency cycle, it is not a logical cycle:
- * 1. releasesStore uses queryStore as a data source
- * 2. queryStore calls getPerspectiveState for computing release perspectives
- * 3. getPerspectiveState uses releasesStore as a data source
- * 4. however, queryStore does not use getPerspectiveState for the perspective used in releasesStore ("raw")
- */
-// eslint-disable-next-line import/no-cycle
-import {getQueryState} from '../query/queryStore'
 import {bindActionByResource, type BoundResourceKey} from '../store/createActionBinder'
 import {type SanityInstance} from '../store/createSanityInstance'
 import {createStateSourceAction, type StateSource} from '../store/createStateSourceAction'
 import {defineStore, type StoreContext} from '../store/defineStore'
+import {observeReleases} from './observeReleases'
 import {sortReleases} from './utils/sortReleases'
 
 const ARCHIVED_RELEASE_STATES = ['archived', 'published']
@@ -60,7 +52,10 @@ export const releasesStore = defineStore<ReleasesStoreState, BoundResourceKey>({
 const _getActiveReleasesState = bindActionByResource(
   releasesStore,
   createStateSourceAction({
-    selector: ({state}, _?) => state.activeReleases,
+    selector: ({state}) => {
+      if (state.error) throw state.error
+      return state.activeReleases
+    },
   }),
 )
 
@@ -82,7 +77,10 @@ export const getActiveReleasesState = (
 const _getAllReleasesState = bindActionByResource(
   releasesStore,
   createStateSourceAction({
-    selector: ({state}, _?) => state.allReleases,
+    selector: ({state}) => {
+      if (state.error) throw state.error
+      return state.allReleases
+    },
   }),
 )
 
@@ -95,32 +93,34 @@ export const getAllReleasesState = (
   options?: {resource?: DocumentResource},
 ): StateSource<ReleaseDocument[] | undefined> => _getAllReleasesState(instance, options ?? {})
 
-const RELEASES_QUERY = 'releases::all()'
-
 const subscribeToReleases = ({
   instance,
   state,
   key: {resource},
 }: StoreContext<ReleasesStoreState, BoundResourceKey>) => {
-  const {observable: releases$} = getQueryState<ReleaseDocument[]>(instance, {
-    query: RELEASES_QUERY,
-    perspective: 'raw',
+  const releases$ = observeReleases(instance, {
     resource,
-    tag: 'releases',
+    // Surface CORS errors as store state instead of erroring the stream so
+    // they can be handled by the Cors Error component
+    onCorsError: (error) => state.set('setError', {error}),
   })
-  return releases$
-    .pipe(
-      map((releases) => {
-        // logic here mirrors that of studio:
-        // https://github.com/sanity-io/sanity/blob/156e8fa482703d99219f08da7bacb384517f1513/packages/sanity/src/core/releases/store/useActiveReleases.ts#L29
-        const sorted = sortReleases(releases ?? STABLE_EMPTY_RELEASES).reverse()
-        state.set('setReleases', {
-          allReleases: sorted,
-          activeReleases: sorted.filter(
-            (release) => !ARCHIVED_RELEASE_STATES.includes(release.state),
-          ),
-        })
-      }),
-    )
-    .subscribe({error: (error) => state.set('setError', {error})})
+  return (
+    releases$
+      .pipe(
+        map((releases) => {
+          // logic here mirrors that of studio:
+          // https://github.com/sanity-io/sanity/blob/156e8fa482703d99219f08da7bacb384517f1513/packages/sanity/src/core/releases/store/useActiveReleases.ts#L29
+          const sorted = sortReleases(releases ?? STABLE_EMPTY_RELEASES).reverse()
+          state.set('setReleases', {
+            allReleases: sorted,
+            activeReleases: sorted.filter(
+              (release) => !ARCHIVED_RELEASE_STATES.includes(release.state),
+            ),
+          })
+        }),
+      )
+      // live-connection errors are already retried inside observeLiveEvents;
+      // a fetch error is terminal and surfaced via setError
+      .subscribe({error: (error) => state.set('setError', {error})})
+  )
 }