@morscherlab/mint-sdk 1.3.9 → 1.4.0-beta.1

package/src/__tests__/composables/usePlatform.test.ts

@@ -0,0 +1,102 @@
+import { beforeEach, afterEach, describe, expect, expectTypeOf, it } from 'vitest'
+
+import { usePlatform } from '../../composables/usePlatform'
+import type { PlatformContext } from '../../types'
+
+type InjectedPlatformWindow = Window & {
+  __MINT_PLATFORM__?: PlatformContext
+}
+
+describe('usePlatform', () => {
+  it('uses integer IDs for injected users', () => {
+    expectTypeOf<NonNullable<PlatformContext['user']>['id']>().toEqualTypeOf<number>()
+  })
+
+  beforeEach(() => {
+    delete (window as InjectedPlatformWindow).__MINT_PLATFORM__
+  })
+
+  afterEach(() => {
+    delete (window as InjectedPlatformWindow).__MINT_PLATFORM__
+  })
+
+  it('should preserve the settings API capability when the platform injects it', () => {
+    const injectedContext: PlatformContext = {
+      isIntegrated: true,
+      theme: 'light',
+      platformApiUrl: '/api',
+      plugin: {
+        id: 'test-plugin',
+        name: 'test-plugin',
+        version: '1.0.0',
+        display_name: 'test-plugin',
+        plugin_type: 'analysis',
+        route_prefix: '/test-plugin',
+        api_prefix: '/api/test-plugin',
+        settings_api: 'plugin',
+      },
+    }
+    ;(window as InjectedPlatformWindow).__MINT_PLATFORM__ = injectedContext
+
+    const context = usePlatform()
+
+    expect(context.plugin.value?.settings_api).toBe('plugin')
+  })
+
+  it('should read the theme from the SDK settings when the platform injects no theme', () => {
+    localStorage.setItem('mint-settings', JSON.stringify({ theme: 'dark' }))
+    ;(window as Window & { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
+      contextVersion: 1, isIntegrated: true, platformOrigin: 'http://mint.test', platformApiUrl: '/api', features: {},
+    }
+
+    try {
+      expect(usePlatform().theme.value).toBe('dark')
+    } finally {
+      localStorage.removeItem('mint-settings')
+    }
+  })
+
+  const role = (permissions: string[], plugin_access: string[] | 'all' | null = null) => ({
+    id: 2,
+    slug: 'member',
+    name: 'Member',
+    color: '#6B7280',
+    permissions,
+    project_scope: 'all',
+    plugin_access,
+  })
+
+  it.each([
+    ['admin', 'an administrator', { role: 'admin', role_obj: role([]) }, true],
+    ['use', 'a member', { role: 'member', role_obj: role(['plugins.use']) }, true],
+    ['use', 'a member without plugins.use', { role: 'member', role_obj: role([]) }, false],
+    ['use', 'a member whose role cannot see the plugin', { role: 'member', role_obj: role(['plugins.use'], ['other']) }, false],
+    ['use', 'a member whose role lists the plugin', { role: 'member', role_obj: role(['plugins.use'], ['test-plugin']) }, true],
+    ['use', 'a member whose role lists the route prefix', { role: 'member', role_obj: role(['plugins.use'], ['test']) }, true],
+    ['configure', 'a member without plugins.configure', { role: 'member', role_obj: role(['plugins.use']) }, false],
+    ['configure', 'a configuring member', { role: 'member', role_obj: role(['plugins.use', 'plugins.configure']) }, true],
+    ['admin', 'a configuring member', { role: 'member', role_obj: role(['plugins.use', 'plugins.configure']) }, false],
+  ] as const)('should decide can(%s) when the caller is %s, outside a mounted component', (access, _label, user, expected) => {
+    ;(window as InjectedPlatformWindow).__MINT_PLATFORM__ = {
+      isIntegrated: true,
+      theme: 'light',
+      authRequired: true,
+      plugin: {
+        id: 'test-plugin', name: 'test-plugin', display_name: 'test-plugin', version: '1.0.0', plugin_type: 'analysis',
+        route_prefix: '/test', api_prefix: '/api/test', settings_api: 'platform',
+      },
+      user: { id: 1, username: 'ada', ...user },
+    }
+
+    expect(usePlatform().can(access)).toBe(expected)
+  })
+
+  it.each([
+    [false, true],
+    [true, false],
+  ])('should decide can(admin) with no signed-in user when authRequired is %s', (authRequired, expected) => {
+    ;(window as InjectedPlatformWindow).__MINT_PLATFORM__ = { isIntegrated: true, theme: 'light', authRequired }
+
+    expect(usePlatform().can('admin')).toBe(expected)
+  })
+})

package/src/__tests__/composables/usePresence.test.ts

@@ -0,0 +1,164 @@
+import { effectScope, nextTick, ref } from 'vue'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const post = vi.fn(() => Promise.resolve())
+vi.mock('../../composables/useApi', () => ({ useApi: () => ({ post }) }))
+
+class FakeEventSource {
+  static instances: FakeEventSource[] = []
+  onopen: (() => void) | null = null
+  onmessage: ((message: { data: string }) => void) | null = null
+  onerror: (() => void) | null = null
+
+  constructor(readonly url: string) {
+    FakeEventSource.instances.push(this)
+  }
+
+  close(): void {}
+
+  emit(event: Record<string, unknown>): void {
+    this.onmessage?.({ data: JSON.stringify(event) })
+  }
+}
+
+function latest(): FakeEventSource {
+  return FakeEventSource.instances[FakeEventSource.instances.length - 1]
+}
+
+async function loadUsePresence() {
+  vi.resetModules()
+  return (await import('../../composables/usePresence')).usePresence
+}
+
+async function loadBoth() {
+  const usePresence = await loadUsePresence()
+  return { usePresence, useRealtime: (await import('../../composables/useRealtime')).useRealtime }
+}
+
+const alice = { user_id: '7', activity: 'editing' }
+
+describe('usePresence', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    FakeEventSource.instances = []
+    post.mockClear()
+    vi.stubGlobal('EventSource', FakeEventSource)
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+    vi.useRealTimers()
+  })
+
+  it('should list the viewers of its own topic only when presence changes', async () => {
+    const usePresence = await loadUsePresence()
+    const scope = effectScope()
+    const presence = scope.run(() => usePresence('experiment:4'))!
+    vi.runAllTimers()
+    latest().onopen?.()
+
+    latest().emit({ type: 'presence.changed', topic: 'experiment:4', viewers: [alice], count: 3 })
+    latest().emit({ type: 'presence.changed', topic: 'experiment:5', viewers: [], count: 0 })
+
+    expect([presence.viewers.value, presence.count.value, post.mock.calls.length]).toEqual([[alice], 3, 0])
+    scope.stop()
+  })
+
+  it('should clear the viewers when the topic changes', async () => {
+    const usePresence = await loadUsePresence()
+    const topic = ref('experiment:4')
+    const scope = effectScope()
+    const presence = scope.run(() => usePresence(topic))!
+    vi.runAllTimers()
+    latest().emit({ type: 'presence.changed', topic: 'experiment:4', viewers: [alice], count: 1 })
+
+    topic.value = 'experiment:5'
+    await nextTick()
+
+    expect([presence.viewers.value, presence.count.value]).toEqual([[], 0])
+    scope.stop()
+  })
+
+  it('should clear the viewers while the stream is closed and list them again after the reconnect', async () => {
+    const usePresence = await loadUsePresence()
+    const scope = effectScope()
+    const presence = scope.run(() => usePresence('experiment:4'))!
+    vi.runAllTimers()
+    latest().onopen?.()
+    latest().emit({ type: 'presence.changed', topic: 'experiment:4', viewers: [alice], count: 1 })
+    await nextTick()
+
+    latest().onerror?.()
+    await nextTick()
+    const closed = [presence.viewers.value, presence.count.value]
+    vi.runAllTimers()
+    latest().onopen?.()
+    latest().emit({ type: 'presence.changed', topic: 'experiment:4', viewers: [alice], count: 1 })
+
+    expect([closed, [presence.viewers.value, presence.count.value]]).toEqual([[[], 0], [[alice], 1]])
+    scope.stop()
+  })
+
+  it('should report the activity each time the stream opens and when it changes while open', async () => {
+    const usePresence = await loadUsePresence()
+    const activity = ref<'viewing' | 'editing'>('viewing')
+    const scope = effectScope()
+    scope.run(() => usePresence('experiment:4', activity))
+    vi.runAllTimers()
+
+    activity.value = 'editing'
+    await nextTick()
+    const beforeOpen = post.mock.calls.length
+    latest().onopen?.()
+    activity.value = 'viewing'
+    await nextTick()
+
+    expect([beforeOpen, post.mock.calls]).toEqual([
+      0,
+      [
+        ['/presence/activity', { topic: 'experiment:4', activity: 'editing' }],
+        ['/presence/activity', { topic: 'experiment:4', activity: 'viewing' }],
+      ],
+    ])
+    scope.stop()
+  })
+
+  it('should show the viewers and report the activity when the open stream already views the topic', async () => {
+    const { usePresence, useRealtime } = await loadBoth()
+    const scope = effectScope()
+    scope.run(() => useRealtime(['experiment:4'], vi.fn()))
+    vi.runAllTimers()
+    latest().onopen?.()
+    latest().emit({ type: 'presence.changed', topic: 'experiment:4', viewers: [alice], count: 1 })
+
+    const presence = scope.run(() => usePresence('experiment:4', 'viewing_design'))!
+    vi.runAllTimers()
+
+    expect([FakeEventSource.instances.length, presence.viewers.value, post.mock.calls]).toEqual([
+      1,
+      [alice],
+      [['/presence/activity', { topic: 'experiment:4', activity: 'viewing_design' }]],
+    ])
+    scope.stop()
+  })
+
+  it('should set the label back to viewing and stop reporting when stopped', async () => {
+    const { usePresence, useRealtime } = await loadBoth()
+    const activity = ref<'editing' | 'viewing_design'>('editing')
+    const scope = effectScope()
+    scope.run(() => useRealtime(['experiment:4'], vi.fn()))
+    const presence = scope.run(() => usePresence('experiment:4', activity))!
+    vi.runAllTimers()
+    latest().onopen?.()
+
+    presence.stop()
+    activity.value = 'viewing_design'
+    await nextTick()
+
+    expect(post.mock.calls).toEqual([
+      ['/presence/activity', { topic: 'experiment:4', activity: 'editing' }],
+      ['/presence/activity', { topic: 'experiment:4', activity: 'viewing' }],
+    ])
+    scope.stop()
+  })
+})

package/src/__tests__/composables/useRackEditor.test.ts

@@ -96,10 +96,10 @@ describe('useRackEditor — PlateEditor intents (7a)', () => {
     expect(editor.racks.value.map(rack => rack.id)).toEqual(['r2', 'r1'])
   })
 
-  it('should follow update:activeRackId', () => {
+  it('should follow update:activeRack', () => {
     const editor = useRackEditor(makeRacks())
 
-    editor.plateEditorListeners['update:activeRackId']('r2')
+    editor.plateEditorListeners['update:activeRack']('r2')
 
     expect(editor.activeRackId.value).toBe('r2')
   })

package/src/__tests__/composables/useRealtime.test.ts

@@ -0,0 +1,196 @@
+import { effectScope, ref } from 'vue'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+class FakeEventSource {
+  static instances: FakeEventSource[] = []
+  onopen: (() => void) | null = null
+  onmessage: ((message: { data: string }) => void) | null = null
+  onerror: (() => void) | null = null
+  closed = false
+
+  constructor(readonly url: string) {
+    FakeEventSource.instances.push(this)
+  }
+
+  close(): void {
+    this.closed = true
+  }
+
+  emit(event: Record<string, unknown>): void {
+    this.onmessage?.({ data: JSON.stringify(event) })
+  }
+
+  get topics(): string {
+    return new URL(this.url, 'http://test').searchParams.get('topics') ?? ''
+  }
+}
+
+function live(): FakeEventSource[] {
+  return FakeEventSource.instances.filter(source => !source.closed)
+}
+
+async function loadUseRealtime() {
+  vi.resetModules()
+  return (await import('../../composables/useRealtime')).useRealtime
+}
+
+describe('useRealtime', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    FakeEventSource.instances = []
+    vi.stubGlobal('EventSource', FakeEventSource)
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+    vi.useRealTimers()
+  })
+
+  it('should open one shared stream with the merged topics when several callers subscribe', async () => {
+    const useRealtime = await loadUseRealtime()
+    const scope = effectScope()
+    scope.run(() => {
+      useRealtime(['experiment:1', 'experiments'], vi.fn())
+      useRealtime(['experiments', 'project:2'], vi.fn())
+    })
+
+    vi.runAllTimers()
+
+    expect(live().map(source => source.topics)).toEqual(['experiment:1,experiments,project:2'])
+    scope.stop()
+  })
+
+  it('should deliver an event only to the callers subscribed to its topic', async () => {
+    const useRealtime = await loadUseRealtime()
+    const onExperiment = vi.fn()
+    const onProject = vi.fn()
+    const scope = effectScope()
+    scope.run(() => {
+      useRealtime(['experiment:1'], onExperiment)
+      useRealtime(['project:2'], onProject)
+    })
+    vi.runAllTimers()
+
+    live()[0].emit({ type: 'experiment.update', topic: 'experiment:1' })
+
+    expect([onExperiment.mock.calls.length, onProject.mock.calls.length]).toEqual([1, 0])
+    scope.stop()
+  })
+
+  it('should not deliver presence.changed when the caller is not usePresence', async () => {
+    const useRealtime = await loadUseRealtime()
+    const handler = vi.fn()
+    const scope = effectScope()
+    scope.run(() => useRealtime(['experiment:1'], handler))
+    vi.runAllTimers()
+
+    live()[0].emit({ type: 'presence.changed', topic: 'experiment:1', viewers: [], count: 0 })
+
+    expect(handler).not.toHaveBeenCalled()
+    scope.stop()
+  })
+
+  it('should notify every caller when the server sends resync', async () => {
+    const useRealtime = await loadUseRealtime()
+    const first = vi.fn()
+    const second = vi.fn()
+    const scope = effectScope()
+    scope.run(() => {
+      useRealtime(['experiment:1'], first)
+      useRealtime(['project:2'], second)
+    })
+    vi.runAllTimers()
+
+    live()[0].emit({ type: 'resync' })
+
+    expect([first.mock.calls[0]?.[0], second.mock.calls[0]?.[0]]).toEqual([{ type: 'resync' }, { type: 'resync' }])
+    scope.stop()
+  })
+
+  it('should reconnect with a growing backoff and resync when the stream opens again', async () => {
+    const useRealtime = await loadUseRealtime()
+    const handler = vi.fn()
+    const scope = effectScope()
+    scope.run(() => useRealtime(['experiment:1'], handler))
+    vi.runAllTimers()
+    FakeEventSource.instances[0].onopen?.()
+
+    FakeEventSource.instances[0].onerror?.()
+    vi.advanceTimersByTime(999)
+    const beforeFirstRetry = FakeEventSource.instances.length
+    vi.advanceTimersByTime(1)
+    FakeEventSource.instances[1].onerror?.()
+    vi.advanceTimersByTime(1999)
+    const beforeSecondRetry = FakeEventSource.instances.length
+    vi.advanceTimersByTime(1)
+    handler.mockClear()
+    FakeEventSource.instances[2].onopen?.()
+
+    expect([beforeFirstRetry, beforeSecondRetry, FakeEventSource.instances.length]).toEqual([1, 2, 3])
+    expect(handler.mock.calls).toEqual([[{ type: 'resync' }]])
+    scope.stop()
+  })
+
+  it('should reopen with the new topics when a caller changes its topics', async () => {
+    const useRealtime = await loadUseRealtime()
+    const topics = ref(['experiment:1'])
+    const scope = effectScope()
+    scope.run(() => useRealtime(topics, vi.fn()))
+    vi.runAllTimers()
+
+    topics.value = ['experiment:2']
+    await Promise.resolve()
+    vi.runAllTimers()
+
+    expect(live().map(source => source.topics)).toEqual(['experiment:2'])
+    scope.stop()
+  })
+
+  it('should resync every caller when a stream opens, the first stream too', async () => {
+    const useRealtime = await loadUseRealtime()
+    const list = vi.fn()
+    const detail = vi.fn()
+    const scope = effectScope()
+    scope.run(() => useRealtime(['experiments'], list))
+    vi.runAllTimers()
+    FakeEventSource.instances[0].onopen?.()
+    const afterFirstOpen = list.mock.calls.length
+
+    scope.run(() => useRealtime(['experiment:7'], detail))
+    vi.runAllTimers()
+    FakeEventSource.instances[1].onopen?.()
+
+    expect([afterFirstOpen, list.mock.calls, detail.mock.calls])
+      .toEqual([1, [[{ type: 'resync' }], [{ type: 'resync' }]], [[{ type: 'resync' }]]])
+    scope.stop()
+  })
+
+  it('should keep the backoff when a caller subscribes while the stream waits to reconnect', async () => {
+    const useRealtime = await loadUseRealtime()
+    const scope = effectScope()
+    scope.run(() => useRealtime(['experiments'], vi.fn()))
+    vi.runAllTimers()
+    FakeEventSource.instances[0].onopen?.()
+    FakeEventSource.instances[0].onerror?.()
+
+    scope.run(() => useRealtime(['experiment:7'], vi.fn()))
+    vi.advanceTimersByTime(999)
+    const beforeRetry = FakeEventSource.instances.length
+    vi.advanceTimersByTime(1)
+
+    expect([beforeRetry, live().map(source => source.topics)]).toEqual([1, ['experiment:7,experiments']])
+    scope.stop()
+  })
+
+  it('should close the stream when the scope of the last caller is disposed', async () => {
+    const useRealtime = await loadUseRealtime()
+    const scope = effectScope()
+    scope.run(() => useRealtime(['experiment:1'], vi.fn()))
+    vi.runAllTimers()
+
+    scope.stop()
+    vi.runAllTimers()
+
+    expect([FakeEventSource.instances.length, live().length]).toEqual([1, 0])
+  })
+})

package/src/__tests__/composables/{useRequestSyncState.test.ts → useRequest.test.ts}

@@ -1,12 +1,12 @@
 import { describe, expect, it } from 'vitest'
 
-import { useRequestSyncState } from '../../composables/useRequestSyncState'
+import { useRequest } from '../../composables/useRequest'
 
-describe('useRequestSyncState', () => {
+describe('useRequest', () => {
   it('starts with idle request state', () => {
-    const state = useRequestSyncState()
+    const state = useRequest()
 
-    expect(state.loading.value).toBe(false)
+    expect(state.isLoading.value).toBe(false)
     expect(state.error.value).toBeNull()
     expect(state.lastLoadedAt.value).toBeNull()
     expect(state.lastSavedAt.value).toBeNull()
@@ -14,7 +14,7 @@ describe('useRequestSyncState', () => {
   })
 
   it('normalizes errors and supports explicit clearing', () => {
-    const state = useRequestSyncState('Default failure')
+    const state = useRequest('Default failure')
 
     expect(state.setError(new Error('Backend rejected request'))).toBe(
       'Backend rejected request',
@@ -32,31 +32,16 @@ describe('useRequestSyncState', () => {
     expect(state.error.value).toBeNull()
   })
 
-  it('marks load, save, and run timestamps', () => {
-    const state = useRequestSyncState()
-    const loadedAt = new Date('2026-05-07T09:00:00Z')
-    const savedAt = new Date('2026-05-07T09:01:00Z')
-    const runAt = new Date('2026-05-07T09:02:00Z')
-
-    state.markLoaded(loadedAt)
-    state.markSaved(savedAt)
-    state.markRun(runAt)
-
-    expect(state.lastLoadedAt.value).toBe(loadedAt)
-    expect(state.lastSavedAt.value).toBe(savedAt)
-    expect(state.lastRunAt.value).toBe(runAt)
-  })
-
   it('wraps successful operations and marks requested sync timestamps', async () => {
-    const state = useRequestSyncState()
+    const state = useRequest()
 
     const result = await state.run(async () => {
-      expect(state.loading.value).toBe(true)
+      expect(state.isLoading.value).toBe(true)
       return { ok: true }
-    }, { success: 'load' })
+    }, { kind: 'load' })
 
     expect(result).toEqual({ ok: true })
-    expect(state.loading.value).toBe(false)
+    expect(state.isLoading.value).toBe(false)
     expect(state.error.value).toBeNull()
     expect(state.lastLoadedAt.value).toBeInstanceOf(Date)
     expect(state.lastSavedAt.value).toBeNull()
@@ -64,9 +49,9 @@ describe('useRequestSyncState', () => {
   })
 
   it('wraps successful run operations and marks lastRunAt', async () => {
-    const state = useRequestSyncState()
+    const state = useRequest()
 
-    const result = await state.run(async () => 'done', { success: 'run' })
+    const result = await state.run(async () => 'done', { kind: 'run' })
 
     expect(result).toBe('done')
     expect(state.lastLoadedAt.value).toBeNull()
@@ -75,15 +60,15 @@ describe('useRequestSyncState', () => {
   })
 
   it('wraps failed operations, sets error, and rethrows', async () => {
-    const state = useRequestSyncState()
+    const state = useRequest()
     const failure = new Error('Network down')
 
     await expect(state.run(async () => {
-      expect(state.loading.value).toBe(true)
+      expect(state.isLoading.value).toBe(true)
       throw failure
-    }, { success: 'save' })).rejects.toThrow('Network down')
+    }, { kind: 'save' })).rejects.toThrow('Network down')
 
-    expect(state.loading.value).toBe(false)
+    expect(state.isLoading.value).toBe(false)
     expect(state.error.value).toBe('Network down')
     expect(state.lastLoadedAt.value).toBeNull()
     expect(state.lastSavedAt.value).toBeNull()
@@ -102,29 +87,29 @@ describe('useRequestSyncState', () => {
     }
 
     it('lets only the newest run own loading', async () => {
-      const state = useRequestSyncState()
+      const state = useRequest()
       const first = deferred<string>()
       const second = deferred<string>()
 
-      const firstRun = state.run(() => first.promise, { success: 'load' })
-      const secondRun = state.run(() => second.promise, { success: 'load' })
+      const firstRun = state.run(() => first.promise, { kind: 'load' })
+      const secondRun = state.run(() => second.promise, { kind: 'load' })
 
       first.resolve('stale')
       await expect(firstRun).resolves.toBe('stale')
-      expect(state.loading.value).toBe(true)
+      expect(state.isLoading.value).toBe(true)
 
       second.resolve('fresh')
       await expect(secondRun).resolves.toBe('fresh')
-      expect(state.loading.value).toBe(false)
+      expect(state.isLoading.value).toBe(false)
     })
 
     it('does not let a stale success move the sync timestamps', async () => {
-      const state = useRequestSyncState()
+      const state = useRequest()
       const first = deferred<string>()
       const second = deferred<string>()
 
-      const firstRun = state.run(() => first.promise, { success: 'save' })
-      const secondRun = state.run(() => second.promise, { success: 'load' })
+      const firstRun = state.run(() => first.promise, { kind: 'save' })
+      const secondRun = state.run(() => second.promise, { kind: 'load' })
 
       first.resolve('stale')
       await firstRun
@@ -137,12 +122,12 @@ describe('useRequestSyncState', () => {
     })
 
     it('does not let a stale failure write the error, but still rejects its caller', async () => {
-      const state = useRequestSyncState()
+      const state = useRequest()
       const first = deferred<string>()
       const second = deferred<string>()
 
       const firstRun = state.run(() => first.promise, { errorMessage: 'first failed' })
-      const secondRun = state.run(() => second.promise, { success: 'load' })
+      const secondRun = state.run(() => second.promise, { kind: 'load' })
 
       first.reject(new Error('stale failure'))
       await expect(firstRun).rejects.toThrow('stale failure')
@@ -151,11 +136,11 @@ describe('useRequestSyncState', () => {
       second.resolve('fresh')
       await secondRun
       expect(state.error.value).toBeNull()
-      expect(state.loading.value).toBe(false)
+      expect(state.isLoading.value).toBe(false)
     })
 
     it('aborts the superseded run signal by default', async () => {
-      const state = useRequestSyncState()
+      const state = useRequest()
       const first = deferred<string>()
       const second = deferred<string>()
       let firstSignal: AbortSignal | undefined
@@ -175,7 +160,7 @@ describe('useRequestSyncState', () => {
     })
 
     it('leaves the previous signal alone when abortPrevious is false', async () => {
-      const state = useRequestSyncState()
+      const state = useRequest()
       const first = deferred<string>()
       const second = deferred<string>()
       let firstSignal: AbortSignal | undefined
@@ -193,7 +178,7 @@ describe('useRequestSyncState', () => {
     })
 
     it('forwards a caller signal onto the operation signal', async () => {
-      const state = useRequestSyncState()
+      const state = useRequest()
       const caller = new AbortController()
       const pending = deferred<string>()
       let operationSignal: AbortSignal | undefined
@@ -211,18 +196,18 @@ describe('useRequestSyncState', () => {
     })
 
     it('cancel() aborts the in-flight run and drops loading', async () => {
-      const state = useRequestSyncState()
+      const state = useRequest()
       const pending = deferred<string>()
       let operationSignal: AbortSignal | undefined
 
       const run = state.run((signal) => {
         operationSignal = signal
         return pending.promise
-      }, { success: 'load' })
+      }, { kind: 'load' })
 
       state.cancel()
       expect(operationSignal?.aborted).toBe(true)
-      expect(state.loading.value).toBe(false)
+      expect(state.isLoading.value).toBe(false)
 
       pending.resolve('too late')
       await expect(run).resolves.toBe('too late')