@sanity/sdk 3.4.0-rc.0 → 3.4.0

package/src/dashboard/messageBus/bus.ts

@@ -42,6 +42,7 @@ export type MessageBusErrorCode =
   | 'PROTOCOL_MISMATCH'
   | 'OWNERSHIP_MISMATCH'
   | 'MISSING_APP_ID'
+  | 'REFUSED'
 
 /**
  * An error raised by the message bus protocol.
@@ -89,6 +90,12 @@ export interface MessageBusMessage<T, R = never, K extends PropertyKey = TopicNa
   meta: MessageBusMeta
   /** Replies to an awaiting sender. */
   reply(value: R): void
+  /**
+   * Refuses the message: the sender's awaited `emit()` rejects with a
+   * {@link MessageBusError} whose `code` is `'REFUSED'`. Ignored, with a warning,
+   * once the reply has already settled.
+   */
+  reject(message?: string): void
   /** Aborts when the sender stops waiting for a reply. */
   readonly signal: AbortSignal
 }
@@ -186,6 +193,8 @@ export interface MessageBus<TTopics = MessageBusTopics> {
  * @public
  */
 export interface MessageBusConnection<TTopics = MessageBusTopics> extends MessageBus<TTopics> {
+  /** The application this connection belongs to. */
+  readonly appId: Application['id']
   /**
    * Tears down this connection: pending requests reject `ABORTED`, subscriptions
    * complete, and later `emit`, `query`, and `subscribe` calls fail with `ABORTED`.
@@ -207,6 +216,19 @@ export interface MessageBusClient {
   readonly closed: AbortSignal
   /** Writes a state value to this connection only. Ignored once the connection has closed. */
   emit<K extends StateTopic>(type: K, value: ValueOf<K>): void
+  /**
+   * Rejects a state topic for this connection: its pending and later {@link MessageBus.query}
+   * calls reject with a {@link MessageBusError} whose `code` is `'REFUSED'`, until the host next
+   * writes a value with {@link MessageBusClient.emit}, which clears the rejection.
+   *
+   * @remarks
+   * A rejected promise cannot be un-rejected and an errored subject cannot resume, so the
+   * rejection is tracked per connection alongside the topic's subject rather than by erroring
+   * it: `query` consults it before awaiting, and {@link MessageBus.subscribe} and the topic's
+   * {@link MessageBusStateSource} stay silent (they never error) until a value is written.
+   * Ignored once the connection has closed, the same as {@link MessageBusClient.emit}.
+   */
+  reject<K extends StateTopic>(type: K, message?: string): void
 }
 
 /**
@@ -260,6 +282,10 @@ interface ConnectionRecord {
   readonly appId: string
   readonly moduleId: string
   readonly stateSubjects: Map<string, BehaviorSubject<unknown>>
+  // Topics the host has rejected for this connection, with the reason, until the next write.
+  readonly rejections: Map<string, string | undefined>
+  // Fires the rejected topic name so pending queries on that topic can reject at once.
+  readonly rejected$: Subject<string>
   readonly abort: AbortController
 }
 
@@ -384,6 +410,15 @@ function createEventMessage(
       }
       settleReply(pendingReply, {ok: true, value})
     },
+    reject: (reason) => {
+      if (pendingReply.settled) {
+        console.warn(
+          `[sanity-sdk:message-bus] reject ignored for "${type}": no waiting caller or already replied`,
+        )
+        return
+      }
+      settleReply(pendingReply, {ok: false, error: new MessageBusError('REFUSED', reason)})
+    },
     get signal() {
       return pendingReply.responderSignal
     },
@@ -516,6 +551,8 @@ function emitState(
   type: string,
   value: unknown,
 ): void {
+  // A written value clears any rejection so later queries resolve normally.
+  connection.rejections.delete(type)
   const subject = resolveStateSubject(registry, connection, type)
   if (!Object.is(subject.getValue(), value)) subject.next(value)
 }
@@ -526,7 +563,11 @@ function query(
   options: MessageBusQueryOptions | undefined,
   connectionSignal: AbortSignal,
   resetSignal: AbortSignal,
+  connection: ConnectionRecord,
 ): Promise<unknown> {
+  const rejection = () => new MessageBusError('REFUSED', connection.rejections.get(type))
+  // A rejection outranks any earlier value: it is cleared only when the host writes a new one.
+  if (connection.rejections.has(type)) return Promise.reject(rejection())
   const current = source.getCurrent()
   if (current !== undefined) return Promise.resolve(current)
 
@@ -537,12 +578,21 @@ function query(
     const timer =
       timeoutMs === null
         ? undefined
-        : setTimeout(
-            () => reject(new MessageBusError('TIMEOUT', `query("${type}") timed out`)),
-            timeoutMs,
-          )
+        : setTimeout(() => {
+            clear()
+            signal?.removeEventListener('abort', onAbort)
+            reject(new MessageBusError('TIMEOUT', `query("${type}") timed out`))
+          }, timeoutMs)
+    // A rejection that arrives while waiting rejects the pending query at once.
+    const rejectedSub = connection.rejected$.subscribe((rejectedType) => {
+      if (rejectedType !== type) return
+      clear()
+      signal?.removeEventListener('abort', onAbort)
+      reject(rejection())
+    })
     const clear = () => {
       if (timer !== undefined) clearTimeout(timer)
+      rejectedSub.unsubscribe()
     }
     const onAbort = () => {
       clear()
@@ -824,6 +874,7 @@ function migrateEventMessage(
     payload: payload(message.payload),
     meta: message.meta,
     reply: (value) => message.reply(reply(value)),
+    reject: (reason) => message.reject(reason),
     get signal() {
       return message.signal
     },
@@ -838,11 +889,15 @@ function migrateEventReply(
   return createLazyReply(() => (projected ??= Promise.resolve(result).then(project)))
 }
 
-function createRejectedConnection(connectionError: () => unknown): MessageBusConnection {
+function createRejectedConnection(
+  appId: string,
+  connectionError: () => unknown,
+): MessageBusConnection {
   const throwConnectionError = (): never => {
     throw connectionError()
   }
   return {
+    appId,
     emit: throwConnectionError,
     // `query` is typed as a Promise, so it must reject rather than throw synchronously.
     query: () => Promise.reject(connectionError()),
@@ -883,6 +938,7 @@ export function connectApplicationToMessageBus(
       `[sanity-sdk:message-bus] protocol mismatch for "${appId}": installed ${String(installedProtocol)}, this copy speaks ${MESSAGE_BUS_PROTOCOL}`,
     )
     return createRejectedConnection(
+      appId,
       () =>
         new MessageBusError(
           'PROTOCOL_MISMATCH',
@@ -895,6 +951,7 @@ export function connectApplicationToMessageBus(
   if (!registry) {
     console.error(`[sanity-sdk:message-bus] incompatible message bus for "${appId}"`)
     return createRejectedConnection(
+      appId,
       () =>
         new MessageBusError(
           'PROTOCOL_MISMATCH',
@@ -907,7 +964,7 @@ export function connectApplicationToMessageBus(
     mergeTopicManifest(registry, DASHBOARD_TOPIC_MANIFEST)
   } catch (error) {
     console.error(`[sanity-sdk:message-bus] topic manifest conflict for "${appId}"`, {error})
-    return createRejectedConnection(() => error)
+    return createRejectedConnection(appId, () => error)
   }
 
   return createConnection(registry, config) as MessageBusConnection<Topics>
@@ -932,6 +989,11 @@ function createClient(
       }
       emitState(registry, record, type, compatibility.toInstalledEmission(type, value))
     },
+    reject: (type: string, message?: string) => {
+      if (record.abort.signal.aborted) return
+      record.rejections.set(type, message)
+      record.rejected$.next(type)
+    },
   } as MessageBusClient
 }
 
@@ -978,6 +1040,8 @@ function createConnection(
     appId,
     moduleId,
     stateSubjects: new Map(),
+    rejections: new Map(),
+    rejected$: new Subject<string>(),
     abort: connectionAbort,
   }
 
@@ -1028,6 +1092,7 @@ function createConnection(
   }
 
   const connection = {
+    appId,
     emit: (type: string, payload: unknown, options?: MessageBusEmitOptions) => {
       throwIfDisconnected()
       return migrateEventReply(
@@ -1045,7 +1110,14 @@ function createConnection(
     },
     query: (type: string, options?: MessageBusQueryOptions) => {
       if (connectionSignal.aborted) return Promise.reject(new MessageBusError('ABORTED'))
-      return query(stateSource(type), type, options, connectionSignal, registry.resetAbort.signal)
+      return query(
+        stateSource(type),
+        type,
+        options,
+        connectionSignal,
+        registry.resetAbort.signal,
+        record,
+      )
     },
     subscribe: (
       type: string,
@@ -1085,6 +1157,7 @@ function createConnection(
       connectionAbort.abort()
       for (const subject of record.stateSubjects.values()) subject.complete()
       record.stateSubjects.clear()
+      record.rejected$.complete()
       registry.connections.delete(record)
     },
   }
@@ -1110,6 +1183,7 @@ function reset(registry: MessageBusRegistry): void {
   for (const connection of registry.connections) {
     for (const subject of connection.stateSubjects.values()) subject.complete()
     connection.stateSubjects.clear()
+    connection.rejections.clear()
   }
   for (const subject of registry.eventSubjects.values()) subject.complete()
 

package/src/dashboard/messageBus/topics.test.ts

@@ -3,9 +3,12 @@ import {describe, expect, expectTypeOf, it} from 'vitest'
 import {type Application, type ApplicationInclude} from '../../applications/applications'
 import {type MessageBus} from './bus'
 import {
+  type ApplicationActivity,
   type ApplicationConfig,
   type ApplicationConfigAppType,
+  type ApplicationContext,
   type ApplicationStatusUpdate,
+  type CapabilityRecord,
   DASHBOARD_TOPIC_MANIFEST,
   type DashboardTopics,
   type EventTopic,
@@ -53,6 +56,7 @@ describe('dashboard topic types', () => {
     expectTypeOf<ValueOf<'applications.foreground', DashboardTopics>>().toEqualTypeOf<
       Application['id'] | null
     >()
+    expectTypeOf<ValueOf<'applications.capabilities'>>().toEqualTypeOf<CapabilityRecord>()
     expectTypeOf<ValueOf<'applications.config'>>().toEqualTypeOf<ApplicationConfig[] | null>()
     expectTypeOf<ValueOf<'applications.list'>>().toEqualTypeOf<TopicResult<
       Application<ApplicationInclude>[]
@@ -73,6 +77,17 @@ describe('dashboard topic types', () => {
     expectTypeOf<ApplicationConfigAppType>().not.toEqualTypeOf<string>()
   })
 
+  it('pairs the application context state with its update event', () => {
+    // State carries the host-stamped sender; the update payload does not, since the host reads
+    // the sender from `message.meta.appId`.
+    expectTypeOf<ValueOf<'applications.context'>>().toEqualTypeOf<
+      (ApplicationContext & {readonly appId: Application['id']}) | null
+    >()
+    expectTypeOf<
+      PayloadOf<'applications.context.update'>
+    >().toEqualTypeOf<ApplicationContext | null>()
+  })
+
   it('exposes event payload and reply values', () => {
     expectTypeOf<PayloadOf<'navigation.location.update'>>().toEqualTypeOf<{
       url: string
@@ -83,6 +98,11 @@ describe('dashboard topic types', () => {
     >()
   })
 
+  it('reports application activity as a fire-and-forget event', () => {
+    expectTypeOf<PayloadOf<'applications.activity'>>().toEqualTypeOf<ApplicationActivity>()
+    expectTypeOf<ReplyOf<'applications.activity'>>().toBeNever()
+  })
+
   it('requires payloads only for events that declare one', () => {
     const messageBus = {
       emit: () => undefined,

package/src/dashboard/messageBus/topics.ts

@@ -31,6 +31,52 @@ export interface ApplicationConfig extends RemoteModuleRef {
   readonly appType: ApplicationConfigAppType
 }
 
+/**
+ * The capabilities a host can provide.
+ *
+ * Reuses the Studio's rendering-context identifiers so an application can hide its own
+ * implementation of anything the host provides.
+ * @public
+ */
+export const capabilities = ['globalUserMenu', 'favorites', 'history'] as const
+
+/**
+ * A capability a host can provide.
+ * @public
+ */
+export type Capability = (typeof capabilities)[number]
+
+/**
+ * The capabilities the host provides. A missing key means the host does not provide it.
+ * @public
+ */
+export type CapabilityRecord = Partial<Record<Capability, boolean>>
+
+/**
+ * A document a user viewed, edited, created, or deleted in an application.
+ * @public
+ */
+export interface DocumentActivity {
+  readonly kind: 'document'
+  readonly eventType: 'viewed' | 'edited' | 'created' | 'deleted'
+  readonly document: {
+    readonly id: string
+    readonly type: string
+    readonly resource: {
+      readonly id: string
+      readonly type: 'dataset' | 'media-library' | 'canvas'
+      /** Schema collection the document belongs to; the workspace name for studios. */
+      readonly schemaName?: string
+    }
+  }
+}
+
+/**
+ * Activity an application reports to the host. Discriminated on `kind`.
+ * @public
+ */
+export type ApplicationActivity = DocumentActivity
+
 /**
  * A label rendered for an application interface; `null` clears it.
  * @internal
@@ -48,6 +94,20 @@ export type ApplicationStatusUpdate = {
   value: ApplicationStatus
 }
 
+/**
+ * What an application is currently showing: the Comlink agent resource context, made generic.
+ * @public
+ */
+export interface ApplicationContext {
+  /** The resource the application is working in. Types follow `@sanity/client`'s resource config. */
+  readonly resource: {
+    readonly id: string
+    readonly type: 'dataset' | 'media-library' | 'canvas'
+  }
+  /** The open document, or `null` when none is open. */
+  readonly document: {readonly id: string} | null
+}
+
 /**
  * Declares a topic that stores and replays its current value.
  * @public
@@ -100,14 +160,24 @@ export type NavigationLocation = NavigationTarget & {
  * @public
  */
 export interface DashboardTopics {
+  /** Reports user activity in an application, e.g. for the recents feed. Fire-and-forget. */
+  'applications.activity': EventTopicDef<ApplicationActivity>
   /**
    * The base path for an application.
    *
    * An unknown application returns `{ok: false}`.
    */
   'applications.base-path': StateTopicDef<TopicResult<string>>
+  /** The capabilities the host provides. A missing key means the host does not provide it. */
+  'applications.capabilities': StateTopicDef<CapabilityRecord>
   /** The available application configuration modules. */
   'applications.config': StateTopicDef<ApplicationConfig[] | null>
+  /** The foreground application's context, or `null` when it has published none. */
+  'applications.context': StateTopicDef<
+    (ApplicationContext & {readonly appId: Application['id']}) | null
+  >
+  /** Publishes the sending application's context. `null` clears it. Fire-and-forget. */
+  'applications.context.update': EventTopicDef<ApplicationContext | null>
   /** The foreground application ID, or `null` on dashboard-level routes. */
   'applications.foreground': StateTopicDef<Application['id'] | null>
   /** The dashboard applications available to the current user. */
@@ -208,8 +278,12 @@ type DashboardTopicManifest = {
  * @internal
  */
 export const DASHBOARD_TOPIC_MANIFEST: DashboardTopicManifest = {
+  'applications.activity': dashboardEvent,
   'applications.base-path': stateTopic(undefined),
+  'applications.capabilities': stateTopic(undefined),
   'applications.config': stateTopic(undefined),
+  'applications.context': stateTopic(undefined),
+  'applications.context.update': dashboardEvent,
   'applications.foreground': stateTopic(undefined),
   'applications.list': stateTopic(undefined),
   'applications.status.update': dashboardEvent,

package/src/document/documentConstants.ts

@@ -19,11 +19,14 @@ export const API_VERSION = 'v2025-05-06'
 export const UNVERIFIED_REVISION_RETENTION_TIME = 30_000
 
 /**
- * Base delay (ms) before retrying a document listener after an `OutOfSyncError`.
- * Backoff doubles on each successive retry, capped at {@link OUT_OF_SYNC_RETRY_MAX_DELAY}.
+ * Base delay (ms) before retrying a document listener after a transient failure
+ * (an `OutOfSyncError`, a 5xx response, 408 or 429). Backoff doubles on each
+ * successive retry, capped at {@link OUT_OF_SYNC_RETRY_MAX_DELAY}, and gives up
+ * after {@link OUT_OF_SYNC_RETRY_COUNT} retries so a lasting failure surfaces.
  */
 export const OUT_OF_SYNC_RETRY_BASE_DELAY = 500
 export const OUT_OF_SYNC_RETRY_MAX_DELAY = 10_000
+export const OUT_OF_SYNC_RETRY_COUNT = 5
 
 /**
  * Base delay (ms) before retrying the dataset ACL fetch after a transient

package/src/document/documentStore.test.ts

@@ -10,6 +10,7 @@ import {
   type RawQueryResponse,
   type ResponseQueryOptions,
   type SanityClient,
+  ServerError,
   type SingleActionResult,
   type UnfilteredResponseQueryOptions,
   type WelcomeEvent,
@@ -43,9 +44,11 @@ import {
   discardDocument,
   editDocument,
   publishDocument,
+  publishRelease,
   unpublishDocument,
 } from './actions'
 import {applyDocumentActions} from './applyDocumentActions'
+import {OUT_OF_SYNC_RETRY_COUNT} from './documentConstants'
 import {
   getDocumentState,
   getDocumentSyncStatus,
@@ -1403,6 +1406,7 @@ vi.mock('./documentConstants.ts', async (importOriginal) => {
     DOCUMENT_STATE_CLEAR_DELAY: 25,
     OUT_OF_SYNC_RETRY_BASE_DELAY: 0,
     OUT_OF_SYNC_RETRY_MAX_DELAY: 0,
+    OUT_OF_SYNC_RETRY_COUNT: 2,
     ACL_RETRY_BASE_DELAY: 0,
     ACL_RETRY_MAX_DELAY: 0,
   }
@@ -1809,3 +1813,193 @@ beforeEach(() => {
   } as SanityClient
   client$.next(client)
 })
+
+it('resolves a readable document while another in the same dataset is inaccessible due to permissions', async () => {
+  const readableId = DocumentId('doc-readable')
+  const blockedId = DocumentId('doc-blocked')
+
+  vi.mocked(createFetchDocument).mockReturnValue(
+    vi.fn((id) =>
+      (id === blockedId
+        ? throwError(
+            () =>
+              new Error(`Document with ID \`${blockedId}\` is inaccessible due to permissions.`),
+          )
+        : of({_id: id, _type: 'article', _rev: 'rev-1'} as SanityDocument)
+      ).pipe(delay(0)),
+    ),
+  )
+
+  const readable = getDocumentState<TestDocument>(instance, {
+    documentId: readableId,
+    documentType: 'article',
+    liveEdit: true,
+  })
+  const blocked = getDocumentState<TestDocument>(instance, {
+    documentId: blockedId,
+    documentType: 'article',
+    liveEdit: true,
+  })
+
+  const unsubscribeReadable = readable.subscribe()
+  const unsubscribeBlocked = blocked.subscribe()
+
+  await vi.waitFor(() => expect(readable.getCurrent()).toMatchObject({_id: readableId}))
+  await expect(firstValueFrom(blocked.observable)).rejects.toThrow(
+    'Document with ID `doc-blocked` is inaccessible due to permissions.',
+  )
+
+  unsubscribeReadable()
+  unsubscribeBlocked()
+})
+
+it('reports an inaccessible draft to the document that reads it', async () => {
+  const documentId = DocumentId('doc-with-blocked-draft')
+  const draftId = getDraftId(documentId)
+  const message = `Document with ID \`${draftId}\` is inaccessible due to permissions.`
+
+  vi.mocked(createFetchDocument).mockReturnValue(
+    vi.fn((id) =>
+      (id === draftId
+        ? throwError(() => new Error(message))
+        : of({_id: id, _type: 'article', _rev: 'rev-1'} as SanityDocument)
+      ).pipe(delay(0)),
+    ),
+  )
+
+  const doc = createDocumentHandle({documentId, documentType: 'article'})
+
+  await expect(resolveDocument(instance, doc)).rejects.toThrow(message)
+  await expect(
+    firstValueFrom(
+      getDocumentSyncStatus(instance, doc).observable.pipe(first((value) => value !== undefined)),
+    ),
+  ).rejects.toThrow(message)
+})
+
+it('fails a write to a document it cannot read instead of waiting for it', async () => {
+  const documentId = DocumentId('doc-with-blocked-draft-write')
+  const draftId = getDraftId(documentId)
+  const message = `Document with ID \`${draftId}\` is inaccessible due to permissions.`
+
+  vi.mocked(createFetchDocument).mockReturnValue(
+    vi.fn((id) =>
+      (id === draftId
+        ? throwError(() => new Error(message))
+        : of({_id: id, _type: 'article', _rev: 'rev-1'} as SanityDocument)
+      ).pipe(delay(0)),
+    ),
+  )
+
+  const doc = createDocumentHandle({documentId, documentType: 'article'})
+
+  await expect(
+    applyDocumentActions(instance, {
+      actions: [editDocument(doc, {set: {title: 'Edited'}})],
+      resource,
+    }),
+  ).rejects.toThrow(message)
+})
+
+it('reads a document again after the server fails once', async () => {
+  const documentId = DocumentId('doc-with-flaky-read')
+  const draftId = getDraftId(documentId)
+  let thrown = 0
+
+  vi.mocked(createFetchDocument).mockReturnValue(
+    vi.fn((id) =>
+      defer(() => {
+        if (id === draftId && thrown === 0) {
+          thrown++
+          return throwError(() => new ServerError({statusCode: 503, headers: {}, body: {}}))
+        }
+        return of({_id: id, _type: 'article', _rev: 'rev-1'} as SanityDocument)
+      }).pipe(delay(0)),
+    ),
+  )
+
+  const doc = createDocumentHandle({documentId, documentType: 'article'})
+
+  await expect(resolveDocument(instance, doc)).resolves.toMatchObject({_id: draftId})
+  expect(thrown).toBe(1)
+})
+
+it('fails a release action whose release document cannot be read', async () => {
+  const releaseId = 'blocked-release'
+  const releaseDocumentId = `_.releases.${releaseId}`
+  const message = `Document with ID \`${releaseDocumentId}\` is inaccessible due to permissions.`
+
+  vi.mocked(createFetchDocument).mockReturnValue(
+    vi.fn((id) =>
+      (id === releaseDocumentId
+        ? throwError(() => new Error(message))
+        : of({_id: id, _type: 'article', _rev: 'rev-1'} as SanityDocument)
+      ).pipe(delay(0)),
+    ),
+  )
+
+  await expect(
+    applyDocumentActions(instance, {
+      actions: [publishRelease({releaseId})],
+      resource,
+    }),
+  ).rejects.toThrow(message)
+})
+
+it('gives up on a read that keeps failing rather than loading forever', async () => {
+  const documentId = DocumentId('doc-with-failing-read')
+  const draftId = getDraftId(documentId)
+  let attempts = 0
+
+  vi.mocked(createFetchDocument).mockReturnValue(
+    vi.fn((id) =>
+      defer(() => {
+        if (id !== draftId) return of({_id: id, _type: 'article', _rev: 'rev-1'} as SanityDocument)
+        attempts++
+        return throwError(() => new ServerError({statusCode: 503, headers: {}, body: {}}))
+      }).pipe(delay(0)),
+    ),
+  )
+
+  const doc = createDocumentHandle({documentId, documentType: 'article'})
+
+  await expect(resolveDocument(instance, doc)).rejects.toThrow(ServerError)
+  expect(attempts).toBe(3)
+})
+
+it('keeps its retry budget per failure, not per listener', async () => {
+  const documentId = DocumentId('doc-with-flaky-listener')
+  const draftId = getDraftId(documentId)
+  let calls = 0
+
+  vi.mocked(createFetchDocument).mockReturnValue(
+    vi.fn((id) =>
+      defer(() => {
+        if (id !== draftId) return of({_id: id, _type: 'article', _rev: 'rev-1'} as SanityDocument)
+        calls++
+        // every read fails once before it succeeds
+        return calls % 2 === 1
+          ? throwError(() => new ServerError({statusCode: 503, headers: {}, body: {}}))
+          : of({_id: id, _type: 'article', _rev: `rev-${calls}`} as SanityDocument)
+      }).pipe(delay(0)),
+    ),
+  )
+
+  const doc = createDocumentHandle({documentId, documentType: 'article'})
+  const documentState = getDocumentState<TestDocument>(instance, doc)
+  const unsubscribe = documentState.subscribe()
+  await vi.waitFor(() => expect(documentState.getCurrent()).toMatchObject({_id: draftId}))
+
+  const sharedListener = (
+    createSharedListener as unknown as () => {events: Subject<ListenEvent<SanityDocument>>}
+  )()
+  // more failure streaks than the budget, each one recovering in between
+  for (let attempt = 0; attempt < OUT_OF_SYNC_RETRY_COUNT + 2; attempt++) {
+    const seen = calls
+    sharedListener.events.next({type: 'reset'})
+    await vi.waitFor(() => expect(calls).toBeGreaterThan(seen + 1))
+  }
+
+  expect(() => documentState.getCurrent()).not.toThrow()
+  unsubscribe()
+})