@sanity/sdk 3.0.0-rc.0 → 3.0.0-rc.1

package/src/document/reducers.test.ts

@@ -1,9 +1,9 @@
+import {DocumentId, getDraftId, getPublishedId} from '@sanity/id-utils'
 import {type SanityDocument} from '@sanity/types'
 import {parse} from 'groq-js'
 import {Subject} from 'rxjs'
 import {describe, expect, it} from 'vitest'
 
-import {getDraftId, getPublishedId} from '../utils/ids'
 import {type DocumentEvent} from './events'
 import {type RemoteDocument} from './listen'
 import {type DocumentSet} from './processMutations'
@@ -56,7 +56,6 @@ describe('queueTransaction', () => {
           documentId: 'doc1',
           documentType: 'book',
           patches: [{set: {foo: 'bar'}}],
-          resource: {projectId: 'p', dataset: 'd'},
         },
       ],
     }
@@ -67,8 +66,8 @@ describe('queueTransaction', () => {
     expect(newState.queued[0]).toEqual(transaction)
 
     // Check that both the published and draft documentStates got a subscription id added.
-    const draftId = getDraftId('doc1')
-    const pubId = getPublishedId('doc1')
+    const draftId = getDraftId(DocumentId('doc1'))
+    const pubId = getPublishedId(DocumentId('doc1'))
     expect(newState.documentStates[draftId]).toBeDefined()
     expect(newState.documentStates[pubId]).toBeDefined()
     expect(newState.documentStates[draftId]?.subscriptions).toContain('txn1')
@@ -78,8 +77,8 @@ describe('queueTransaction', () => {
 
 describe('removeQueuedTransaction', () => {
   it('removes the transaction from queued and removes subscription ids from documents', () => {
-    const draftId = getDraftId('doc1')
-    const pubId = getPublishedId('doc1')
+    const draftId = getDraftId(DocumentId('doc1'))
+    const pubId = getPublishedId(DocumentId('doc1'))
 
     const initialState: SyncTransactionState = {
       queued: [
@@ -91,7 +90,6 @@ describe('removeQueuedTransaction', () => {
               documentId: 'doc1',
               documentType: 'book',
               patches: [{set: {foo: 'bar'}}],
-              resource: {projectId: 'p', dataset: 'd'},
             },
           ],
         },
@@ -100,8 +98,8 @@ describe('removeQueuedTransaction', () => {
       outgoing: undefined,
       grants,
       documentStates: {
-        [draftId]: {id: draftId, subscriptions: ['txn1'], local: {}},
-        [pubId]: {id: pubId, subscriptions: ['txn1'], local: {}},
+        [draftId]: {id: draftId, subscriptions: ['txn1']},
+        [pubId]: {id: pubId, subscriptions: ['txn1']},
       } as SyncTransactionState['documentStates'],
     }
 
@@ -140,19 +138,12 @@ describe('applyFirstQueuedTransaction', () => {
 
   it('returns unchanged state if any required document is not yet loaded', () => {
     // If a document's local value is undefined, the reducer should do nothing.
-    const draftId = getDraftId('doc1')
+    const draftId = getDraftId(DocumentId('doc1'))
     const state: SyncTransactionState = {
       queued: [
         {
           transactionId: 'txn2',
-          actions: [
-            {
-              type: 'document.discard',
-              documentId: 'doc1',
-              documentType: 'book',
-              resource: {projectId: 'p', dataset: 'd'},
-            },
-          ],
+          actions: [{type: 'document.discard', documentId: 'doc1', documentType: 'book'}],
         },
       ],
       applied: [],
@@ -171,14 +162,7 @@ describe('applyFirstQueuedTransaction', () => {
       queued: [
         {
           transactionId: 'txn-missing-grants',
-          actions: [
-            {
-              type: 'document.discard',
-              documentId: 'doc1',
-              documentType: 'book',
-              resource: {projectId: 'p', dataset: 'd'},
-            },
-          ],
+          actions: [{type: 'document.discard', documentId: 'doc1', documentType: 'book'}],
         },
       ],
       applied: [],
@@ -192,8 +176,8 @@ describe('applyFirstQueuedTransaction', () => {
 
   it('applies the first queued transaction (using a discard action)', () => {
     // For a discard action, processActions deletes the draft document.
-    const draftId = getDraftId('doc1')
-    const pubId = getPublishedId('doc1')
+    const draftId = getDraftId(DocumentId('doc1'))
+    const pubId = getPublishedId(DocumentId('doc1'))
     const initialDraft = {...exampleDoc, _id: draftId, foo: 'bar', _rev: 'rev1'}
     const initialPub = {...exampleDoc, _id: pubId, foo: 'bar', _rev: 'rev1'}
 
@@ -201,14 +185,7 @@ describe('applyFirstQueuedTransaction', () => {
       queued: [
         {
           transactionId: 'txn3',
-          actions: [
-            {
-              type: 'document.discard',
-              documentId: 'doc1',
-              documentType: 'book',
-              resource: {projectId: 'p', dataset: 'd'},
-            },
-          ],
+          actions: [{type: 'document.discard', documentId: 'doc1', documentType: 'book'}],
         },
       ],
       applied: [],
@@ -247,31 +224,37 @@ describe('batchAppliedTransactions', () => {
           documentId: 'doc1',
           documentType: 'book',
           patches: [{set: {foo: 'a'}}],
-          resource: {projectId: 'p', dataset: 'd'},
         },
         {
           type: 'document.edit',
           documentId: 'doc1',
           documentType: 'book',
           patches: [{set: {bar: 'b'}}],
-          resource: {projectId: 'p', dataset: 'd'},
         },
       ],
       disableBatching: false,
       outgoingActions: [],
       outgoingMutations: [],
-      base: {[getDraftId('doc1')]: {_id: getDraftId('doc1'), _rev: 'rev1'}} as DocumentSet,
+      base: {
+        [getDraftId(DocumentId('doc1'))]: {_id: getDraftId(DocumentId('doc1')), _rev: 'rev1'},
+      } as unknown as DocumentSet,
       working: {
-        [getDraftId('doc1')]: {
+        [getDraftId(DocumentId('doc1'))]: {
           ...exampleDoc,
-          _id: getDraftId('doc1'),
+          _id: getDraftId(DocumentId('doc1')),
           _rev: 'rev2',
           foo: 'a',
           bar: 'b',
         },
       },
-      previous: {[getDraftId('doc1')]: {...exampleDoc, _id: getDraftId('doc1'), _rev: 'rev1'}},
-      previousRevs: {[getDraftId('doc1')]: 'rev1'},
+      previous: {
+        [getDraftId(DocumentId('doc1'))]: {
+          ...exampleDoc,
+          _id: getDraftId(DocumentId('doc1')),
+          _rev: 'rev1',
+        },
+      },
+      previousRevs: {[getDraftId(DocumentId('doc1'))]: 'rev1'},
       timestamp: '2025-02-06T00:00:00.000Z',
     }
     const result = batchAppliedTransactions([appliedTx])
@@ -281,16 +264,16 @@ describe('batchAppliedTransactions', () => {
   })
 
   it('batches two edit transactions when possible', () => {
-    const draftId = getDraftId('doc1')
+    const documentId = DocumentId('doc1')
+    const draftId = getDraftId(documentId)
     const appliedTx1: AppliedTransaction = {
       transactionId: 'txn5',
       actions: [
         {
           type: 'document.edit',
-          documentId: 'doc1',
+          documentId,
           documentType: 'book',
           patches: [{set: {foo: 'a'}}],
-          resource: {projectId: 'p', dataset: 'd'},
         },
       ],
       disableBatching: false,
@@ -298,7 +281,7 @@ describe('batchAppliedTransactions', () => {
         {
           actionType: 'sanity.action.document.edit',
           draftId,
-          publishedId: getPublishedId('doc1'),
+          publishedId: getPublishedId(documentId),
           patch: {set: {foo: 'a'}},
         },
       ],
@@ -314,10 +297,9 @@ describe('batchAppliedTransactions', () => {
       actions: [
         {
           type: 'document.edit',
-          documentId: 'doc1',
+          documentId,
           documentType: 'book',
           patches: [{set: {bar: 'b'}}],
-          resource: {projectId: 'p', dataset: 'd'},
         },
       ],
       disableBatching: false,
@@ -325,7 +307,7 @@ describe('batchAppliedTransactions', () => {
         {
           actionType: 'sanity.action.document.edit',
           draftId,
-          publishedId: getPublishedId('doc1'),
+          publishedId: getPublishedId(documentId),
           patch: {set: {bar: 'b'}},
         },
       ],
@@ -349,7 +331,7 @@ describe('batchAppliedTransactions', () => {
   })
 
   it('returns a transaction with disableBatching true if a single edit action already has disableBatching set', () => {
-    const draftId = getDraftId('docA')
+    const draftId = getDraftId(DocumentId('docA'))
     const appliedTx: AppliedTransaction = {
       transactionId: 'txn-disable',
       actions: [
@@ -358,7 +340,6 @@ describe('batchAppliedTransactions', () => {
           documentId: 'docA',
           documentType: 'book',
           patches: [{set: {foo: 'a'}}],
-          resource: {projectId: 'p', dataset: 'd'},
         },
       ],
       disableBatching: true, // already set to true
@@ -378,6 +359,85 @@ describe('batchAppliedTransactions', () => {
     // The actions array should be the same as the input's.
     expect(result?.actions).toEqual(appliedTx.actions)
   })
+
+  it('does not batch a liveEdit edit with a non-liveEdit edit', () => {
+    const nonLiveEditTx: AppliedTransaction = {
+      transactionId: 'txn-nonlive',
+      actions: [
+        {
+          type: 'document.edit',
+          documentId: 'doc1',
+          documentType: 'article',
+          patches: [{set: {foo: 'a'}}],
+        },
+      ],
+      disableBatching: false,
+      outgoingActions: [
+        {
+          actionType: 'sanity.action.document.edit',
+          draftId: getDraftId(DocumentId('doc1')),
+          publishedId: getPublishedId(DocumentId('doc1')),
+          patch: {set: {foo: 'a'}},
+        },
+      ],
+      outgoingMutations: [],
+      base: {
+        [getDraftId(DocumentId('doc1'))]: {
+          ...exampleDoc,
+          _id: getDraftId(DocumentId('doc1')),
+          _rev: 'rev1',
+        },
+      },
+      working: {
+        [getDraftId(DocumentId('doc1'))]: {
+          ...exampleDoc,
+          _id: getDraftId(DocumentId('doc1')),
+          _rev: 'rev2',
+        },
+      },
+      previous: {
+        [getDraftId(DocumentId('doc1'))]: {
+          ...exampleDoc,
+          _id: getDraftId(DocumentId('doc1')),
+          _rev: 'rev1',
+        },
+      },
+      previousRevs: {[getDraftId(DocumentId('doc1'))]: 'rev1'},
+      timestamp: '2025-02-06T00:00:00.000Z',
+    }
+    const liveEditTx: AppliedTransaction = {
+      transactionId: 'txn-live',
+      actions: [
+        {
+          type: 'document.edit',
+          documentId: 'doc2',
+          documentType: 'liveArticle',
+          liveEdit: true,
+          patches: [{set: {bar: 'b'}}],
+        },
+      ],
+      disableBatching: false,
+      outgoingActions: [],
+      outgoingMutations: [{patch: {id: 'doc2', set: {bar: 'b'}}}],
+      base: {doc2: {...exampleDoc, _id: 'doc2', _rev: 'rev1'}},
+      working: {doc2: {...exampleDoc, _id: 'doc2', _rev: 'rev2'}},
+      previous: {doc2: {...exampleDoc, _id: 'doc2', _rev: 'rev1'}},
+      previousRevs: {doc2: 'rev1'},
+      timestamp: '2025-02-06T00:01:00.000Z',
+    }
+
+    // liveEdit first: should return only the liveEdit transaction
+    const resultLiveFirst = batchAppliedTransactions([liveEditTx, nonLiveEditTx])
+    expect(resultLiveFirst?.batchedTransactionIds).toEqual(['txn-live'])
+    expect(resultLiveFirst?.outgoingMutations).toEqual(liveEditTx.outgoingMutations)
+    expect(resultLiveFirst?.outgoingActions).toHaveLength(0)
+
+    // non-liveEdit first: should return only the non-liveEdit transaction
+    const resultNonLiveFirst = batchAppliedTransactions([nonLiveEditTx, liveEditTx])
+    expect(resultNonLiveFirst?.batchedTransactionIds).toEqual(['txn-nonlive'])
+    expect(resultNonLiveFirst?.outgoingActions).toEqual(nonLiveEditTx.outgoingActions)
+    expect(resultNonLiveFirst?.outgoingMutations).toHaveLength(0)
+  })
 })
 
 describe('transitionAppliedTransactionsToOutgoing', () => {
@@ -394,7 +454,7 @@ describe('transitionAppliedTransactionsToOutgoing', () => {
   })
 
   it('transitions applied transactions to an outgoing transaction', () => {
-    const draftId = getDraftId('doc1')
+    const draftId = getDraftId(DocumentId('doc1'))
     const initialDoc = {...exampleDoc, _id: draftId, foo: 'old', _rev: 'rev1'}
     const state: SyncTransactionState = {
       queued: [],
@@ -407,7 +467,6 @@ describe('transitionAppliedTransactionsToOutgoing', () => {
               documentId: 'doc1',
               documentType: 'book',
               patches: [{set: {foo: 'new'}}],
-              resource: {projectId: 'p', dataset: 'd'},
             },
           ],
           disableBatching: false,
@@ -438,6 +497,9 @@ describe('transitionAppliedTransactionsToOutgoing', () => {
     expect(docState?.unverifiedRevisions).toBeDefined()
     expect(docState?.unverifiedRevisions?.['txn7']).toBeDefined()
     expect(docState?.unverifiedRevisions?.['txn7']?.previousRev).toEqual('rev1')
+    // the transaction ID is also tracked durably for remote-patches origin
+    // labeling, surviving unverified-revision pruning
+    expect(docState?.recentOwnTransactionIds).toEqual(['txn7'])
   })
 })
 
@@ -455,8 +517,8 @@ describe('cleanupOutgoingTransaction', () => {
   })
 
   it('removes subscription ids for all documents associated with the outgoing transaction and then clears outgoing', () => {
-    const draftId = getDraftId('doc1')
-    const pubId = getPublishedId('doc1')
+    const draftId = getDraftId(DocumentId('doc1'))
+    const pubId = getPublishedId(DocumentId('doc1'))
     const state: SyncTransactionState = {
       queued: [],
       applied: [],
@@ -468,7 +530,6 @@ describe('cleanupOutgoingTransaction', () => {
             documentId: 'doc1',
             documentType: 'book',
             patches: [{set: {foo: 'x'}}],
-            resource: {projectId: 'p', dataset: 'd'},
           },
         ],
         disableBatching: false,
@@ -497,8 +558,8 @@ describe('cleanupOutgoingTransaction', () => {
 
 describe('revertOutgoingTransaction', () => {
   it('reverts the outgoing transaction and updates documentStates by removing unverified revisions', () => {
-    const draftId = getDraftId('doc1')
-    const pubId = getPublishedId('doc1')
+    const draftId = getDraftId(DocumentId('doc1'))
+    const pubId = getPublishedId(DocumentId('doc1'))
     // In this test we simulate a state with one applied transaction and an outgoing transaction.
     const state: SyncTransactionState = {
       queued: [],
@@ -511,7 +572,6 @@ describe('revertOutgoingTransaction', () => {
               documentId: 'doc1',
               documentType: 'book',
               patches: [{set: {foo: 'reverted'}}],
-              resource: {projectId: 'p', dataset: 'd'},
             },
           ],
           disableBatching: false,
@@ -532,7 +592,6 @@ describe('revertOutgoingTransaction', () => {
             documentId: 'doc1',
             documentType: 'book',
             patches: [{set: {foo: 'changed'}}],
-            resource: {projectId: 'p', dataset: 'd'},
           },
         ],
         disableBatching: false,
@@ -597,7 +656,7 @@ describe('applyRemoteDocument', () => {
   })
 
   it('verifies an unverified revision when the revision matches and previousRev is as expected', () => {
-    const docId = getDraftId('doc1')
+    const docId = getDraftId(DocumentId('doc1'))
     const initialState: SyncTransactionState = {
       queued: [],
       applied: [],
@@ -637,9 +696,132 @@ describe('applyRemoteDocument', () => {
     expect(newDocState?.unverifiedRevisions?.['txn10']).toBeUndefined()
   })
 
+  describe('fast-forward convergence of local', () => {
+    const docId = getDraftId(DocumentId('doc1'))
+    const otherDocId = getDraftId(DocumentId('doc2'))
+
+    const makeApplied = (overrides: Partial<AppliedTransaction>): AppliedTransaction => ({
+      transactionId: 'txnPending',
+      actions: [],
+      working: {},
+      previous: {},
+      base: {},
+      previousRevs: {},
+      timestamp: '2025-02-06T00:06:30.000Z',
+      outgoingActions: [],
+      outgoingMutations: [],
+      ...overrides,
+    })
+
+    const makeState = (applied: AppliedTransaction[]): SyncTransactionState => ({
+      queued: [],
+      applied,
+      outgoing: undefined,
+      grants,
+      documentStates: {
+        [docId]: {
+          id: docId,
+          subscriptions: ['sub1'],
+          local: {...exampleDoc, _id: docId, foo: 'optimistic'},
+          remote: {...exampleDoc, _id: docId, foo: 'old'},
+          unverifiedRevisions: {
+            txn10: {
+              transactionId: 'txn10',
+              documentId: docId,
+              previousRev: 'revOld',
+              timestamp: '2025-02-06T00:06:00.000Z',
+            },
+          },
+        },
+      },
+    })
+
+    const remote: RemoteDocument = {
+      type: 'sync',
+      documentId: docId,
+      document: {...exampleDoc, _id: docId, foo: 'server-truth'},
+      revision: 'txn10',
+      previousRev: 'revOld',
+      timestamp: '2025-02-06T00:07:00.000Z',
+    }
+
+    it('converges local to the server document when nothing else is pending', () => {
+      const events = new Subject<DocumentEvent>()
+      const newState = applyRemoteDocument(makeState([]), remote, events)
+      expect(newState.documentStates[docId]?.local).toEqual(remote.document)
+    })
+
+    it('converges local when pending work modifies only other documents', () => {
+      // a pending applied transaction on doc2 must not block convergence of
+      // doc1: nothing would ever revisit doc1's local otherwise
+      const otherDoc = {...exampleDoc, _id: otherDocId}
+      const pendingOnOtherDoc = makeApplied({
+        working: {[otherDocId]: {...otherDoc, _rev: 'txnPending'}},
+        previous: {[otherDocId]: otherDoc},
+        base: {[otherDocId]: otherDoc},
+        previousRevs: {[otherDocId]: 'txn0'},
+      })
+      const events = new Subject<DocumentEvent>()
+      const newState = applyRemoteDocument(makeState([pendingOnOtherDoc]), remote, events)
+      expect(newState.documentStates[docId]?.local).toEqual(remote.document)
+    })
+
+    it('converges local when pending work carries this document unmodified', () => {
+      // a draft edit carries the published document in its working set
+      // without changing it; presence alone must not block convergence
+      const thisDoc = {...exampleDoc, _id: docId}
+      const pendingCarryingUnmodified = makeApplied({
+        working: {
+          [docId]: thisDoc,
+          [otherDocId]: {...exampleDoc, _id: otherDocId, _rev: 'txnPending'},
+        },
+        previous: {[docId]: thisDoc, [otherDocId]: {...exampleDoc, _id: otherDocId}},
+        base: {[docId]: thisDoc, [otherDocId]: {...exampleDoc, _id: otherDocId}},
+        previousRevs: {[docId]: thisDoc._rev, [otherDocId]: 'txn0'},
+      })
+      const events = new Subject<DocumentEvent>()
+      const newState = applyRemoteDocument(makeState([pendingCarryingUnmodified]), remote, events)
+      expect(newState.documentStates[docId]?.local).toEqual(remote.document)
+    })
+
+    it('keeps the optimistic local when pending work modifies this document', () => {
+      const optimistic = {...exampleDoc, _id: docId, _rev: 'txnPending', foo: 'optimistic'}
+      const pendingOnThisDoc = makeApplied({
+        working: {[docId]: optimistic},
+        previous: {[docId]: {...exampleDoc, _id: docId}},
+        base: {[docId]: {...exampleDoc, _id: docId}},
+        previousRevs: {[docId]: 'txn0'},
+      })
+      const state = makeState([pendingOnThisDoc])
+      const events = new Subject<DocumentEvent>()
+      const newState = applyRemoteDocument(state, remote, events)
+      expect(newState.documentStates[docId]?.local).toBe(state.documentStates[docId]?.local)
+      expect(newState.documentStates[docId]?.remote).toEqual(remote.document)
+    })
+
+    it('keeps the optimistic local when a different in-flight transaction modifies this document', () => {
+      const optimistic = {...exampleDoc, _id: docId, _rev: 'txnOutgoing', foo: 'optimistic'}
+      const outgoing = {
+        ...makeApplied({
+          transactionId: 'txnOutgoing',
+          working: {[docId]: optimistic},
+          previous: {[docId]: {...exampleDoc, _id: docId}},
+          base: {[docId]: {...exampleDoc, _id: docId}},
+          previousRevs: {[docId]: 'txn0'},
+        }),
+        disableBatching: false,
+        batchedTransactionIds: ['txnOutgoing'],
+      }
+      const state = {...makeState([]), outgoing}
+      const events = new Subject<DocumentEvent>()
+      const newState = applyRemoteDocument(state, remote, events)
+      expect(newState.documentStates[docId]?.local).toBe(state.documentStates[docId]?.local)
+    })
+  })
+
   it('rebases local changes when no matching unverified revision is found', () => {
     // In this branch we simply let processActions rebase so that the local becomes the remote.
-    const docId = getDraftId('doc1')
+    const docId = getDraftId(DocumentId('doc1'))
     const initialState: SyncTransactionState = {
       queued: [],
       applied: [],
@@ -674,7 +856,7 @@ describe('applyRemoteDocument', () => {
 
   // Test that a sync event removes outdated unverified revisions.
   it('removes outdated unverified revisions when a sync event is received', () => {
-    const docId = getDraftId('doc1')
+    const docId = getDraftId(DocumentId('doc1'))
     // An unverified revision created at an earlier time.
     const outdatedTimestamp = new Date('2025-02-06T00:09:00.000Z').toISOString()
     // The incoming sync event timestamp is later.
@@ -738,6 +920,399 @@ describe('applyRemoteDocument', () => {
     expect(newDocState?.remote).toEqual(remote.document)
     expect(newDocState?.remoteRev).toBe('currentRev')
   })
+
+  describe('remote-patches events', () => {
+    const docId = getDraftId(DocumentId('doc1'))
+
+    function createInitialState(
+      unverifiedRevisions: NonNullable<
+        SyncTransactionState['documentStates'][string]
+      >['unverifiedRevisions'] = {},
+      recentOwnTransactionIds?: string[],
+    ): SyncTransactionState {
+      return {
+        queued: [],
+        applied: [],
+        outgoing: undefined,
+        grants,
+        documentStates: {
+          [docId]: {
+            id: docId,
+            subscriptions: ['sub1'],
+            local: {...exampleDoc, _id: docId, foo: 'old'},
+            remote: {...exampleDoc, _id: docId, foo: 'old'},
+            unverifiedRevisions,
+            ...(recentOwnTransactionIds && {recentOwnTransactionIds}),
+          },
+        },
+      }
+    }
+
+    it('emits a remote-patches event with origin "remote" for foreign transactions', () => {
+      const events = new Subject<DocumentEvent>()
+      const received: DocumentEvent[] = []
+      events.subscribe((e) => received.push(e))
+
+      const remote: RemoteDocument = {
+        type: 'mutation',
+        documentId: docId,
+        document: {...exampleDoc, _id: docId, foo: 'new'},
+        revision: 'txnForeign',
+        previousRev: 'txn0',
+        timestamp: '2025-02-06T00:12:00.000Z',
+        mutations: [
+          {
+            patch: {
+              id: docId,
+              unset: ['blocks[_key=="a"].children[_key=="b"].marks[0]'],
+            },
+          },
+          {
+            patch: {
+              id: docId,
+              insert: {after: 'blocks[_key=="a"].markDefs[-1]', items: [{_key: 'link1'}]},
+            },
+          },
+        ],
+      }
+
+      applyRemoteDocument(createInitialState(), remote, events)
+
+      expect(received).toEqual([
+        {
+          type: 'remote-patches',
+          documentId: docId,
+          transactionId: 'txnForeign',
+          previousRev: 'txn0',
+          timestamp: '2025-02-06T00:12:00.000Z',
+          origin: 'remote',
+          patches: [
+            {unset: ['blocks[_key=="a"].children[_key=="b"].marks[0]']},
+            {insert: {after: 'blocks[_key=="a"].markDefs[-1]', items: [{_key: 'link1'}]}},
+          ],
+        },
+      ])
+    })
+
+    it('emits origin "local" when the transaction is one of our own unverified revisions', () => {
+      const events = new Subject<DocumentEvent>()
+      const received: DocumentEvent[] = []
+      events.subscribe((e) => received.push(e))
+
+      const remote: RemoteDocument = {
+        type: 'mutation',
+        documentId: docId,
+        document: {...exampleDoc, _id: docId, foo: 'new'},
+        revision: 'txnOwn',
+        previousRev: 'txn0',
+        timestamp: '2025-02-06T00:13:00.000Z',
+        mutations: [{patch: {id: docId, set: {foo: 'new'}}}],
+      }
+
+      applyRemoteDocument(
+        createInitialState({
+          txnOwn: {
+            transactionId: 'txnOwn',
+            documentId: docId,
+            previousRev: 'txn0',
+            timestamp: '2025-02-06T00:13:00.000Z',
+          },
+        }),
+        remote,
+        events,
+      )
+
+      expect(received).toEqual([
+        {
+          type: 'remote-patches',
+          documentId: docId,
+          transactionId: 'txnOwn',
+          previousRev: 'txn0',
+          timestamp: '2025-02-06T00:13:00.000Z',
+          origin: 'local',
+          patches: [{set: {foo: 'new'}}],
+        },
+      ])
+    })
+
+    it('does not emit for sync events', () => {
+      const events = new Subject<DocumentEvent>()
+      const received: DocumentEvent[] = []
+      events.subscribe((e) => received.push(e))
+
+      const remote: RemoteDocument = {
+        type: 'sync',
+        documentId: docId,
+        document: {...exampleDoc, _id: docId, foo: 'new'},
+        revision: 'revSync',
+        timestamp: '2025-02-06T00:14:00.000Z',
+      }
+
+      applyRemoteDocument(createInitialState(), remote, events)
+      expect(received).toEqual([])
+    })
+
+    it('does not emit when the mutations contain no patches', () => {
+      const events = new Subject<DocumentEvent>()
+      const received: DocumentEvent[] = []
+      events.subscribe((e) => received.push(e))
+
+      const remote: RemoteDocument = {
+        type: 'mutation',
+        documentId: docId,
+        document: {...exampleDoc, _id: docId, foo: 'new'},
+        revision: 'txnCreate',
+        previousRev: 'txn0',
+        timestamp: '2025-02-06T00:15:00.000Z',
+        mutations: [{createOrReplace: {...exampleDoc, _id: docId, foo: 'new'}}],
+      }
+
+      applyRemoteDocument(createInitialState(), remote, events)
+      expect(received).toEqual([])
+    })
+
+    it('excludes patches addressed to other documents in the same transaction', () => {
+      const events = new Subject<DocumentEvent>()
+      const received: DocumentEvent[] = []
+      events.subscribe((e) => received.push(e))
+
+      const remote: RemoteDocument = {
+        type: 'mutation',
+        documentId: docId,
+        document: {...exampleDoc, _id: docId, foo: 'new'},
+        revision: 'txnMulti',
+        previousRev: 'txn0',
+        timestamp: '2025-02-06T00:20:00.000Z',
+        mutations: [
+          {patch: {id: docId, set: {foo: 'new'}}},
+          {patch: {id: 'some-other-doc', set: {foo: 'other'}}},
+          {patch: {query: '*[_type == "author"]', set: {foo: 'queried'}}},
+        ],
+      }
+
+      applyRemoteDocument(createInitialState(), remote, events)
+
+      expect(received).toHaveLength(1)
+      expect((received[0] as {patches: unknown}).patches).toEqual([{set: {foo: 'new'}}])
+    })
+
+    it('labels origin "local" via recentOwnTransactionIds when the unverified revision was pruned', () => {
+      const events = new Subject<DocumentEvent>()
+      const received: DocumentEvent[] = []
+      events.subscribe((e) => received.push(e))
+
+      const remote: RemoteDocument = {
+        type: 'mutation',
+        documentId: docId,
+        document: {...exampleDoc, _id: docId, foo: 'new'},
+        revision: 'txnPruned',
+        previousRev: 'txn0',
+        timestamp: '2025-02-06T00:21:00.000Z',
+        mutations: [{patch: {id: docId, set: {foo: 'new'}}}],
+      }
+
+      // a sync event racing the listener echo pruned the unverified revision,
+      // but the transaction ID is still tracked as one of our own
+      applyRemoteDocument(createInitialState({}, ['txnPruned']), remote, events)
+
+      expect(received).toHaveLength(1)
+      expect(received[0]).toMatchObject({
+        type: 'remote-patches',
+        transactionId: 'txnPruned',
+        origin: 'local',
+      })
+    })
+  })
+
+  describe('rebase with preserved operations', () => {
+    it('skips a preserved-operations transaction that fails to re-apply and emits rebase-error', () => {
+      const docId = getDraftId(DocumentId('doc1'))
+      const originalDoc: SanityDocument = {
+        ...exampleDoc,
+        _id: docId,
+        _rev: 'rev1',
+        title: 'The quick brown fox',
+      }
+      const locallyEditedDoc: SanityDocument = {
+        ...originalDoc,
+        title: 'The quick brown cat',
+        _rev: 'txnLocal',
+      }
+
+      const appliedTransaction: AppliedTransaction = {
+        transactionId: 'txnLocal',
+        actions: [
+          {
+            type: 'document.edit',
+            documentId: 'doc1',
+            documentType: 'author',
+            patches: [{diffMatchPatch: {title: '@@ -13,7 +13,7 @@\n own \n-fox\n+cat\n'}}],
+            preserveOperations: true,
+          },
+        ],
+        previous: {[docId]: originalDoc},
+        base: {[docId]: originalDoc},
+        working: {[docId]: locallyEditedDoc},
+        previousRevs: {[docId]: 'rev1'},
+        timestamp: '2025-02-06T00:16:00.000Z',
+        outgoingActions: [],
+        outgoingMutations: [],
+      }
+
+      const initialState: SyncTransactionState = {
+        queued: [],
+        applied: [appliedTransaction],
+        outgoing: undefined,
+        grants,
+        documentStates: {
+          [docId]: {
+            id: docId,
+            subscriptions: ['sub1'],
+            local: locallyEditedDoc,
+            remote: originalDoc,
+            unverifiedRevisions: {},
+          },
+        },
+      }
+
+      // a foreign transaction replaced the title with a non-string, so our
+      // diffMatchPatch can no longer re-apply during the rebase
+      const remoteDoc: SanityDocument = {
+        ...originalDoc,
+        title: 42 as unknown as string,
+        _rev: 'txnForeign',
+      }
+      const remote: RemoteDocument = {
+        type: 'mutation',
+        documentId: docId,
+        document: remoteDoc,
+        revision: 'txnForeign',
+        previousRev: 'rev1',
+        timestamp: '2025-02-06T00:17:00.000Z',
+        mutations: [{patch: {id: docId, set: {title: 42}}}],
+      }
+
+      const events = new Subject<DocumentEvent>()
+      const received: DocumentEvent[] = []
+      events.subscribe((e) => received.push(e))
+
+      const newState = applyRemoteDocument(initialState, remote, events)
+
+      const rebaseErrors = received.filter((e) => e.type === 'rebase-error')
+      expect(rebaseErrors).toHaveLength(1)
+      expect(rebaseErrors[0]).toMatchObject({
+        type: 'rebase-error',
+        transactionId: 'txnLocal',
+        documentId: 'doc1',
+        message: expect.stringMatching(/Failed to apply patches to the working document/),
+      })
+
+      // the failing transaction is dropped and local converges to remote
+      expect(newState.applied).toEqual([])
+      expect(newState.documentStates[docId]?.local).toEqual(remoteDoc)
+      expect(newState.documentStates[docId]?.remote).toEqual(remoteDoc)
+    })
+
+    it('re-applies preserved keyed patches onto a diverged remote document', () => {
+      const docId = getDraftId(DocumentId('doc1'))
+      const originalDoc: SanityDocument = {
+        ...exampleDoc,
+        _id: docId,
+        _rev: 'rev1',
+        items: [
+          {_key: 'a', value: 'first'},
+          {_key: 'b', value: 'second'},
+        ],
+      }
+      const locallyEditedDoc: SanityDocument = {
+        ...originalDoc,
+        items: [
+          {_key: 'a', value: 'first'},
+          {_key: 'c', value: 'in between'},
+          {_key: 'b', value: 'second'},
+        ],
+        _rev: 'txnLocal',
+      }
+
+      const appliedTransaction: AppliedTransaction = {
+        transactionId: 'txnLocal',
+        actions: [
+          {
+            type: 'document.edit',
+            documentId: 'doc1',
+            documentType: 'author',
+            patches: [
+              {insert: {after: 'items[_key=="a"]', items: [{_key: 'c', value: 'in between'}]}},
+            ],
+            preserveOperations: true,
+          },
+        ],
+        previous: {[docId]: originalDoc},
+        base: {[docId]: originalDoc},
+        working: {[docId]: locallyEditedDoc},
+        previousRevs: {[docId]: 'rev1'},
+        timestamp: '2025-02-06T00:18:00.000Z',
+        outgoingActions: [],
+        outgoingMutations: [],
+      }
+
+      const initialState: SyncTransactionState = {
+        queued: [],
+        applied: [appliedTransaction],
+        outgoing: undefined,
+        grants,
+        documentStates: {
+          [docId]: {
+            id: docId,
+            subscriptions: ['sub1'],
+            local: locallyEditedDoc,
+            remote: originalDoc,
+            unverifiedRevisions: {},
+          },
+        },
+      }
+
+      // a foreign transaction appended a new item concurrently
+      const remoteDoc: SanityDocument = {
+        ...originalDoc,
+        items: [
+          {_key: 'a', value: 'first'},
+          {_key: 'b', value: 'second'},
+          {_key: 'd', value: 'appended remotely'},
+        ],
+        _rev: 'txnForeign',
+      }
+      const remote: RemoteDocument = {
+        type: 'mutation',
+        documentId: docId,
+        document: remoteDoc,
+        revision: 'txnForeign',
+        previousRev: 'rev1',
+        timestamp: '2025-02-06T00:19:00.000Z',
+        mutations: [
+          {
+            patch: {
+              id: docId,
+              insert: {after: 'items[-1]', items: [{_key: 'd', value: 'appended remotely'}]},
+            },
+          },
+        ],
+      }
+
+      const events = new Subject<DocumentEvent>()
+      const newState = applyRemoteDocument(initialState, remote, events)
+
+      // both edits survive: our keyed insert re-anchors after item "a" while
+      // the remote append is preserved
+      expect(newState.documentStates[docId]?.local?.['items']).toEqual([
+        {_key: 'a', value: 'first'},
+        {_key: 'c', value: 'in between'},
+        {_key: 'b', value: 'second'},
+        {_key: 'd', value: 'appended remotely'},
+      ])
+      expect(newState.applied).toHaveLength(1)
+    })
+  })
 })
 
 describe('addSubscriptionIdToDocument', () => {