@sanity/sdk 3.0.0-rc.2 → 3.1.0

package/src/document/processMutations.ts

@@ -5,6 +5,7 @@ import {
   type SanityDocument,
 } from '@sanity/types'
 
+import {randomUuid} from '../utils/ids'
 import {
   dec,
   diffMatchPatch,
@@ -63,8 +64,8 @@ const patchOperations = {
  * [- source](https://www.sanity.io/docs/http-mutations#c732f27330a4)
  */
 export function getId(id?: string): string {
-  if (!id || typeof id !== 'string') return crypto.randomUUID()
-  if (id.endsWith('.')) return `${id}${crypto.randomUUID()}`
+  if (!id || typeof id !== 'string') return randomUuid()
+  if (id.endsWith('.')) return `${id}${randomUuid()}`
   return id
 }
 

package/src/document/reducers.test.ts

@@ -4,6 +4,7 @@ import {parse} from 'groq-js'
 import {Subject} from 'rxjs'
 import {describe, expect, it} from 'vitest'
 
+import {UNVERIFIED_REVISION_RETENTION_TIME} from './documentConstants'
 import {type DocumentEvent} from './events'
 import {type RemoteDocument} from './listen'
 import {type DocumentSet} from './processMutations'
@@ -556,6 +557,118 @@ describe('cleanupOutgoingTransaction', () => {
   })
 })
 
+describe('document state retention between ack and echo', () => {
+  const docId = 'doc1'
+  const justNow = new Date().toISOString()
+  const longAgo = new Date(Date.now() - UNVERIFIED_REVISION_RETENTION_TIME - 1000).toISOString()
+
+  const outgoing: NonNullable<SyncTransactionState['outgoing']> = {
+    transactionId: 'txnOut',
+    actions: [
+      {
+        type: 'document.edit',
+        documentId: docId,
+        documentType: 'book',
+        liveEdit: true,
+        patches: [{set: {foo: 'changed'}}],
+      },
+    ],
+    disableBatching: false,
+    batchedTransactionIds: ['txnOut'],
+    outgoingActions: [],
+    outgoingMutations: [],
+    base: {},
+    working: {},
+    previous: {},
+    previousRevs: {},
+    timestamp: justNow,
+  }
+
+  const unverifiedRevision = (timestamp: string) => ({
+    txnOut: {transactionId: 'txnOut', documentId: docId, previousRev: 'txn0', timestamp},
+  })
+
+  const stateAfterAck = (timestamp: string): SyncTransactionState => ({
+    queued: [],
+    applied: [],
+    outgoing,
+    grants,
+    documentStates: {
+      [docId]: {
+        id: docId,
+        // the UI unsubscribed before the ack arrived, so the transaction's
+        // own subscription id is the only one left
+        subscriptions: ['txnOut'],
+        local: {...exampleDoc, _id: docId, foo: 'changed'},
+        remote: {...exampleDoc, _id: docId, foo: 'old'},
+        unverifiedRevisions: unverifiedRevision(timestamp),
+        recentOwnTransactionIds: ['txnOut'],
+      },
+    },
+  })
+
+  it('keeps echo-recognition memory alive through cleanup so a late echo still labels "local"', () => {
+    // the HTTP ack arrives and cleans up the outgoing transaction's
+    // subscription. previously this deleted the whole DocumentState
+    // immediately, before the listener echo had a chance to arrive
+    const afterCleanup = cleanupOutgoingTransaction(stateAfterAck(justNow))
+    expect(afterCleanup.outgoing).toBeUndefined()
+
+    const docStateAfterCleanup = afterCleanup.documentStates[docId]
+    expect(docStateAfterCleanup).toBeDefined()
+    expect(docStateAfterCleanup?.subscriptions).toEqual([])
+    expect(docStateAfterCleanup?.unverifiedRevisions?.['txnOut']).toBeDefined()
+
+    // now the echo finally arrives over the shared listener
+    const events = new Subject<DocumentEvent>()
+    const received: DocumentEvent[] = []
+    events.subscribe((e) => received.push(e))
+
+    const echo: RemoteDocument = {
+      type: 'mutation',
+      documentId: docId,
+      document: {...exampleDoc, _id: docId, foo: 'changed'},
+      revision: 'txnOut',
+      previousRev: 'txn0',
+      timestamp: new Date().toISOString(),
+      mutations: [{patch: {id: docId, set: {foo: 'changed'}}}],
+    }
+
+    const afterEcho = applyRemoteDocument(afterCleanup, echo, events)
+
+    const remotePatchesEvents = received.filter((e) => e.type === 'remote-patches')
+    expect(remotePatchesEvents).toHaveLength(1)
+    expect(remotePatchesEvents[0]).toMatchObject({origin: 'local', transactionId: 'txnOut'})
+
+    // the echo verified the revision and nothing was subscribed any more, so
+    // the now fully-idle document state can finally be evicted
+    expect(afterEcho.documentStates[docId]).toBeUndefined()
+  })
+
+  it('stops waiting for an echo that is older than the retention time', () => {
+    // an accepted transaction whose operations all no-op server-side never
+    // produces an echo, so the wait has to expire or the document (and its
+    // listener) would be pinned for the lifetime of the store
+    const afterCleanup = cleanupOutgoingTransaction(stateAfterAck(longAgo))
+    expect(afterCleanup.documentStates[docId]).toBeUndefined()
+  })
+
+  it('does not extend the wait on `recentOwnTransactionIds` alone', () => {
+    const state = stateAfterAck(justNow)
+    const documentState = state.documentStates[docId]!
+    const withoutUnverifiedRevisions: SyncTransactionState = {
+      ...state,
+      documentStates: {
+        [docId]: {...documentState, unverifiedRevisions: {}, recentOwnTransactionIds: ['txnOut']},
+      },
+    }
+
+    expect(
+      cleanupOutgoingTransaction(withoutUnverifiedRevisions).documentStates[docId],
+    ).toBeUndefined()
+  })
+})
+
 describe('revertOutgoingTransaction', () => {
   it('reverts the outgoing transaction and updates documentStates by removing unverified revisions', () => {
     const draftId = getDraftId(DocumentId('doc1'))
@@ -686,6 +799,117 @@ describe('revertOutgoingTransaction', () => {
     // transaction id is gone from its subscriptions
     expect(newState.documentStates[pubId]?.subscriptions).toEqual(['sub-ui'])
   })
+
+  it('evicts a document left with no subscribers once its unverified revision is discarded', () => {
+    const docId = 'doc1'
+    const state: SyncTransactionState = {
+      queued: [],
+      applied: [],
+      outgoing: {
+        transactionId: 'txnOut',
+        actions: [
+          {
+            type: 'document.edit',
+            documentId: docId,
+            documentType: 'book',
+            liveEdit: true,
+            patches: [{set: {foo: 'changed'}}],
+          },
+        ],
+        disableBatching: false,
+        batchedTransactionIds: ['txnOut'],
+        outgoingActions: [],
+        outgoingMutations: [],
+        base: {},
+        working: {},
+        previous: {},
+        previousRevs: {},
+        timestamp: new Date().toISOString(),
+      },
+      grants,
+      documentStates: {
+        // the reverted transaction was this document's last subscriber, so the
+        // revision discarded below is the only thing keeping it around
+        [docId]: {
+          id: docId,
+          subscriptions: [],
+          local: {...exampleDoc, _id: docId, foo: 'changed'},
+          remote: {...exampleDoc, _id: docId, foo: 'old'},
+          unverifiedRevisions: {
+            txnOut: {
+              transactionId: 'txnOut',
+              documentId: docId,
+              previousRev: 'txn0',
+              timestamp: new Date().toISOString(),
+            },
+          },
+        },
+      },
+    }
+
+    expect(revertOutgoingTransaction(state).documentStates[docId]).toBeUndefined()
+  })
+
+  it('leaves `local` intact for a document still waiting on its own acked transaction', () => {
+    const revertedId = 'doc-reverted'
+    const retainedId = 'doc-retained'
+    const state: SyncTransactionState = {
+      queued: [],
+      applied: [],
+      outgoing: {
+        transactionId: 'txnOut',
+        actions: [
+          {
+            type: 'document.edit',
+            documentId: revertedId,
+            documentType: 'book',
+            liveEdit: true,
+            patches: [{set: {foo: 'changed'}}],
+          },
+        ],
+        disableBatching: false,
+        batchedTransactionIds: ['txnOut'],
+        outgoingActions: [],
+        outgoingMutations: [],
+        base: {},
+        working: {},
+        previous: {},
+        previousRevs: {},
+        timestamp: new Date().toISOString(),
+      },
+      grants,
+      documentStates: {
+        [revertedId]: {
+          id: revertedId,
+          subscriptions: ['txnOut'],
+          local: {...exampleDoc, _id: revertedId, foo: 'changed'},
+          remote: {...exampleDoc, _id: revertedId, foo: 'old'},
+        },
+        // unrelated to the reverted batch: acked, unsubscribed, and still
+        // waiting on the echo that will settle its optimistic value
+        [retainedId]: {
+          id: retainedId,
+          subscriptions: [],
+          local: {...exampleDoc, _id: retainedId, foo: 'acked'},
+          remote: {...exampleDoc, _id: retainedId, foo: 'old'},
+          unverifiedRevisions: {
+            txnAcked: {
+              transactionId: 'txnAcked',
+              documentId: retainedId,
+              previousRev: 'txn0',
+              timestamp: new Date().toISOString(),
+            },
+          },
+        },
+      },
+    }
+
+    const newState = revertOutgoingTransaction(state)
+    // the reverted document's only subscriber was the batch itself, so
+    // unregistering it evicts the state
+    expect(newState.documentStates[revertedId]).toBeUndefined()
+    expect(newState.documentStates[retainedId]?.local).toMatchObject({foo: 'acked'})
+  })
 })
 
 describe('applyRemoteDocument', () => {

package/src/document/reducers.ts

@@ -4,11 +4,11 @@ import {type Mutation, type PatchOperations, type SanityDocumentLike} from '@san
 import {type DocumentHandle} from '../config/sanityConfig'
 import {isReleasePerspective} from '../releases/utils/isReleasePerspective'
 import {type StoreContext} from '../store/defineStore'
-import {insecureRandomId} from '../utils/ids'
+import {randomId} from '../utils/ids'
 import {isDeepEqual, omitProperty} from '../utils/object'
 import {setCleanupTimeout} from '../utils/setCleanupTimeout'
 import {type Action} from './actions'
-import {DOCUMENT_STATE_CLEAR_DELAY} from './documentConstants'
+import {DOCUMENT_STATE_CLEAR_DELAY, UNVERIFIED_REVISION_RETENTION_TIME} from './documentConstants'
 import {type DocumentState, type DocumentStoreState} from './documentStore'
 import {type RemoteDocument} from './listen'
 import {ActionError, processActions} from './processActions/processActions'
@@ -401,7 +401,13 @@ export function cleanupOutgoingTransaction(prev: SyncTransactionState): SyncTran
     }
   }
 
-  return {...next, outgoing: undefined}
+  // every ack is also when a previously retained document's echo may have
+  // stopped being expected, so re-make that eviction decision here
+  return {
+    ...next,
+    outgoing: undefined,
+    documentStates: evictOrphanedDocumentStates(next.documentStates),
+  }
 }
 
 export function revertOutgoingTransaction(prev: SyncTransactionState): SyncTransactionState {
@@ -446,20 +452,38 @@ export function revertOutgoingTransaction(prev: SyncTransactionState): SyncTrans
     ...base,
     applied: nextApplied,
     outgoing: undefined,
-    documentStates: Object.fromEntries(
-      Object.entries(base.documentStates)
-        .filter((e): e is [string, DocumentState] => !!e[1])
-        .map(([documentId, {unverifiedRevisions = {}, local, ...documentState}]) => {
-          const next: DocumentState = {
-            ...documentState,
-            local: documentId in working ? working[documentId] : local,
-            unverifiedRevisions:
-              prev.outgoing && prev.outgoing.transactionId in unverifiedRevisions
-                ? omitProperty(unverifiedRevisions, prev.outgoing.transactionId)
-                : unverifiedRevisions,
-          }
-          return [documentId, next] as const
-        }),
+    // discarding the outgoing transaction drops its echo-recognition memory,
+    // which can leave a document that was only being kept alive for that echo
+    // with nothing left to wait for, so sweep afterwards
+    documentStates: evictOrphanedDocumentStates(
+      Object.fromEntries(
+        Object.entries(base.documentStates)
+          .filter((e): e is [string, DocumentState] => !!e[1])
+          .map(([documentId, documentState]) => {
+            const {unverifiedRevisions = {}} = documentState
+            const next: DocumentState = {
+              ...documentState,
+              unverifiedRevisions:
+                prev.outgoing && prev.outgoing.transactionId in unverifiedRevisions
+                  ? omitProperty(unverifiedRevisions, prev.outgoing.transactionId)
+                  : unverifiedRevisions,
+            }
+
+            // a document with no subscribers that is still waiting on the echo
+            // of a different, already acked transaction of its own is not
+            // represented in `working` (only `applied` transactions are
+            // re-applied above), so rebuilding its `local` from `remote` would
+            // drop that transaction's effect. leave it for the echo to resolve
+            if (!next.subscriptions.length && isAwaitingOwnEcho(next)) {
+              return [documentId, next] as const
+            }
+
+            return [
+              documentId,
+              {...next, local: documentId in working ? working[documentId] : next.local},
+            ] as const
+          }),
+      ),
     ),
   }
 }
@@ -579,7 +603,7 @@ export function applyRemoteDocument(
 
     return {
       ...prev,
-      documentStates: {
+      documentStates: evictOrphanedDocumentStates({
         ...prev.documentStates,
         [documentId]: {
           ...prevDocState,
@@ -588,7 +612,7 @@ export function applyRemoteDocument(
           local,
           unverifiedRevisions,
         },
-      },
+      }),
     }
   }
 
@@ -645,7 +669,7 @@ export function applyRemoteDocument(
   return {
     ...prev,
     applied: nextApplied,
-    documentStates: {
+    documentStates: evictOrphanedDocumentStates({
       ...prev.documentStates,
       [documentId]: {
         ...prevDocState,
@@ -654,7 +678,7 @@ export function applyRemoteDocument(
         local,
         unverifiedRevisions,
       },
-    },
+    }),
   }
 }
 
@@ -685,29 +709,88 @@ export function removeSubscriptionIdFromDocument(
   subscriptionId: string,
 ): SyncTransactionState {
   const prevDocState = prev.documentStates?.[documentId]
-  const prevSubscriptions = prevDocState?.subscriptions ?? []
-  const subscriptions = prevSubscriptions.filter((id) => id !== subscriptionId)
-
   if (!prevDocState) return prev
-  if (!subscriptions.length) {
+
+  const subscriptions = prevDocState.subscriptions.filter((id) => id !== subscriptionId)
+
+  // a document with no subscribers left is normally evicted below, but if a
+  // transaction was just submitted for it, its echo-recognition memory
+  // (`unverifiedRevisions`) is still waiting on the listener echo.
+  // `cleanupOutgoingTransaction` removes the outgoing transaction's own
+  // subscription right at HTTP ack, before the echo arrives, so deleting the
+  // state here would lose that memory and make the echo mislabel as
+  // `origin: 'remote'` (or, worse, get skipped outright). keep the state
+  // alive, unsubscribed, until the echo verifies or the wait expires
+  if (!subscriptions.length && !isAwaitingOwnEcho(prevDocState)) {
     return {...prev, documentStates: omitProperty(prev.documentStates, documentId)}
   }
+
   return {
     ...prev,
     documentStates: {
       ...prev.documentStates,
-      [documentId]: {...prevDocState, subscriptions: subscriptions},
+      [documentId]: {...prevDocState, subscriptions},
     },
   }
 }
 
+/**
+ * Whether this document still expects the listener echo of one of its own
+ * submitted transactions. That expectation is the only reason a document state
+ * with no subscribers is kept around.
+ *
+ * Revisions stop counting after `UNVERIFIED_REVISION_RETENTION_TIME` because an
+ * echo is not guaranteed to arrive at all: Content Lake records no transaction
+ * when every operation resolves to a no-op (e.g. a keyed path that no longer
+ * exists), while the client bumps `_rev` regardless and so tracks a revision
+ * for it. Without the expiry, such a document (and the listener keyed off its
+ * state) would be pinned for the lifetime of the store.
+ *
+ * `recentOwnTransactionIds` deliberately does not extend the wait: it is capped
+ * rather than drained, so honoring it would keep every edited document alive.
+ */
+function isAwaitingOwnEcho(documentState: DocumentState): boolean {
+  const expiresAfter = Date.now() - UNVERIFIED_REVISION_RETENTION_TIME
+  return Object.values(documentState.unverifiedRevisions ?? {}).some(
+    (revision) => !!revision && new Date(revision.timestamp).getTime() > expiresAfter,
+  )
+}
+
+/**
+ * Removes every document state that has no subscribers left and no own
+ * transaction still awaiting its echo.
+ *
+ * This is a sweep rather than a decision made where the last subscriber leaves
+ * because `removeSubscriptionIdFromDocument` defers that eviction while an echo
+ * is in flight, and both halves of the condition can change without a
+ * subscriber going anywhere: the echo can verify, be dropped by a sync, be
+ * discarded by a revert, or simply never arrive. Every reducer that can settle
+ * an in-flight transaction sweeps, so the deferred decision is always re-made.
+ *
+ * Note this can evict the very document whose remote event is being processed,
+ * which synchronously unsubscribes that document's listener from inside its own
+ * emission (see `subscribeToSubscriptionsAndListenToDocuments`).
+ */
+function evictOrphanedDocumentStates(
+  documentStates: SyncTransactionState['documentStates'],
+): SyncTransactionState['documentStates'] {
+  let next = documentStates
+  for (const [documentId, documentState] of Object.entries(documentStates)) {
+    if (!documentState) continue
+    if (documentState.subscriptions.length) continue
+    if (isAwaitingOwnEcho(documentState)) continue
+    next = omitProperty(next, documentId)
+  }
+  return next
+}
+
 export function manageSubscriberIds(
   {state}: StoreContext<SyncTransactionState>,
   handles: DocumentHandleLike[],
 ): () => void {
   const documentIds = getDocumentIdsFromHandleLikes(handles)
 
-  const subscriptionId = insecureRandomId()
+  const subscriptionId = randomId(16)
   state.set('addSubscribers', (prev) =>
     documentIds.reduce(
       (acc, id) => addSubscriptionIdToDocument(acc, id, subscriptionId),

package/src/favorites/favorites.test.ts

@@ -1,12 +1,12 @@
 import {type Node} from '@sanity/comlink'
-import {firstValueFrom, of, Subject} from 'rxjs'
+import {of, Subject} from 'rxjs'
 import {describe, expect, it, type Mock, vi} from 'vitest'
 
 import {getNodeState, type NodeState} from '../comlink/node/getNodeState'
 import {type FrameMessage, type WindowMessage} from '../comlink/types'
 import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
 import {type StateSource} from '../store/createStateSourceAction'
-import {getFavoritesState, resolveFavoritesState} from './favorites'
+import {favorites, setFavorite} from './favorites'
 
 vi.mock('../comlink/node/getNodeState', () => ({
   getNodeState: vi.fn(),
@@ -62,8 +62,8 @@ describe('favoritesStore', () => {
     it('creates different keys for different contexts with schema name', async () => {
       setupMockStateSource()
       // Make two fetches with different document IDs
-      await resolveFavoritesState(instance!, mockContext)
-      await resolveFavoritesState(instance!, {
+      await favorites.resolveState(instance!, mockContext)
+      await favorites.resolveState(instance!, {
         ...mockContext,
         documentId: 'different',
       })
@@ -79,8 +79,8 @@ describe('favoritesStore', () => {
     it('creates different keys for contexts without schema name', async () => {
       setupMockStateSource()
       // Make two fetches with different document IDs
-      await resolveFavoritesState(instance!, mockContextNoSchema)
-      await resolveFavoritesState(instance!, {
+      await favorites.resolveState(instance!, mockContextNoSchema)
+      await favorites.resolveState(instance!, {
         ...mockContextNoSchema,
         documentId: 'different',
       })
@@ -110,7 +110,7 @@ describe('favoritesStore', () => {
     it('fetches favorite status and handles success', async () => {
       const mockResponse = {isFavorited: true}
       setupMockStateSource({fetchImpl: vi.fn().mockResolvedValue(mockResponse)})
-      const result = await resolveFavoritesState(instance!, mockContext)
+      const result = await favorites.resolveState(instance!, mockContext)
       expect(result).toEqual(mockResponse)
       expect(mockFetch).toHaveBeenCalledWith('dashboard/v1/events/favorite/query', {
         document: {
@@ -128,7 +128,7 @@ describe('favoritesStore', () => {
     it('handles error and returns default response', async () => {
       const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
       setupMockStateSource({fetchImpl: vi.fn().mockRejectedValue(new Error('Failed to fetch'))})
-      const result = await resolveFavoritesState(instance!, mockContext)
+      const result = await favorites.resolveState(instance!, mockContext)
       expect(result).toEqual({isFavorited: false})
       expect(consoleErrorSpy).toHaveBeenCalledWith(
         'Favorites service connection error',
@@ -137,25 +137,19 @@ describe('favoritesStore', () => {
       consoleErrorSpy.mockRestore()
     })
 
-    it('shares observable between multiple subscribers and cleans up', async () => {
+    it('serves subsequent reads within staleTime from the cache', async () => {
       const mockResponse = {isFavorited: true}
       setupMockStateSource({fetchImpl: vi.fn().mockResolvedValue(mockResponse)})
-      const state = getFavoritesState(instance!, mockContext)
-      // First subscriber
-      const sub1 = state.subscribe()
-      await firstValueFrom(state.observable)
+      const first = await favorites.resolveState(instance!, mockContext)
+      expect(first).toEqual(mockResponse)
       expect(mockFetch).toHaveBeenCalledTimes(1)
-      // Second subscriber should use cached response
-      const state2 = getFavoritesState(instance!, mockContext)
-      const sub2 = state2.subscribe()
-      await firstValueFrom(state2.observable)
+      // Second read is fresh (within staleTime) — no second fetch
+      const second = await favorites.resolveState(instance!, mockContext)
+      expect(second).toEqual(mockResponse)
       expect(mockFetch).toHaveBeenCalledTimes(1)
-      // Cleanup
-      sub1()
-      sub2()
     })
 
-    it('reuses active fetch via createFetcherStore/shareReplay when called again while pending', async () => {
+    it('dedupes against the in-flight fetch when called again while pending', async () => {
       vi.useFakeTimers()
       let resolveFetch: (value: {isFavorited: boolean}) => void
       const fetchPromise = new Promise<{isFavorited: boolean}>((resolve) => {
@@ -175,13 +169,15 @@ describe('favoritesStore', () => {
       } as unknown as StateSource<NodeState>
       vi.mocked(getNodeState).mockReturnValue(mockStateSource)
       // Call 1: Triggers the actual fetch
-      const promise1 = resolveFavoritesState(instance!, mockContext)
+      const promise1 = favorites.resolveState(instance!, mockContext)
+      // Let the deferred fetch start and subscribe to the node state
+      await vi.advanceTimersByTimeAsync(1)
       // Simulate node becoming connected
       subject.next({node: mockNode, status: 'connected'})
       await vi.advanceTimersByTimeAsync(1)
       expect(fetchSpy).toHaveBeenCalledTimes(1)
-      // Call 2: Should reuse the pending fetch via createFetcherStore/shareReplay
-      const promise2 = resolveFavoritesState(instance!, mockContext)
+      // Call 2: Should reuse the pending fetch
+      const promise2 = favorites.resolveState(instance!, mockContext)
       await vi.advanceTimersByTimeAsync(1)
       expect(fetchSpy).toHaveBeenCalledTimes(1)
       // Resolve the underlying fetch
@@ -195,4 +191,48 @@ describe('favoritesStore', () => {
       vi.useRealTimers()
     })
   })
+
+  describe('setFavorite', () => {
+    beforeEach(() => {
+      vi.resetAllMocks()
+      instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+      setupMockStateSource({fetchImpl: vi.fn().mockResolvedValue({success: true})})
+    })
+
+    afterEach(() => {
+      instance?.dispose()
+    })
+
+    it('sends the added event with schemaName and resolves to the new state', async () => {
+      const result = await setFavorite(instance!, {...mockContext, isFavorited: true})
+      expect(result.data).toEqual({isFavorited: true})
+      expect(mockFetch).toHaveBeenCalledWith('dashboard/v1/events/favorite/mutate', {
+        eventType: 'added',
+        document: {
+          id: mockContext.documentId,
+          type: mockContext.documentType,
+          resource: {
+            id: mockContext.resourceId,
+            type: mockContext.resourceType,
+            schemaName: mockContext.schemaName,
+          },
+        },
+      })
+    })
+
+    it('sends the removed event and omits schemaName when absent', async () => {
+      const result = await setFavorite(instance!, {...mockContextNoSchema, isFavorited: false})
+      expect(result.data).toEqual({isFavorited: false})
+      const payload = mockFetch.mock.calls[0][1]
+      expect(payload.eventType).toBe('removed')
+      expect(payload.document.resource).not.toHaveProperty('schemaName')
+    })
+
+    it('rejects when the server reports failure', async () => {
+      setupMockStateSource({fetchImpl: vi.fn().mockResolvedValue({success: false})})
+      await expect(setFavorite(instance!, {...mockContext, isFavorited: true})).rejects.toThrow(
+        'Failed to update favorite status',
+      )
+    })
+  })
 })