@sanity/sdk 2.11.0 → 2.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/sdk",
-  "version": "2.11.0",
+  "version": "2.12.0",
   "private": false,
   "description": "Sanity SDK",
   "keywords": [
@@ -48,41 +48,41 @@
   "browserslist": "extends @sanity/browserslist-config",
   "prettier": "@sanity/prettier-config",
   "dependencies": {
-    "@sanity/bifur-client": "^0.4.1",
+    "@sanity/bifur-client": "^1.0.0",
     "@sanity/client": "^7.22.0",
-    "@sanity/comlink": "^3.1.1",
+    "@sanity/comlink": "^4.0.1",
     "@sanity/diff-match-patch": "^3.2.0",
     "@sanity/diff-patch": "^6.0.0",
     "@sanity/id-utils": "^1.0.0",
-    "@sanity/image-url": "^2.0.3",
+    "@sanity/image-url": "^2.1.1",
     "@sanity/json-match": "^1.0.5",
     "@sanity/message-protocol": "^0.23.0",
     "@sanity/mutate": "^0.16.1",
     "@sanity/telemetry": "^1.1.0",
-    "@sanity/types": "^5.2.0",
+    "@sanity/types": "^5.26.0",
     "groq": "3.88.1-typegen-experimental.0",
     "groq-js": "^1.30.1",
     "reselect": "^5.1.1",
     "rxjs": "^7.8.2",
-    "zustand": "^5.0.12"
+    "zustand": "^5.0.13"
   },
   "devDependencies": {
     "@sanity/browserslist-config": "^1.0.5",
     "@sanity/pkg-utils": "^8.1.29",
     "@sanity/prettier-config": "^1.0.6",
-    "@types/node": "^22.19.1",
-    "@vitest/coverage-v8": "4.1.5",
-    "eslint": "^9.22.0",
-    "prettier": "^3.7.3",
+    "@types/node": "^24.12.4",
+    "@vitest/coverage-v8": "4.1.6",
+    "eslint": "^9.39.4",
+    "prettier": "^3.8.3",
     "rollup-plugin-visualizer": "^5.14.0",
-    "typescript": "^5.8.3",
-    "vite": "^7.0.0",
-    "vitest": "^4.1.4",
-    "@repo/config-eslint": "0.0.0",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.3",
+    "vitest": "^4.1.6",
     "@repo/package.bundle": "3.82.0",
-    "@repo/config-test": "0.0.1",
     "@repo/package.config": "0.0.1",
-    "@repo/tsconfig": "0.0.1"
+    "@repo/tsconfig": "0.0.1",
+    "@repo/config-test": "0.0.1",
+    "@repo/config-eslint": "0.0.0"
   },
   "publishConfig": {
     "access": "public"

package/src/_exports/index.ts

@@ -105,6 +105,7 @@ export {
   type MediaLibrarySource,
   type PerspectiveHandle,
   type ProjectHandle,
+  type ReleaseHandle,
   type ReleasePerspective,
   type SanityConfig,
   type StudioConfig,
@@ -112,19 +113,37 @@ export {
 } from '../config/sanityConfig'
 export {getDatasetsState, resolveDatasets} from '../datasets/datasets'
 export {
+  type Action,
+  archiveRelease,
+  type ArchiveReleaseAction,
   createDocument,
   type CreateDocumentAction,
+  createRelease,
+  type CreateReleaseAction,
   deleteDocument,
   type DeleteDocumentAction,
+  deleteRelease,
+  type DeleteReleaseAction,
   discardDocument,
   type DiscardDocumentAction,
   type DocumentAction,
   editDocument,
   type EditDocumentAction,
+  editRelease,
+  type EditReleaseAction,
   publishDocument,
   type PublishDocumentAction,
+  publishRelease,
+  type PublishReleaseAction,
+  type ReleaseAction,
+  scheduleRelease,
+  type ScheduleReleaseAction,
+  unarchiveRelease,
+  type UnarchiveReleaseAction,
   unpublishDocument,
   type UnpublishDocumentAction,
+  unscheduleRelease,
+  type UnscheduleReleaseAction,
 } from '../document/actions'
 export {
   type ActionsResult,
@@ -155,6 +174,7 @@ export {
 } from '../document/events'
 export {type JsonMatch} from '../document/patchOperations'
 export {type DocumentPermissionsResult, type PermissionDeniedReason} from '../document/permissions'
+export {getReleaseDocumentId} from '../document/processActions/releaseUtil'
 export type {FavoriteStatusResponse} from '../favorites/favorites'
 export {getFavoritesState, resolveFavoritesState} from '../favorites/favorites'
 export {
@@ -214,8 +234,8 @@ export {
   resolveQuery,
 } from '../query/queryStore'
 export {getPerspectiveState} from '../releases/getPerspectiveState'
-export type {ReleaseDocument} from '../releases/releasesStore'
-export {getActiveReleasesState} from '../releases/releasesStore'
+export type {ReleaseState} from '../releases/releasesStore'
+export {getActiveReleasesState, getAllReleasesState} from '../releases/releasesStore'
 export {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
 export {type Selector, type StateSource} from '../store/createStateSourceAction'
 export {getUsersKey, parseUsersKey} from '../users/reducers'
@@ -244,6 +264,7 @@ export {defineIntent, type Intent, type IntentFilter} from '../utils/defineInten
 export {getCorsErrorProjectId} from '../utils/getCorsErrorProjectId'
 export {isImportError} from '../utils/isImportError'
 export {CORE_SDK_VERSION} from '../version'
+export type {ReleaseDocument} from '@sanity/client'
 export {
   getIndexForKey,
   getPathDepth,

package/src/auth/refreshStampedToken.test.ts

@@ -59,8 +59,8 @@ describe('refreshStampedToken', () => {
       request: vi.fn(
         async (
           _name: string,
-          _options: LockOptions | LockGrantedCallback,
-          callback?: LockGrantedCallback,
+          _options: LockOptions | LockGrantedCallback<unknown>,
+          callback?: LockGrantedCallback<unknown>,
         ) => {
           const actualCallback = typeof _options === 'function' ? _options : callback
           if (!actualCallback) return false

package/src/auth/subscribeToStateAndFetchCurrentUser.test.ts

@@ -112,4 +112,120 @@ describe('subscribeToStateAndFetchCurrentUser', () => {
 
     subscription.unsubscribe()
   })
+
+  it('recovers from a fetch error when a new token is set', () => {
+    const error = new Error('Unauthorized')
+    const mockUser = {id: 'recovered-user'} as CurrentUser
+    const mockRequest = vi
+      .fn()
+      .mockReturnValueOnce(throwError(() => error))
+      .mockReturnValueOnce(of(mockUser))
+    const mockClient = {observable: {request: mockRequest}}
+    const clientFactory = vi.fn().mockReturnValue(mockClient)
+    const instance = createSanityInstance({projectId: 'p', dataset: 'd', auth: {clientFactory}})
+
+    const state = createStoreState(authStore.getInitialState(instance, null))
+    const subscription = subscribeToStateAndFetchCurrentUser({state, instance, key: null})
+
+    // First token causes a 401 — state should transition to ERROR
+    state.set('setLoggedIn', {
+      authState: {type: AuthStateType.LOGGED_IN, token: 'expired-token', currentUser: null},
+    })
+    expect(state.get()).toMatchObject({authState: {type: AuthStateType.ERROR, error}})
+
+    // Simulate comlink providing a fresh token (setAuthToken sets LOGGED_IN with new token)
+    state.set('setNewToken', {
+      authState: {type: AuthStateType.LOGGED_IN, token: 'fresh-token', currentUser: null},
+    })
+
+    // Subscription should still be alive — re-fetches /users/me with the new token
+    expect(state.get()).toMatchObject({
+      authState: {type: AuthStateType.LOGGED_IN, token: 'fresh-token', currentUser: mockUser},
+    })
+    expect(mockRequest).toHaveBeenCalledTimes(2)
+
+    subscription.unsubscribe()
+  })
+
+  it('recovers from multiple consecutive fetch errors', () => {
+    const error1 = new Error('Unauthorized')
+    const error2 = new Error('Unauthorized again')
+    const mockUser = {id: 'finally-recovered'} as CurrentUser
+    const mockRequest = vi
+      .fn()
+      .mockReturnValueOnce(throwError(() => error1))
+      .mockReturnValueOnce(throwError(() => error2))
+      .mockReturnValueOnce(of(mockUser))
+    const mockClient = {observable: {request: mockRequest}}
+    const clientFactory = vi.fn().mockReturnValue(mockClient)
+    const instance = createSanityInstance({projectId: 'p', dataset: 'd', auth: {clientFactory}})
+
+    const state = createStoreState(authStore.getInitialState(instance, null))
+    const subscription = subscribeToStateAndFetchCurrentUser({state, instance, key: null})
+
+    // First attempt fails
+    state.set('setLoggedIn', {
+      authState: {type: AuthStateType.LOGGED_IN, token: 'token-1', currentUser: null},
+    })
+    expect(state.get()).toMatchObject({authState: {type: AuthStateType.ERROR, error: error1}})
+
+    // Second attempt also fails
+    state.set('setNewToken', {
+      authState: {type: AuthStateType.LOGGED_IN, token: 'token-2', currentUser: null},
+    })
+    expect(state.get()).toMatchObject({authState: {type: AuthStateType.ERROR, error: error2}})
+
+    // Third attempt succeeds
+    state.set('setNewToken', {
+      authState: {type: AuthStateType.LOGGED_IN, token: 'token-3', currentUser: null},
+    })
+    expect(state.get()).toMatchObject({
+      authState: {type: AuthStateType.LOGGED_IN, token: 'token-3', currentUser: mockUser},
+    })
+    expect(mockRequest).toHaveBeenCalledTimes(3)
+
+    subscription.unsubscribe()
+  })
+
+  it('does not re-fetch with the same token but recovers with a different token', () => {
+    const error = new Error('Unauthorized')
+    const mockUser = {id: 'recovered-user'} as CurrentUser
+    const mockRequest = vi
+      .fn()
+      .mockReturnValueOnce(throwError(() => error))
+      .mockReturnValueOnce(of(mockUser))
+    const mockClient = {observable: {request: mockRequest}}
+    const clientFactory = vi.fn().mockReturnValue(mockClient)
+    const instance = createSanityInstance({projectId: 'p', dataset: 'd', auth: {clientFactory}})
+
+    const state = createStoreState(authStore.getInitialState(instance, null))
+    const subscription = subscribeToStateAndFetchCurrentUser({state, instance, key: null})
+
+    // First attempt fails
+    state.set('setLoggedIn', {
+      authState: {type: AuthStateType.LOGGED_IN, token: 'same-token', currentUser: null},
+    })
+    expect(state.get()).toMatchObject({authState: {type: AuthStateType.ERROR, error}})
+
+    // Same token should be blocked by distinctUntilChanged — no re-fetch
+    state.set('setNewToken', {
+      authState: {type: AuthStateType.LOGGED_IN, token: 'same-token', currentUser: null},
+    })
+    expect(mockRequest).toHaveBeenCalledTimes(1)
+
+    // A different token should pass distinctUntilChanged and trigger recovery
+    state.set('setNewToken', {
+      authState: {type: AuthStateType.LOGGED_IN, token: 'different-token', currentUser: null},
+    })
+    expect(state.get()).toMatchObject({
+      authState: {
+        type: AuthStateType.LOGGED_IN,
+        token: 'different-token',
+        currentUser: mockUser,
+      },
+    })
+    expect(mockRequest).toHaveBeenCalledTimes(2)
+
+    subscription.unsubscribe()
+  })
 })

package/src/auth/subscribeToStateAndFetchCurrentUser.ts

@@ -1,5 +1,13 @@
 import {type CurrentUser} from '@sanity/types'
-import {distinctUntilChanged, filter, map, type Subscription, switchMap} from 'rxjs'
+import {
+  catchError,
+  distinctUntilChanged,
+  EMPTY,
+  filter,
+  map,
+  type Subscription,
+  switchMap,
+} from 'rxjs'
 
 import {type StoreContext} from '../store/defineStore'
 import {DEFAULT_API_VERSION, REQUEST_TAG_PREFIX} from './authConstants'
@@ -60,11 +68,24 @@ export const subscribeToStateAndFetchCurrentUser = (
         }),
       ),
       switchMap((client) =>
-        client.observable.request<CurrentUser>({
-          uri: '/users/me',
-          method: 'GET',
-          tag: 'users.get-current',
-        }),
+        client.observable
+          .request<CurrentUser>({
+            uri: '/users/me',
+            method: 'GET',
+            tag: 'users.get-current',
+          })
+          .pipe(
+            /**
+             * Catch inside switchMap so the outer subscription survives.
+             * Without this, a 401 terminates the subscription permanently
+             * and subsequent token refreshes via comlink never re-fetch /users/me.
+             * @see SDK-1409
+             */
+            catchError((error) => {
+              state.set('setError', {authState: {type: AuthStateType.ERROR, error}})
+              return EMPTY
+            }),
+          ),
       ),
     )
 
@@ -77,8 +98,5 @@ export const subscribeToStateAndFetchCurrentUser = (
             : prev.authState,
       }))
     },
-    error: (error) => {
-      state.set('setError', {authState: {type: AuthStateType.ERROR, error}})
-    },
   })
 }

package/src/config/sanityConfig.ts

@@ -118,6 +118,18 @@ export interface DocumentHandle<
   documentId: string
 }
 
+/**
+ * Identifies a release within a Sanity dataset and project. `releaseId` is the
+ * `name` parameter on the release document (e.g. `{name: 'r41035a4'}`).
+ * The underlying release document ID is `_.releases.<releaseId>`.
+ * It's also the `id` parameter sent to the Actions API.
+ * (This type doesn't need to have ProjectId / Dataset generics since it's always the same shape)
+ * @beta
+ */
+export interface ReleaseHandle extends DatasetHandle {
+  releaseId: string
+}
+
 /**
  * Represents the complete configuration for a Sanity SDK instance
  * @public

package/src/document/actions.test.ts

@@ -1,15 +1,24 @@
+import {type ReleaseDocument} from '@sanity/client'
 import {at, patch, set, setIfMissing} from '@sanity/mutate'
 import {type PatchOperations} from '@sanity/types'
 import {describe, expect, it} from 'vitest'
 
-import {type DocumentHandle} from '../config/sanityConfig'
+import {type DocumentHandle, type ReleaseHandle} from '../config/sanityConfig'
 import {
+  archiveRelease,
   createDocument,
+  createRelease,
   deleteDocument,
+  deleteRelease,
   discardDocument,
   editDocument,
+  editRelease,
   publishDocument,
+  publishRelease,
+  scheduleRelease,
+  unarchiveRelease,
   unpublishDocument,
+  unscheduleRelease,
 } from '../document/actions'
 
 const dummyPatch: PatchOperations = {
@@ -19,6 +28,9 @@ const dummyPatch: PatchOperations = {
 const dummyDocHandle: DocumentHandle = {documentId: 'drafts.abc123', documentType: 'testType'}
 const dummyDocString = {documentId: 'drafts.abc123', documentType: 'testType'}
 
+const dummyReleaseHandle: ReleaseHandle = {releaseId: 'my-release'}
+const dummyReleasePatch: PatchOperations = {set: {'metadata.title': 'Updated title'}}
+
 describe('document actions', () => {
   describe('createDocument', () => {
     it('creates a document action from a document handle', () => {
@@ -207,3 +219,102 @@ describe('document actions', () => {
     })
   })
 })
+
+describe('release actions', () => {
+  describe('createRelease', () => {
+    it('creates a release action from a release handle', () => {
+      const action = createRelease(dummyReleaseHandle)
+      expect(action).toEqual({
+        type: 'release.create',
+        releaseId: 'my-release',
+        metadata: {releaseType: 'undecided'},
+      })
+    })
+
+    it('creates a release action with metadata', () => {
+      const metadata: ReleaseDocument['metadata'] = {
+        title: 'My release',
+        description: 'Some description',
+        releaseType: 'scheduled',
+        intendedPublishAt: '2026-01-01T00:00:00.000Z',
+      }
+      const action = createRelease(dummyReleaseHandle, metadata)
+      expect(action).toEqual({
+        type: 'release.create',
+        releaseId: 'my-release',
+        metadata,
+      })
+    })
+
+    it('preserves resource fields from the handle', () => {
+      const action = createRelease({
+        releaseId: 'my-release',
+        resource: {dataset: 'production', projectId: 'abc123'},
+      })
+      expect(action).toEqual({
+        type: 'release.create',
+        releaseId: 'my-release',
+        resource: {dataset: 'production', projectId: 'abc123'},
+        metadata: {releaseType: 'undecided'},
+      })
+    })
+  })
+
+  describe('editRelease', () => {
+    it('creates a release.edit action with a patch', () => {
+      const action = editRelease(dummyReleaseHandle, dummyReleasePatch)
+      expect(action).toEqual({
+        type: 'release.edit',
+        releaseId: 'my-release',
+        patch: dummyReleasePatch,
+      })
+    })
+  })
+
+  describe('publishRelease', () => {
+    it('creates a release.publish action from a release handle', () => {
+      const action = publishRelease(dummyReleaseHandle)
+      expect(action).toEqual({type: 'release.publish', releaseId: 'my-release'})
+    })
+  })
+
+  describe('scheduleRelease', () => {
+    it('creates a release.schedule action with publishAt', () => {
+      const publishAt = '2026-01-01T00:00:00.000Z'
+      const action = scheduleRelease(dummyReleaseHandle, publishAt)
+      expect(action).toEqual({
+        type: 'release.schedule',
+        releaseId: 'my-release',
+        publishAt,
+      })
+    })
+  })
+
+  describe('unscheduleRelease', () => {
+    it('creates a release.unschedule action from a release handle', () => {
+      const action = unscheduleRelease(dummyReleaseHandle)
+      expect(action).toEqual({type: 'release.unschedule', releaseId: 'my-release'})
+    })
+  })
+
+  describe('archiveRelease', () => {
+    it('creates a release.archive action from a release handle', () => {
+      const action = archiveRelease(dummyReleaseHandle)
+      expect(action).toEqual({type: 'release.archive', releaseId: 'my-release'})
+    })
+  })
+
+  describe('unarchiveRelease', () => {
+    it('creates a release.unarchive action from a release handle', () => {
+      const action = unarchiveRelease(dummyReleaseHandle)
+      expect(action).toEqual({type: 'release.unarchive', releaseId: 'my-release'})
+    })
+  })
+
+  describe('deleteRelease', () => {
+    it('creates a release.delete action from a release handle', () => {
+      const action = deleteRelease(dummyReleaseHandle)
+      expect(action).toEqual({type: 'release.delete', releaseId: 'my-release'})
+    })
+  })
+})

package/src/document/actions.ts

@@ -1,9 +1,14 @@
+import {type ReleaseDocument} from '@sanity/client'
 import {SanityEncoder} from '@sanity/mutate'
 import {type PatchMutation as SanityMutatePatchMutation} from '@sanity/mutate/_unstable_store'
 import {type PatchMutation, type PatchOperations} from '@sanity/types'
 import {type SanityDocument} from 'groq'
 
-import {type DocumentHandle, type DocumentTypeHandle} from '../config/sanityConfig'
+import {
+  type DocumentHandle,
+  type DocumentTypeHandle,
+  type ReleaseHandle,
+} from '../config/sanityConfig'
 import {getEffectiveDocumentId} from './util'
 
 const isSanityMutatePatch = (value: unknown): value is SanityMutatePatchMutation => {
@@ -120,6 +125,17 @@ export type DocumentAction<
   | UnpublishDocumentAction<TDocumentType, TDataset, TProjectId>
   | DiscardDocumentAction<TDocumentType, TDataset, TProjectId>
 
+/**
+ * Union of every action accepted by `applyDocumentActions` — both document-
+ * level actions and release-lifecycle actions.
+ * @beta
+ */
+export type Action<
+  TDocumentType extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+> = DocumentAction<TDocumentType, TDataset, TProjectId> | ReleaseAction
+
 /**
  * Creates a `CreateDocumentAction` object.
  * @param doc - A handle identifying the document type, dataset, and project. An optional `documentId` can be provided.
@@ -316,3 +332,134 @@ export function discardDocument<
     documentId: effectiveDocumentId,
   }
 }
+
+/**
+ * Creates a new release. The `releaseId` must be unique within the current
+ * retention period.
+ * @beta
+ */
+export interface CreateReleaseAction extends ReleaseHandle {
+  type: 'release.create'
+  metadata: ReleaseDocument['metadata']
+}
+
+/**
+ * Patches the metadata of an existing release.
+ * @beta
+ */
+export interface EditReleaseAction extends ReleaseHandle {
+  type: 'release.edit'
+  patch: PatchOperations
+}
+
+/**
+ * Publishes all version documents in a release.
+ * @beta
+ */
+export interface PublishReleaseAction extends ReleaseHandle {
+  type: 'release.publish'
+}
+
+/**
+ * Schedules a release to be published at the given UTC time. Locks the
+ * version documents server-side until the release is unscheduled or published.
+ * @beta
+ */
+export interface ScheduleReleaseAction extends ReleaseHandle {
+  type: 'release.schedule'
+  publishAt: string
+}
+
+/**
+ * Unschedules a release that was previously scheduled, returning it to the
+ * active editable state.
+ * @beta
+ */
+export interface UnscheduleReleaseAction extends ReleaseHandle {
+  type: 'release.unschedule'
+}
+
+/**
+ * Archives an active release. Version documents within the release are
+ * removed and no longer queryable, though still recoverable through history
+ * during the retention period.
+ * @beta
+ */
+export interface ArchiveReleaseAction extends ReleaseHandle {
+  type: 'release.archive'
+}
+
+/**
+ * Restores an archived release. Only possible during the retention period.
+ * @beta
+ */
+export interface UnarchiveReleaseAction extends ReleaseHandle {
+  type: 'release.unarchive'
+}
+
+/**
+ * Permanently deletes an archived or published release. To remove an active
+ * release, use the archive action first.
+ * @beta
+ */
+export interface DeleteReleaseAction extends ReleaseHandle {
+  type: 'release.delete'
+}
+
+/**
+ * Union of all release actions that can be dispatched alongside document
+ * actions through `applyDocumentActions`.
+ * @beta
+ */
+export type ReleaseAction =
+  | CreateReleaseAction
+  | EditReleaseAction
+  | PublishReleaseAction
+  | ScheduleReleaseAction
+  | UnscheduleReleaseAction
+  | ArchiveReleaseAction
+  | UnarchiveReleaseAction
+  | DeleteReleaseAction
+
+/** @beta */
+export function createRelease(
+  handle: ReleaseHandle,
+  metadata: ReleaseDocument['metadata'] = {releaseType: 'undecided'},
+): CreateReleaseAction {
+  return {type: 'release.create', ...handle, metadata}
+}
+
+/** @beta */
+export function editRelease(handle: ReleaseHandle, patch: PatchOperations): EditReleaseAction {
+  return {type: 'release.edit', ...handle, patch}
+}
+
+/** @beta */
+export function publishRelease(handle: ReleaseHandle): PublishReleaseAction {
+  return {type: 'release.publish', ...handle}
+}
+
+/** @beta */
+export function scheduleRelease(handle: ReleaseHandle, publishAt: string): ScheduleReleaseAction {
+  return {type: 'release.schedule', ...handle, publishAt}
+}
+
+/** @beta */
+export function unscheduleRelease(handle: ReleaseHandle): UnscheduleReleaseAction {
+  return {type: 'release.unschedule', ...handle}
+}
+
+/** @beta */
+export function archiveRelease(handle: ReleaseHandle): ArchiveReleaseAction {
+  return {type: 'release.archive', ...handle}
+}
+
+/** @beta */
+export function unarchiveRelease(handle: ReleaseHandle): UnarchiveReleaseAction {
+  return {type: 'release.unarchive', ...handle}
+}
+
+/** @beta */
+export function deleteRelease(handle: ReleaseHandle): DeleteReleaseAction {
+  return {type: 'release.delete', ...handle}
+}

package/src/document/applyDocumentActions.ts

@@ -5,7 +5,7 @@ import {type DocumentResource} from '../config/sanityConfig'
 import {bindActionByResource} from '../store/createActionBinder'
 import {type SanityInstance} from '../store/createSanityInstance'
 import {type StoreContext} from '../store/defineStore'
-import {type DocumentAction} from './actions'
+import {type Action} from './actions'
 import {documentStore, type DocumentStoreState} from './documentStore'
 import {type DocumentTransactionSubmissionResult} from './events'
 import {type DocumentSet} from './processMutations'
@@ -26,9 +26,10 @@ export interface ActionsResult<TDocument extends SanityDocument = SanityDocument
 /** @beta */
 export interface ApplyDocumentActionsOptions {
   /**
-   * List of actions to apply.
+   * List of actions to apply. Accepts both document actions and release
+   * lifecycle actions because they share the same transaction pipeline.
    */
-  actions: DocumentAction[]
+  actions: Action[]
 
   /**
    * The resource to which the documents being acted on belong.