@sanity/sdk 3.1.0 → 3.3.0-rc.0

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

@@ -0,0 +1,142 @@
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {createSanityInstance} from '../../store/createSanityInstance'
+import {type MessageBusConnection} from './bus'
+import {getDashboardMessageBus, isDashboardEnvironment} from './store'
+
+const bus = vi.hoisted(() => ({
+  connect: vi.fn(),
+  installed: vi.fn(),
+}))
+
+vi.mock('./bus', () => ({
+  connectMessageBus: bus.connect,
+  isMessageBusInstalled: bus.installed,
+}))
+
+interface FakeConnection extends MessageBusConnection {
+  moduleId?: string
+  disconnected: boolean
+}
+
+const createFakeConnection = (moduleId?: string): FakeConnection => {
+  const connection = {
+    moduleId,
+    disconnected: false,
+    disconnect: () => {
+      connection.disconnected = true
+    },
+  } as FakeConnection
+  return connection
+}
+
+const config = {projectId: 'p', dataset: 'd'}
+
+describe('dashboard message bus store', () => {
+  beforeEach(() => {
+    bus.connect.mockReset()
+    bus.installed.mockReset()
+    bus.installed.mockReturnValue(true)
+    bus.connect.mockImplementation((options?: {moduleId?: string}) =>
+      createFakeConnection(options?.moduleId),
+    )
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('connects one bus per instance with distinct module identity', () => {
+    const a = createSanityInstance(config)
+    const b = createSanityInstance(config)
+
+    const busA = getDashboardMessageBus(a, 'favorites/views/list/main') as FakeConnection
+    const busB = getDashboardMessageBus(b, 'favorites/views/list/panel') as FakeConnection
+
+    expect(busA).not.toBe(busB)
+    expect(busA.moduleId).toBe('favorites/views/list/main')
+    expect(busB.moduleId).toBe('favorites/views/list/panel')
+    expect(bus.connect).toHaveBeenCalledTimes(2)
+
+    a.dispose()
+    b.dispose()
+  })
+
+  it('reuses the cached connection for the same instance', () => {
+    const instance = createSanityInstance(config)
+
+    const first = getDashboardMessageBus(instance)
+    const second = getDashboardMessageBus(instance)
+
+    expect(first).toBe(second)
+    expect(bus.connect).toHaveBeenCalledOnce()
+
+    instance.dispose()
+  })
+
+  it('forwards an absent module id so the bus applies its app id fallback', () => {
+    const instance = createSanityInstance(config)
+
+    getDashboardMessageBus(instance)
+
+    // The fallback itself lives in connectApplicationToMessageBus (covered in bus.test.ts);
+    // the store's job is only to pass the option through unchanged.
+    expect(bus.connect).toHaveBeenCalledWith({moduleId: undefined})
+
+    instance.dispose()
+  })
+
+  it('does not cache a failed connection', () => {
+    const instance = createSanityInstance(config)
+    bus.connect.mockReturnValue(undefined)
+
+    expect(getDashboardMessageBus(instance)).toBeUndefined()
+
+    // A failed connect is not cached, so a later successful connect still lands.
+    bus.connect.mockImplementation((options?: {moduleId?: string}) =>
+      createFakeConnection(options?.moduleId),
+    )
+    expect(getDashboardMessageBus(instance)).toBeDefined()
+
+    instance.dispose()
+  })
+
+  it('disconnects only the disposed instance', () => {
+    const a = createSanityInstance(config)
+    const b = createSanityInstance(config)
+
+    const busA = getDashboardMessageBus(a) as FakeConnection
+    const busB = getDashboardMessageBus(b) as FakeConnection
+
+    a.dispose()
+
+    expect(busA.disconnected).toBe(true)
+    expect(busB.disconnected).toBe(false)
+
+    b.dispose()
+    expect(busB.disconnected).toBe(true)
+  })
+
+  it('returns undefined without caching when no bus is installed, then connects later', () => {
+    const instance = createSanityInstance(config)
+    bus.installed.mockReturnValue(false)
+
+    expect(getDashboardMessageBus(instance)).toBeUndefined()
+    expect(bus.connect).not.toHaveBeenCalled()
+
+    bus.installed.mockReturnValue(true)
+    expect(getDashboardMessageBus(instance)).toBeDefined()
+    expect(bus.connect).toHaveBeenCalledOnce()
+
+    instance.dispose()
+  })
+
+  it('reports the dashboard environment as soon as a host bus is installed', () => {
+    bus.installed.mockReturnValue(false)
+    expect(isDashboardEnvironment()).toBe(false)
+
+    // Before any instance connects: the host owns the session regardless.
+    bus.installed.mockReturnValue(true)
+    expect(isDashboardEnvironment()).toBe(true)
+  })
+})

package/src/dashboard/messageBus/store.ts

@@ -0,0 +1,74 @@
+import {createActionBinder} from '../../store/createActionBinder'
+import {type SanityInstance} from '../../store/createSanityInstance'
+import {defineStore} from '../../store/defineStore'
+import {connectMessageBus, isMessageBusInstalled, type MessageBusConnection} from './bus'
+
+interface DashboardMessageBusState {
+  connection?: MessageBusConnection
+}
+
+const bindActionByInstance = createActionBinder<{name: string}, [moduleId?: string]>(
+  (instance) => ({name: instance.instanceId}),
+)
+
+const dashboardMessageBusStore = defineStore<DashboardMessageBusState>({
+  name: 'dashboardMessageBus',
+  getInitialState: () => ({}),
+  // Runs when the instance is disposed, tearing down this window's connection.
+  initialize:
+    ({state}) =>
+    () =>
+      state.get().connection?.disconnect(),
+})
+
+/**
+ * Returns the message bus connection for this instance, connecting on first call.
+ *
+ * @remarks
+ * One connection is made per {@link SanityInstance}, carrying that window's
+ * module identity. The first caller wins; later callers get the cached
+ * connection. When no host bus is installed it returns `undefined` without
+ * caching, so a later call retries once a host installs the bus.
+ * @internal
+ */
+export const getDashboardMessageBus = bindActionByInstance(
+  dashboardMessageBusStore,
+  ({state}, moduleId?: string): MessageBusConnection | undefined => {
+    const current = state.get().connection
+    if (current) return current
+    if (!isMessageBusInstalled()) return undefined
+    const connection = connectMessageBus({moduleId})
+    if (!connection) return undefined
+    state.set('connect', {connection})
+    return connection
+  },
+)
+
+/**
+ * Returns the instance's message bus connection, or throws when no dashboard host has
+ * installed a bus. `action` names what the caller was about to do, e.g. `read topic "x"`.
+ * @internal
+ */
+export function requireDashboardMessageBus(
+  instance: SanityInstance,
+  action: string,
+): MessageBusConnection {
+  const messageBus = getDashboardMessageBus(instance)
+  if (!messageBus) {
+    throw new Error(`Cannot ${action} without an installed dashboard message bus`)
+  }
+  return messageBus
+}
+
+/**
+ * Returns whether a dashboard host has installed a message bus.
+ *
+ * @remarks
+ * Answers "does a host own this session", not "has this instance connected yet". Callers
+ * such as the login redirect run before {@link getDashboardMessageBus} has been called for
+ * the instance, so this must not depend on the connection state.
+ * @internal
+ */
+export function isDashboardEnvironment(): boolean {
+  return isMessageBusInstalled()
+}

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

@@ -0,0 +1,172 @@
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {createSanityInstance, type SanityInstance} from '../../store/createSanityInstance'
+import {
+  installMessageBus,
+  type MessageBus,
+  MessageBusError,
+  type MessageBusHost,
+  resetMessageBus,
+} from './bus'
+import {getDashboardMessageBus} from './store'
+import {getTopicState, resolveTopic, TopicError} from './topicStore'
+
+const MESSAGE_BUS_KEY = Symbol.for('sanity.os.bus')
+
+let host: MessageBusHost
+let instance: SanityInstance
+
+const advance = (ms: number) => vi.advanceTimersByTimeAsync(ms)
+
+describe('dashboard topic store', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    vi.stubGlobal('__SANITY_APP_ID__', 'app')
+    host = installMessageBus({appId: 'dashboard'})
+    instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+  })
+
+  afterEach(() => {
+    instance.dispose()
+    resetMessageBus()
+    delete (globalThis as {[MESSAGE_BUS_KEY]?: unknown})[MESSAGE_BUS_KEY]
+    vi.unstubAllGlobals()
+    vi.useRealTimers()
+  })
+
+  it('reads the current value from the bus and unwraps topic results', () => {
+    expect(getTopicState(instance, 'applications.foreground').getCurrent()).toBeUndefined()
+    host.connections.subscribe((client) => client.emit('applications.foreground', null))
+    expect(getTopicState(instance, 'applications.foreground').getCurrent()).toBeNull()
+
+    host.connections.subscribe((client) => client.emit('applications.list', {ok: true, value: []}))
+    expect(getTopicState(instance, 'applications.list').getCurrent()).toEqual([])
+
+    host.connections.subscribe((client) => client.emit('applications.list', {ok: false}))
+    expect(() => getTopicState(instance, 'applications.list').getCurrent()).toThrow(TopicError)
+  })
+
+  it('notifies subscribers when the topic publishes', () => {
+    const onChange = vi.fn()
+    const unsubscribe = getTopicState(instance, 'auth.token').subscribe(onChange)
+
+    host.connections.subscribe((client) => client.emit('auth.token', 'token'))
+
+    expect(onChange).toHaveBeenCalledTimes(1)
+    expect(getTopicState(instance, 'auth.token').getCurrent()).toBe('token')
+    unsubscribe()
+  })
+
+  it('shares one query across pending reads of the same topic', () => {
+    const query = vi.spyOn(getDashboardMessageBus(instance) as MessageBus, 'query')
+
+    const first = resolveTopic(instance, 'auth.token')
+    const second = resolveTopic(instance, 'auth.token')
+
+    expect(second).toBe(first)
+    expect(query).toHaveBeenCalledTimes(1)
+  })
+
+  it('records a query failure, then drops it with its last reader', async () => {
+    const pending = resolveTopic(instance, 'auth.token')
+    await advance(5000)
+    await pending
+
+    expect(() => getTopicState(instance, 'auth.token').getCurrent()).toThrow(
+      expect.objectContaining({code: 'TIMEOUT'}) as MessageBusError,
+    )
+
+    // The temporary reader is released after the grace period; nothing else holds the entry.
+    await advance(1000)
+
+    expect(getTopicState(instance, 'auth.token').getCurrent()).toBeUndefined()
+  })
+
+  it('returns a value published inside the grace window instead of the recorded failure', async () => {
+    const pending = resolveTopic(instance, 'auth.token')
+    await advance(5000)
+    await pending
+    expect(() => getTopicState(instance, 'auth.token').getCurrent()).toThrow(MessageBusError)
+
+    // The temporary reader still holds the entry; a publish must win over its stale failure.
+    host.connections.subscribe((client) => client.emit('auth.token', 'token'))
+
+    expect(getTopicState(instance, 'auth.token').getCurrent()).toBe('token')
+  })
+
+  it('keeps a pending query alive after its readers leave, so its failure lands on its own entry', async () => {
+    const unsubscribe = getTopicState(instance, 'auth.token').subscribe()
+    const first = resolveTopic(instance, 'auth.token')
+    unsubscribe()
+    await advance(1000)
+
+    // Still pending: a new reader joins the same query rather than starting another.
+    expect(resolveTopic(instance, 'auth.token')).toBe(first)
+
+    await advance(4000)
+    await first
+    expect(() => getTopicState(instance, 'auth.token').getCurrent()).toThrow(
+      expect.objectContaining({code: 'TIMEOUT'}) as MessageBusError,
+    )
+  })
+
+  it('keeps the entry while any reader remains', async () => {
+    const leaveA = getTopicState(instance, 'auth.token').subscribe()
+    const leaveB = getTopicState(instance, 'auth.token').subscribe()
+    const pending = resolveTopic(instance, 'auth.token')
+
+    leaveA()
+    await advance(1000)
+    expect(resolveTopic(instance, 'auth.token')).toBe(pending)
+
+    leaveB()
+    await advance(1000)
+    // Only the query's own temporary reader is left, and that is enough.
+    expect(resolveTopic(instance, 'auth.token')).toBe(pending)
+  })
+
+  it('surfaces a query failure to subscribers and ends their subscription', async () => {
+    const onChange = vi.fn()
+    getTopicState(instance, 'auth.token').subscribe(onChange)
+    const pending = resolveTopic(instance, 'auth.token')
+    await advance(5000)
+    await pending
+
+    expect(onChange).toHaveBeenCalledTimes(1)
+    expect(() => getTopicState(instance, 'auth.token').getCurrent()).toThrow(MessageBusError)
+
+    // The failed subscriber is gone: a later publish no longer reaches it, and once the
+    // temporary reader is released a fresh read sees the value cleanly.
+    await advance(1000)
+    host.connections.subscribe((client) => client.emit('auth.token', 'token'))
+
+    expect(onChange).toHaveBeenCalledTimes(1)
+    expect(getTopicState(instance, 'auth.token').getCurrent()).toBe('token')
+  })
+
+  it('reads the value written to this instance connection only', () => {
+    const other = createSanityInstance({projectId: 'p', dataset: 'd'})
+    // Connect both instances (module ids come from the first store call) before writing.
+    getDashboardMessageBus(instance, 'module-a')
+    getDashboardMessageBus(other, 'module-b')
+    host.connections.subscribe((client) => {
+      if (client.moduleId === 'module-a') client.emit('auth.token', 'tok-a')
+      if (client.moduleId === 'module-b') client.emit('auth.token', 'tok-b')
+    })
+
+    expect(getTopicState(instance, 'auth.token').getCurrent()).toBe('tok-a')
+    expect(getTopicState(other, 'auth.token').getCurrent()).toBe('tok-b')
+    other.dispose()
+  })
+
+  it('throws without an installed message bus', () => {
+    resetMessageBus()
+    delete (globalThis as {[MESSAGE_BUS_KEY]?: unknown})[MESSAGE_BUS_KEY]
+    const other = createSanityInstance({projectId: 'p', dataset: 'd'})
+
+    expect(() => getTopicState(other, 'auth.token').getCurrent()).toThrow(
+      'Cannot read topic "auth.token" without an installed dashboard message bus',
+    )
+    other.dispose()
+  })
+})

package/src/dashboard/messageBus/topicStore.ts

@@ -0,0 +1,184 @@
+import {createActionBinder} from '../../store/createActionBinder'
+import {type SanityInstance} from '../../store/createSanityInstance'
+import {createStateSourceAction} from '../../store/createStateSourceAction'
+import {defineStore} from '../../store/defineStore'
+import {setCleanupTimeout} from '../../utils/setCleanupTimeout'
+import {type MessageBus, type MessageBusStateSource} from './bus'
+import {requireDashboardMessageBus} from './store'
+import {type StateTopic, type ValueOf} from './topics'
+
+/**
+ * An error raised when a dashboard state topic reports failure.
+ * @public
+ */
+export class TopicError extends Error {
+  /** The topic that failed. */
+  readonly topic: StateTopic
+
+  /** Creates an error for a failed topic. */
+  constructor(topic: StateTopic) {
+    super(`Topic "${topic}" failed`)
+    this.name = 'TopicError'
+    this.topic = topic
+  }
+}
+
+/**
+ * The value of a state topic, with `TopicResult` wrappers unwrapped to their success value.
+ * @public
+ */
+export type TopicData<K extends StateTopic> =
+  ValueOf<K> extends infer Value
+    ? Value extends {ok: true; value: infer Success}
+      ? Success
+      : Value extends {ok: false}
+        ? never
+        : Value
+    : never
+
+// Mirrors the `TopicResult` shape declared in the topic manifest; no plain-value topic has an `ok` field.
+function isTopicResult(value: unknown): value is {ok: boolean; value?: unknown} {
+  return (
+    typeof value === 'object' && value !== null && 'ok' in value && typeof value.ok === 'boolean'
+  )
+}
+
+function unwrapTopicResult(topic: StateTopic, value: unknown): unknown {
+  if (!isTopicResult(value)) return value
+  if (!value.ok) throw new TopicError(topic)
+  return value.value
+}
+
+interface TopicEntry {
+  /** Why the first-value query failed. Dropped with the entry when its last subscriber leaves. */
+  error?: unknown
+  /** The in-flight first-value query, shared by every suspended render of the topic. */
+  pending?: Promise<void>
+  subscribers: number
+}
+
+interface DashboardTopicsState {
+  topics: {[topic: string]: TopicEntry}
+}
+
+// Matches the query store: a suspended component re-renders after its promise settles before
+// the temporary subscriber is released, so it still sees the recorded failure.
+const TOPIC_STATE_CLEAR_DELAY = 1000
+
+const bindActionByInstance = createActionBinder<{name: string}, [topic: StateTopic]>(
+  (instance) => ({name: instance.instanceId}),
+)
+
+// The bus is the source of truth for topic values (it already keeps one replaying source per
+// topic). This store only tracks what the bus cannot: read failures and who is still reading.
+const dashboardTopicsStore = defineStore<DashboardTopicsState>({
+  name: 'dashboardTopics',
+  getInitialState: () => ({topics: {}}),
+})
+
+const getMessageBus = (instance: SanityInstance, topic: StateTopic): MessageBus =>
+  requireDashboardMessageBus(instance, `read topic "${topic}"`)
+
+function getSource(instance: SanityInstance, topic: StateTopic): MessageBusStateSource<unknown> {
+  return getMessageBus(instance, topic).subscribe(topic)
+}
+
+// An entry lives as long as it has subscribers. Dropping it with the last one is what gives a
+// later mount a fresh deadline instead of a stale failure.
+const updateEntry =
+  (topic: string, update: (entry: TopicEntry) => TopicEntry) =>
+  (state: DashboardTopicsState): DashboardTopicsState => {
+    const {[topic]: entry = {subscribers: 0}, ...rest} = state.topics
+    const next = update(entry)
+    return {topics: next.subscribers > 0 ? {...rest, [topic]: next} : rest}
+  }
+
+const addSubscriber = (topic: string) =>
+  updateEntry(topic, (entry) => ({...entry, subscribers: entry.subscribers + 1}))
+
+const removeSubscriber = (topic: string) =>
+  updateEntry(topic, (entry) => ({...entry, subscribers: entry.subscribers - 1}))
+
+/**
+ * A state source for a dashboard state topic, with `TopicResult` wrappers unwrapped.
+ *
+ * @remarks
+ * Returns `undefined` until the topic publishes; use {@link resolveTopic} to wait for that
+ * first value. While the topic is still unpublished, reading throws the failure that
+ * {@link resolveTopic} recorded. A published value takes precedence over a recorded failure,
+ * and a {@link TopicError} is thrown when the topic itself reports failure. A thrown failure
+ * ends the subscription, so a reader recovers by subscribing again.
+ * @internal
+ */
+export const getTopicState = bindActionByInstance(
+  dashboardTopicsStore,
+  createStateSourceAction({
+    selector: ({state, instance}, topic: StateTopic) => {
+      const current = getSource(instance, topic).getCurrent()
+      // A recorded failure only describes the wait for a first value; a published value wins.
+      const entry = state.topics[topic]
+      if (current === undefined && entry?.error) throw entry.error
+      return unwrapTopicResult(topic, current)
+    },
+    onSubscribe: ({state, instance}, topic: StateTopic) => {
+      state.set('addSubscriber', addSubscriber(topic))
+      // Each publish writes a fresh state object so the selector re-runs against the bus.
+      const subscription = getSource(instance, topic).subscribe(() =>
+        state.set(
+          'publish',
+          updateEntry(topic, (entry) => ({...entry})),
+        ),
+      )
+      return () => {
+        subscription.unsubscribe()
+        setCleanupTimeout(
+          () => state.set('removeSubscriber', removeSubscriber(topic)),
+          TOPIC_STATE_CLEAR_DELAY,
+        )
+      }
+    },
+  }),
+)
+
+/**
+ * Resolves once a dashboard state topic has published, or records the failure for
+ * {@link getTopicState} to throw. Repeated calls for a pending topic share one query.
+ *
+ * @remarks
+ * Holds a temporary subscriber while the query is in flight so a failure recorded after the
+ * reading component has gone is dropped with it, rather than thrown at the next mount.
+ * @internal
+ */
+export const resolveTopic = bindActionByInstance(
+  dashboardTopicsStore,
+  ({state, instance}, topic: StateTopic): Promise<void> => {
+    const existing = state.get().topics[topic]?.pending
+    if (existing) return existing
+
+    const release = () =>
+      setCleanupTimeout(
+        () => state.set('removeSubscriber', removeSubscriber(topic)),
+        TOPIC_STATE_CLEAR_DELAY,
+      )
+    const pending = getMessageBus(instance, topic)
+      .query(topic)
+      .then(
+        () =>
+          state.set(
+            'resolved',
+            updateEntry(topic, ({pending: _pending, ...entry}) => entry),
+          ),
+        (error: unknown) =>
+          state.set(
+            'failed',
+            updateEntry(topic, ({pending: _pending, ...entry}) => ({...entry, error})),
+          ),
+      )
+    pending.then(release, release)
+    state.set(
+      'query',
+      updateEntry(topic, (entry) => ({...entry, pending, subscribers: entry.subscribers + 1})),
+    )
+    return pending
+  },
+)

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

@@ -0,0 +1,71 @@
+import {describe, expectTypeOf, it} from 'vitest'
+
+import {type Application, type ApplicationInclude} from '../../applications/applications'
+import {type MessageBus} from './bus'
+import {
+  type ApplicationConfig,
+  type ApplicationConfigAppType,
+  type PayloadOf,
+  type ReplyOf,
+  type StateTopic,
+  type TopicResult,
+  type ValueOf,
+} from './topics'
+
+type IsStateTopic<Topic> = Topic extends StateTopic ? true : false
+type ListedApplication = Extract<
+  NonNullable<ValueOf<'applications.list'>>,
+  {ok: true}
+>['value'][number]
+type ListedInterface = NonNullable<
+  NonNullable<ListedApplication['activeDeployment']>['interfaces']
+>[number]
+
+describe('dashboard topic types', () => {
+  it('distinguishes state and event topics', () => {
+    expectTypeOf<IsStateTopic<'applications.foreground'>>().toEqualTypeOf<true>()
+    expectTypeOf<IsStateTopic<'auth.token.refresh'>>().toEqualTypeOf<false>()
+    expectTypeOf<Parameters<MessageBus['query']>[0]>().toEqualTypeOf<StateTopic>()
+  })
+
+  it('exposes application state values', () => {
+    expectTypeOf<ValueOf<'applications.config'>>().toEqualTypeOf<ApplicationConfig[] | null>()
+    expectTypeOf<ValueOf<'applications.list'>>().toEqualTypeOf<TopicResult<
+      Application<ApplicationInclude>[]
+    > | null>()
+    expectTypeOf<Extract<ListedInterface, {type: 'tile'}>['metadata']>().toEqualTypeOf<{
+      order?: number
+      size: 'small' | 'large' | 'banner'
+    }>()
+    expectTypeOf<Extract<ListedInterface, {type: 'panel'}>['metadata']>().toEqualTypeOf<{
+      dock?: {group?: string; order?: number}
+    } | null>()
+    expectTypeOf<ValueOf<'applications.foreground'>>().toEqualTypeOf<Application['id'] | null>()
+  })
+
+  it('keeps appType open for forward compatibility without collapsing to string', () => {
+    expectTypeOf<'media-library'>().toMatchTypeOf<ApplicationConfigAppType>()
+    // Guards the `& {}` trick: a plain `string` here would drop known-value autocomplete.
+    expectTypeOf<ApplicationConfigAppType>().not.toEqualTypeOf<string>()
+  })
+
+  it('exposes event payload and reply values', () => {
+    expectTypeOf<PayloadOf<'navigation.location.update'>>().toEqualTypeOf<{
+      url: string
+      history?: 'push' | 'replace'
+    }>()
+    expectTypeOf<ReplyOf<'navigation.location.update'>>().toEqualTypeOf<
+      {ok: true} | {ok: false; reason: 'not-navigable' | 'interrupted' | 'failed'}
+    >()
+  })
+
+  it('requires payloads only for events that declare one', () => {
+    const messageBus = {emit: () => undefined} as unknown as MessageBus
+
+    messageBus.emit('auth.token.refresh')
+    messageBus.emit('auth.token.refresh', undefined, {timeout: null})
+    messageBus.emit('navigation.location.update', {url: '/'})
+    // @ts-expect-error navigation.location.update requires a payload
+    messageBus.emit('navigation.location.update')
+  })
+})