fix(web): persist general preferences in host settings

packages/client/runtime/tests/settings-preference.spec.ts

@@ -0,0 +1,237 @@
+import { Context } from 'cordis'
+import { describe, expect, it, vi } from 'vitest'
+import type { RpcResponse, SettingsNamespaceView } from '@deepseek-ai/dsh-client-connection/client'
+import {
+  bindSettingsPreference, SettingsPreferenceController,
+} from '../src/client/settings-preference.ts'
+
+type Preference = 'light' | 'dark' | 'system'
+
+let rpc = 0
+
+function ok<T>(value: T): RpcResponse<T> {
+  return { rpcId: `preference-${rpc++}` as never, result: { ok: true, value } }
+}
+
+function rejected<T>(): RpcResponse<T> {
+  return {
+    rpcId: `preference-${rpc++}` as never,
+    result: {
+      ok: false,
+      error: { code: 'settings-rejected', message: 'conflict', details: { ns: 'ui-test' } },
+    },
+  }
+}
+
+function view(value: unknown, revision = 0): SettingsNamespaceView {
+  return {
+    ns: 'ui-test',
+    schema: {},
+    value,
+    applies: 'live',
+    secrets: [],
+    revision,
+  }
+}
+
+function described(value: unknown, revision = 0) {
+  return ok({ writable: true, hasDocument: true, namespaces: [view(value, revision)] })
+}
+
+function deferred<T>() {
+  let resolve!: (value: T) => void
+  let reject!: (reason: unknown) => void
+  const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej })
+  return { promise, resolve, reject }
+}
+
+function spec(values: Preference[]) {
+  return {
+    namespace: 'ui-test',
+    field: 'preference',
+    decode: (value: unknown): Preference | undefined =>
+      value === 'light' || value === 'dark' || value === 'system' ? value : undefined,
+    sync: (value: Preference) => { values.push(value) },
+  }
+}
+
+describe('SettingsPreferenceController', () => {
+  it('loads only a valid owned field and contains unavailable transports', async () => {
+    const values: Preference[] = []
+    const describe = vi.fn()
+      .mockResolvedValueOnce(described({ preference: 'dark' }, 3))
+      .mockResolvedValueOnce(ok({ writable: true, hasDocument: true, namespaces: [] }))
+      .mockResolvedValueOnce(described({ preference: 'sepia' }))
+      .mockResolvedValueOnce(described(null))
+      .mockResolvedValueOnce(rejected())
+      .mockRejectedValueOnce(new Error('offline'))
+    const controller = new SettingsPreferenceController({ settings: { describe } } as never, spec(values))
+    for (let i = 0; i < 6; i++) await controller.load()
+    expect(values).toEqual(['dark'])
+  })
+
+  it('serializes rapid writes, carries revisions, and publishes only the latest settlement', async () => {
+    const first = deferred<RpcResponse<SettingsNamespaceView>>()
+    const values: Preference[] = []
+    const describe = vi.fn().mockResolvedValue(described({ preference: 'system' }, 4))
+    const mutate = vi.fn()
+      .mockReturnValueOnce(first.promise)
+      .mockResolvedValueOnce(ok(view({ preference: 'light' }, 6)))
+    const controller = new SettingsPreferenceController(
+      { settings: { describe, mutate } } as never,
+      spec(values),
+    )
+    await controller.load()
+    const dark = controller.persist('dark')
+    const light = controller.persist('light')
+    await vi.waitFor(() => { expect(mutate).toHaveBeenCalledOnce() })
+    first.resolve(ok(view({ preference: 'dark' }, 5)))
+    await Promise.all([dark, light])
+    expect(values).toEqual(['system', 'light'])
+    expect(mutate).toHaveBeenNthCalledWith(1, {
+      ns: 'ui-test',
+      ops: [{ op: 'set', path: ['preference'], value: 'dark' }],
+      expectedRevision: 4,
+    })
+    expect(mutate).toHaveBeenNthCalledWith(2, {
+      ns: 'ui-test',
+      ops: [{ op: 'set', path: ['preference'], value: 'light' }],
+      expectedRevision: 5,
+    })
+  })
+
+  it('recovers the latest rejected or thrown write from Host state', async () => {
+    const values: Preference[] = []
+    const describe = vi.fn()
+      .mockResolvedValueOnce(described({ preference: 'system' }, 2))
+      .mockResolvedValueOnce(described({ preference: 'light' }, 3))
+    const mutate = vi.fn()
+      .mockResolvedValueOnce(rejected())
+      .mockRejectedValueOnce(new Error('offline'))
+    const controller = new SettingsPreferenceController(
+      { settings: { describe, mutate } } as never,
+      spec(values),
+    )
+    await controller.persist('dark')
+    await controller.persist('system')
+    expect(values).toEqual(['system', 'light'])
+  })
+
+  it('does not recover superseded rejected or thrown writes', async () => {
+    const values: Preference[] = []
+    const describe = vi.fn()
+    const mutate = vi.fn()
+      .mockResolvedValueOnce(rejected())
+      .mockRejectedValueOnce(new Error('offline'))
+      .mockResolvedValueOnce(ok(view({ preference: 'light' }, 3)))
+    const controller = new SettingsPreferenceController(
+      { settings: { describe, mutate } } as never,
+      spec(values),
+    )
+    await Promise.all([
+      controller.persist('dark'),
+      controller.persist('system'),
+      controller.persist('light'),
+    ])
+    expect(describe).not.toHaveBeenCalled()
+    expect(values).toEqual(['light'])
+  })
+
+  it('keeps the queue usable when a target callback throws', async () => {
+    const describe = vi.fn()
+      .mockResolvedValueOnce(described({ preference: 'dark' }))
+      .mockResolvedValueOnce(described({ preference: 'sepia' }))
+    const controller = new SettingsPreferenceController(
+      { settings: { describe } } as never,
+      { ...spec([]), sync: () => { throw new Error('target failed') } },
+    )
+    await expect(controller.load()).rejects.toThrow('target failed')
+    await expect(controller.load()).resolves.toBeUndefined()
+  })
+
+  it('cancels queued and post-dispose writes while draining the in-flight mutation', async () => {
+    const first = deferred<RpcResponse<SettingsNamespaceView>>()
+    const mutate = vi.fn().mockReturnValue(first.promise)
+    const values: Preference[] = []
+    const controller = new SettingsPreferenceController(
+      { settings: { mutate } } as never,
+      spec(values),
+    )
+    const dark = controller.persist('dark')
+    await vi.waitFor(() => { expect(mutate).toHaveBeenCalledOnce() })
+    const light = controller.persist('light')
+    let stopped = false
+    const stop = controller.dispose().then(() => { stopped = true })
+    await Promise.resolve()
+    expect(stopped).toBe(false)
+    first.resolve(ok(view({ preference: 'dark' }, 1)))
+    await Promise.all([dark, light, stop])
+    await controller.persist('system')
+    await controller.load()
+    expect(mutate).toHaveBeenCalledOnce()
+    expect(values).toEqual([])
+  })
+
+  it('keeps remote-browser preferences in memory without Host calls', async () => {
+    const describe = vi.fn()
+    const mutate = vi.fn()
+    const controller = new SettingsPreferenceController(
+      { settings: { describe, mutate } } as never,
+      spec([]),
+      'memory',
+    )
+    await controller.load()
+    await controller.persist('dark')
+    await controller.dispose()
+    expect(describe).not.toHaveBeenCalled()
+    expect(mutate).not.toHaveBeenCalled()
+  })
+})
+
+describe('bindSettingsPreference', () => {
+  it('subscribes before the initial read and converges to the latest queued invalidation', async () => {
+    const initial = deferred<ReturnType<typeof described>>()
+    const describe = vi.fn()
+      .mockReturnValueOnce(initial.promise)
+      .mockResolvedValueOnce(described({ preference: 'light' }, 2))
+      .mockResolvedValueOnce(described({ preference: 'system' }, 3))
+    const ctx = new Context()
+    ctx.provide('connection', {
+      api: { settings: { describe } },
+      isLoopback: true,
+    } as never)
+    const values: Preference[] = []
+    const fiber = ctx.plugin({
+      inject: ['connection'],
+      apply: (scope: Context) => { bindSettingsPreference(scope, spec(values)) },
+    })
+    await fiber.await()
+    await vi.waitFor(() => { expect(describe).toHaveBeenCalledOnce() })
+    ctx.emit('settings/changed', 'unrelated')
+    ctx.emit('settings/changed', 'ui-test')
+    ctx.emit('connection/reset')
+    initial.resolve(described({ preference: 'dark' }, 1))
+    await vi.waitFor(() => { expect(describe).toHaveBeenCalledTimes(3) })
+    await vi.waitFor(() => { expect(values).toEqual(['system']) })
+    await fiber.dispose()
+    ctx.emit('settings/changed', 'ui-test')
+    await Promise.resolve()
+    expect(describe).toHaveBeenCalledTimes(3)
+  })
+
+  it('binds a remote browser in memory without starting a settings read', async () => {
+    const describe = vi.fn()
+    const ctx = new Context()
+    ctx.provide('connection', {
+      api: { settings: { describe } },
+      isLoopback: false,
+    } as never)
+    const fiber = ctx.plugin({
+      inject: ['connection'],
+      apply: (scope: Context) => { bindSettingsPreference(scope, spec([])) },
+    })
+    await fiber.await()
+    await fiber.dispose()
+    expect(describe).not.toHaveBeenCalled()
+  })
+})