test(gui): settings package suites; ledger-judged re-registration

Full per-file coverage for the three settings packages: invariant
companions, store mirroring with revision guards, behavior-shaped
section/shell specs (props-fed, real store engine), and apply-level
suites on a real Context + SlotCore covering declaration-aware deferral
and HMR collapse recovery. All three registrants now judge presence on
the slot ledger instead of a local disposer, which went stale when a
parent redeclaration cascade removed the entry (ds-review-bot finding);
the locale re-register path keeps the same idempotence.

packages/client/ui-settings/src/client/index.ts

@@ -43,13 +43,23 @@ export function apply(ctx: ClientContext): void {
     sectionsVersion: () => ctx.slots.getVersion('settings.section'),
     subscribeSections: (listener) => ctx.slots.subscribe('settings.section', listener),
     sections: () => ctx.slots.entries('settings.section')
-      .map(e => ({ id: e.options.id ?? '', order: e.options.order ?? 0, label: e.options.label ?? '' }))
+      .map(e => ({
+        /* v8 ignore next -- list-slot registration requires id (SlotCore rejects an entry without one) */
+        id: e.options.id ?? '',
+        order: e.options.order ?? 0,
+        label: e.options.label ?? '',
+      }))
       .sort((a, b) => a.order - b.order),
   })
+  // Declaration-aware registration; the LEDGER is the has-registered judge
+  // (not a local flag): after an HMR collapse re-declares the slot, the
+  // cascade already removed our entry, and a stale disposer must not block
+  // the re-registration.
   ctx.effect(() => {
     let dispose: (() => void) | undefined
     const tryRegister = (): void => {
-      if (ctx.slots.spec('sidebar.settings') === undefined || dispose !== undefined) return
+      if (ctx.slots.spec('sidebar.settings') === undefined) return
+      if (ctx.slots.entries('sidebar.settings').some(e => e.component === SettingsRoot)) return
       dispose = ctx.slots.register({
         name: 'sidebar.settings',
         children: { 'settings.section': { kind: 'list', scope: 'root' } },

packages/client/ui-settings/tests/apply.spec.ts

@@ -0,0 +1,120 @@
+/** Settings shell registration: declaration-aware deferral, the injected face, and HMR recovery. */
+import { Context } from 'cordis'
+import { describe, expect, it, vi } from 'vitest'
+import { SlotsService } from '@deepseek-ai/dsh-client-runtime/client'
+import { LocaleService } from '@deepseek-ai/dsh-client-locale/client'
+import { apply, inject } from '@deepseek-ai/dsh-client-ui-settings/client'
+import type { SettingsRootInjected } from '@deepseek-ai/dsh-client-ui-settings/client'
+import { SettingsRoot } from '../src/client/SettingsRoot.tsx'
+
+async function bench() {
+  const ctx = new Context()
+  await ctx.plugin(SlotsService).await()
+  const locale = new LocaleService(ctx)
+  ctx.provide('locale', locale)
+  return { ctx, slots: ctx.get('slots') as SlotsService, locale }
+}
+
+function declare(slots: SlotsService): () => void {
+  return slots.register(
+    { name: 'root', children: { 'sidebar.settings': { kind: 'single', scope: 'root' } } } as never,
+    () => null,
+  )
+}
+
+function injectedOf(slots: SlotsService): SettingsRootInjected {
+  const entry = slots.entries('sidebar.settings')[0]!
+  return (entry.inject as () => SettingsRootInjected)()
+}
+
+describe('ui-settings apply', () => {
+  it('declares the services it uses', () => {
+    expect(inject).toEqual(['slots', 'locale'])
+  })
+
+  it('registers the shell for declarations that arrive before or after apply', async () => {
+    const before = await bench()
+    declare(before.slots)
+    await before.ctx.plugin({ inject: [...inject], apply }).await()
+    expect(before.slots.entries('sidebar.settings')[0]!.component).toBe(SettingsRoot)
+    expect(before.slots.spec('settings.section')).toEqual({ kind: 'list', scope: 'root' })
+
+    const after = await bench()
+    await after.ctx.plugin({ inject: [...inject], apply }).await()
+    expect(after.slots.entries('sidebar.settings')).toHaveLength(0)
+    declare(after.slots)
+    await Promise.resolve()
+    expect(after.slots.entries('sidebar.settings')[0]!.component).toBe(SettingsRoot)
+    // The self-inflicted ledger notifications hit the duplicate guard.
+    expect(after.slots.entries('sidebar.settings')).toHaveLength(1)
+  })
+
+  it('registers the zh/en shell dictionaries and disposes them with the fiber', async () => {
+    const b = await bench()
+    declare(b.slots)
+    const fiber = b.ctx.plugin({ inject: [...inject], apply })
+    await fiber.await()
+    expect(b.locale.bind('settings')('title')).toBe('设置')
+    b.locale.setLocale('en')
+    expect(b.locale.bind('settings')('close')).toBe('Close')
+    await fiber.dispose()
+    // The (ns, locale) seats are free again — the dictionary disposers ran.
+    expect(() => b.locale.register('settings', 'zh', {})).not.toThrow()
+    expect(() => b.locale.register('settings', 'en', {})).not.toThrow()
+  })
+
+  it('exposes translate over "<ns>:<key>" refs with literal echo for plain text', async () => {
+    const b = await bench()
+    declare(b.slots)
+    await b.ctx.plugin({ inject: [...inject], apply }).await()
+    const injected = injectedOf(b.slots)
+    expect(injected.translate('settings:title')).toBe('设置')
+    expect(injected.translate('no colon ref')).toBe('no colon ref')
+  })
+
+  it('projects the section ledger into ordered nav rows with option defaults', async () => {
+    const b = await bench()
+    declare(b.slots)
+    await b.ctx.plugin({ inject: [...inject], apply }).await()
+    const injected = injectedOf(b.slots)
+    expect(injected.sections()).toEqual([])
+    b.slots.register({ name: 'settings.section', id: 'z', order: 20, label: 'Z' } as never, () => null)
+    b.slots.register({ name: 'settings.section', id: 'a' } as never, () => null)
+    expect(injected.sections()).toEqual([
+      { id: 'a', order: 0, label: '' },
+      { id: 'z', order: 20, label: 'Z' },
+    ])
+    expect(injected.sectionsVersion()).toBe(b.slots.getVersion('settings.section'))
+    const listener = vi.fn()
+    const off = injected.subscribeSections(listener)
+    b.slots.register({ name: 'settings.section', id: 'b', order: 1, label: 'B' } as never, () => null)
+    await Promise.resolve()
+    expect(listener).toHaveBeenCalled()
+    off()
+  })
+
+  it('re-registers after an HMR collapse re-declares the slot (stale disposer must not block)', async () => {
+    const b = await bench()
+    const redeclare = declare(b.slots)
+    await b.ctx.plugin({ inject: [...inject], apply }).await()
+    expect(b.slots.entries('sidebar.settings')).toHaveLength(1)
+    // Declarer unload: the cascade removes our entry and the slot spec while
+    // our local disposer variable goes stale.
+    redeclare()
+    expect(b.slots.entries('sidebar.settings')).toHaveLength(0)
+    declare(b.slots)
+    await Promise.resolve()
+    expect(b.slots.entries('sidebar.settings')[0]!.component).toBe(SettingsRoot)
+    expect(b.slots.spec('settings.section')).toEqual({ kind: 'list', scope: 'root' })
+  })
+
+  it('unregisters the shell and collapses settings.section on teardown', async () => {
+    const b = await bench()
+    declare(b.slots)
+    const fiber = b.ctx.plugin({ inject: [...inject], apply })
+    await fiber.await()
+    await fiber.dispose()
+    expect(b.slots.entries('sidebar.settings')).toHaveLength(0)
+    expect(b.slots.spec('settings.section')).toBeUndefined()
+  })
+})

packages/client/ui-settings/tests/invariant.spec.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest'
+import { Context } from 'cordis'
+import * as SettingsInvariant from '@deepseek-ai/dsh-client-ui-settings/invariant'
+import InvariantService from '@deepseek-ai/dsh-invariants'
+
+describe('invariant companion', () => {
+  it('registers under the package name with an empty installer', async () => {
+    const ctx = new Context()
+    await ctx.plugin(InvariantService, { enabled: true })
+    await expect(ctx.plugin(SettingsInvariant).await()).resolves.toBeDefined()
+  })
+
+  it('node-half apply is a no-op host placeholder', async () => {
+    const { apply } = await import('@deepseek-ai/dsh-client-ui-settings')
+    apply()
+    expect(true).toBe(true) // reaching here without throw is the contract
+  })
+})

packages/client/ui-settings/tests/settings-root.spec.tsx

@@ -0,0 +1,155 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
+import type { SettingsRootComponentProps } from '../src/client/contract/slots.ts'
+import { SettingsRoot } from '../src/client/SettingsRoot.tsx'
+
+afterEach(cleanup)
+
+const DICT: Record<string, string> = {
+  'settings:trigger': 'Settings',
+  'settings:title': 'Settings',
+  'settings:close': 'Close',
+}
+
+type Row = { id: string; order: number; label: string }
+
+function mount({
+  wide = true,
+  rows = [
+    { id: 'general', order: 0, label: 'General' },
+    { id: 'models', order: 10, label: 'Models' },
+  ],
+}: { wide?: boolean; rows?: Row[] } = {}) {
+  // Mutable row store standing in for the ledger; bump() plays a change.
+  let current = rows
+  let version = 0
+  const listeners = new Set<() => void>()
+  const renderSlot = vi.fn(
+    ((_key: string, _owner: unknown, opts?: { only?: string }) =>
+      <div data-testid={`section-${opts?.only ?? 'all'}`} />) as SettingsRootComponentProps['renderSlot'],
+  )
+  // Global standard kit stubs: the shell consumes neither hook.
+  const unusedHook = (() => { throw new Error('unused by SettingsRoot') }) as never
+  const props: SettingsRootComponentProps = {
+    useSessions: unusedHook,
+    useWorkspaces: unusedHook,
+    wide,
+    translate: (ref) => DICT[ref] ?? ref,
+    sectionsVersion: () => version,
+    subscribeSections: (listener) => {
+      listeners.add(listener)
+      return () => { listeners.delete(listener) }
+    },
+    sections: () => current,
+    renderSlot,
+  }
+  const view = render(<SettingsRoot {...props} />)
+  const bump = (next: Row[]) => {
+    act(() => {
+      current = next
+      version += 1
+      for (const fn of [...listeners]) fn()
+    })
+  }
+  return { view, renderSlot, bump, listeners }
+}
+
+function openPanel() {
+  fireEvent.click(screen.getByRole('button', { name: 'Settings' }))
+}
+
+describe('SettingsRoot trigger', () => {
+  it('renders the wide row with the label and opens the dialog', () => {
+    mount()
+    const trigger = screen.getByRole('button', { name: 'Settings' })
+    expect(trigger.textContent).toContain('Settings')
+    expect(trigger.getAttribute('aria-expanded')).toBe('false')
+    fireEvent.click(trigger)
+    expect(screen.getByRole('dialog')).toBeTruthy()
+    expect(screen.getByRole('button', { name: 'Settings', expanded: true })).toBeTruthy()
+  })
+
+  it('drops the label in the rail state', () => {
+    mount({ wide: false })
+    expect(screen.getByRole('button', { name: 'Settings' }).textContent).toBe('')
+  })
+})
+
+describe('SettingsPanel close paths', () => {
+  it('closes via the header button', () => {
+    mount()
+    openPanel()
+    fireEvent.click(screen.getByRole('button', { name: 'Close' }))
+    expect(screen.queryByRole('dialog')).toBeNull()
+  })
+
+  it('closes via a mask click', () => {
+    mount()
+    openPanel()
+    const dialog = screen.getByRole('dialog')
+    fireEvent.click(dialog.parentElement!.firstElementChild!)
+    expect(screen.queryByRole('dialog')).toBeNull()
+  })
+
+  it('closes via document-level Escape and unhooks the listener with the panel', () => {
+    mount()
+    openPanel()
+    fireEvent.keyDown(document, { key: 'Escape' })
+    expect(screen.queryByRole('dialog')).toBeNull()
+    // Ignored while closed (listener removed with the panel) and non-Escape
+    // keys are ignored while open.
+    fireEvent.keyDown(document, { key: 'Escape' })
+    openPanel()
+    fireEvent.keyDown(document, { key: 'Enter' })
+    expect(screen.getByRole('dialog')).toBeTruthy()
+  })
+
+  it('lands focus on the close button when the dialog opens', () => {
+    mount()
+    openPanel()
+    expect(document.activeElement).toBe(screen.getByRole('button', { name: 'Close' }))
+  })
+})
+
+describe('SettingsPanel navigation', () => {
+  it('projects rows, marks the first active, and renders only that section', () => {
+    mount()
+    openPanel()
+    expect(screen.getByRole('button', { name: 'General' }).getAttribute('aria-current')).toBe('true')
+    expect(screen.getByRole('button', { name: 'Models' }).getAttribute('aria-current')).toBeNull()
+    expect(screen.getByTestId('section-general')).toBeTruthy()
+  })
+
+  it('switches the rendered section on nav click', () => {
+    mount()
+    openPanel()
+    fireEvent.click(screen.getByRole('button', { name: 'Models' }))
+    expect(screen.getByRole('button', { name: 'Models' }).getAttribute('aria-current')).toBe('true')
+    expect(screen.getByTestId('section-models')).toBeTruthy()
+    expect(screen.queryByTestId('section-general')).toBeNull()
+  })
+
+  it('falls back to the first row when the active entry unregisters', () => {
+    const { bump } = mount()
+    openPanel()
+    fireEvent.click(screen.getByRole('button', { name: 'Models' }))
+    bump([{ id: 'general', order: 0, label: 'General' }])
+    expect(screen.queryByRole('button', { name: 'Models' })).toBeNull()
+    expect(screen.getByTestId('section-general')).toBeTruthy()
+  })
+
+  it('renders an empty content column when the ledger is empty', () => {
+    const { renderSlot } = mount({ rows: [] })
+    openPanel()
+    expect(screen.getByRole('dialog')).toBeTruthy()
+    expect(renderSlot).not.toHaveBeenCalled()
+  })
+
+  it('drops the ledger subscription on unmount', () => {
+    const { view, listeners } = mount()
+    expect(listeners.size).toBe(1)
+    view.unmount()
+    expect(listeners.size).toBe(0)
+  })
+})