basalt-ui 1.27.0 → 1.29.0

package/src/controls/props-contract.test.tsx

@@ -1,137 +0,0 @@
-/**
- * C2 and C5 as COMPILER assertions. The claim "a basalt filter has no `value`/`onChange`/`size`" is
- * only worth making if writing one fails the build, so each `@ts-expect-error` below is the actual
- * enforcement: `bunx tsc --noEmit` fails if any of them stops being an error, which is what happens
- * the moment someone widens a prop type back open.
- *
- * `tsc` covers `src/**` including test files, so this file is checked by the ordinary typecheck —
- * there is nothing extra to run and nothing to remember.
- */
-import { describe, expect, test } from 'bun:test'
-import type { ReactNode } from 'react'
-import { createLocalStore, field } from '../state'
-import { CompareFilter } from './compare-filter'
-import { MultiSelectFilter } from './multi-select-filter'
-import { NumberFilter } from './number-filter'
-import { RangeFilter } from './range-filter'
-import { SearchFilter } from './search-filter'
-import { SelectFilter } from './select-filter'
-import { ToggleFilter } from './toggle-filter'
-import { ViewTabs } from './view-tabs'
-
-const local = createLocalStore({
-  key: 'props-contract',
-  fields: {
-    currency: field.enum(['USD', 'EUR'], 'USD'),
-    compare: field.enum(['none', 'previous', 'year'] as const, 'none'),
-    channels: field.multi(['web', 'email'], []),
-    range: field.range({ presets: ['7d', '30d'], fallback: '30d', custom: true }),
-    errorsOnly: field.boolean(false),
-    q: field.string(),
-    nights: field.number({ fallback: 2, min: 1, max: 14, int: true }),
-  },
-})
-
-/** A runtime catalogue — the shape both `options` props take (`FilterOption[]`). */
-const PROJECTS = [
-  { value: 'argo', label: 'Argo' },
-  { value: 'linewatch', label: 'Linewatch', disabled: true },
-]
-const CHANNELS = [{ value: 'web', label: 'web · 1.2k' }]
-
-/** Never rendered — the file's product is the type errors below, not a DOM assertion. */
-function Rejected(): ReactNode {
-  return (
-    <>
-      {/* @ts-expect-error C2 — a filter has no `value`; the field owns it. */}
-      <SelectFilter field={local.field.currency} label="Currency" value="EUR" />
-      {/* @ts-expect-error C2 — nor an `onChange`; the write goes through the field. */}
-      <SelectFilter field={local.field.currency} label="Currency" onChange={() => {}} />
-      {/* @ts-expect-error C5 — the home sets the tier; a control carries no `size`. */}
-      <SelectFilter field={local.field.currency} label="Currency" size="xs" />
-      {/* @ts-expect-error C5 — nor a responsive override; the swap is the control's own. */}
-      <ViewTabs field={local.field.currency} visibleFrom="sm" />
-      {/* @ts-expect-error C2 — a tab is store state too. */}
-      <ViewTabs field={local.field.currency} value="USD" />
-      {/* @ts-expect-error a boolean field is not an enum field. */}
-      <ToggleFilter field={local.field.currency} label="Errors only" />
-      {/* @ts-expect-error a multi field is not an enum field. */}
-      <SelectFilter field={local.field.channels} label="Channels" />
-      {/* @ts-expect-error an enum field is not a range field. */}
-      <RangeFilter field={local.field.currency} />
-      {/* @ts-expect-error a string field is not a boolean field. */}
-      <ToggleFilter field={local.field.q} label="Errors only" />
-      {/* @ts-expect-error CompareFilter's enum is the three basalt names, not any enum. */}
-      <CompareFilter field={local.field.currency} />
-      {/* @ts-expect-error `label` is required on SelectFilter — the pill needs a name at rest. */}
-      <SelectFilter field={local.field.currency} />
-      {/* A string field declares no values, so `options` is the only possible row source — without
-          it the popover would render empty. Two overloads rather than one union prop type precisely
-          so the message names `options`; see `SelectFilter`'s own doc. */}
-      {/* @ts-expect-error a string field needs `options` — nothing else can supply the rows. */}
-      <SelectFilter field={local.field.q} label="Project" />
-      {/* @ts-expect-error `options` does not widen a MULTI field into a single-select either. */}
-      <SelectFilter field={local.field.channels} label="Channels" options={PROJECTS} />
-      {/* @ts-expect-error C2 — a number filter is store-bound too; there is no `value`. */}
-      <NumberFilter field={local.field.nights} label="Nights" value={3} />
-      {/* @ts-expect-error C5 — the home sets the tier. `step` is the stepper's increment, not a size. */}
-      <NumberFilter field={local.field.nights} label="Nights" size="xs" />
-      {/* @ts-expect-error an enum field is not a number field — the whole point of the control. */}
-      <NumberFilter field={local.field.currency} label="Nights" />
-      {/* @ts-expect-error `label` is required — the popover and the sheet both need a heading. */}
-      <NumberFilter field={local.field.nights} />
-      {/* NumberFilter's options are NUMBERS. A string here is the exact shape argo reached for when
-          it widened `nights` into an enum, and it has to be a type error rather than a silent
-          `Number('7')` at the boundary. */}
-      <NumberFilter
-        field={local.field.nights}
-        label="Nights"
-        // @ts-expect-error a numeric preset set takes `value: number`, never a numeral string.
-        options={[{ value: '7', label: 'A week' }]}
-      />
-      {/* @ts-expect-error `min`/`max` belong to the FIELD, which is what validates the URL. */}
-      <NumberFilter field={local.field.nights} label="Nights" min={1} />
-    </>
-  )
-}
-
-/** The same call sites, spelled correctly — so a type error above cannot be a false positive. */
-function Accepted(): ReactNode {
-  return (
-    <>
-      <SelectFilter field={local.field.currency} label="Currency" clearable />
-      {/* A runtime catalogue over a closed enum — `options` is optional there. */}
-      <SelectFilter
-        field={local.field.currency}
-        label="Currency"
-        options={[{ value: 'USD', label: 'USD · 1.00' }]}
-      />
-      {/* A string field WITH options — the id set an enum cannot close over. */}
-      <SelectFilter field={local.field.q} label="Project" options={PROJECTS} />
-      <MultiSelectFilter field={local.field.channels} label="All channels" options={CHANNELS} />
-      <CompareFilter field={local.field.compare} />
-      <MultiSelectFilter field={local.field.channels} label="All channels" noun="channels" />
-      <RangeFilter field={local.field.range} />
-      <ToggleFilter field={local.field.errorsOnly} label="Errors only" />
-      <SearchFilter field={local.field.q} placeholder="Search" />
-      <ViewTabs field={local.field.currency} />
-      {/* Both forms, spelled correctly: the preset set, and the open stepper. */}
-      <NumberFilter
-        field={local.field.nights}
-        label="Nights"
-        options={[
-          { value: 1, label: '1 night' },
-          { value: 7, label: 'A week' },
-        ]}
-      />
-      <NumberFilter field={local.field.nights} label="Nights" step={2} />
-    </>
-  )
-}
-
-describe('props contract', () => {
-  test('both fixtures exist — tsc, not bun, is the assertion (see this file header)', () => {
-    expect(typeof Rejected).toBe('function')
-    expect(typeof Accepted).toBe('function')
-  })
-})

package/src/controls/range-filter.type-guard.test.tsx

@@ -1,122 +0,0 @@
-/**
- * `RangeFilterProps` is generic over the FIELD's `custom` flag — the compile-time half, plus the one
- * runtime consequence of leaving `customPicker` out.
- *
- * Why a file of its own (the `actions.type-guard.test.ts` convention): pinning `C` to its default
- * `boolean` made `RangeFilter field={...}` reject a `field.range({ … })` that never declared
- * `custom: true`. The handle's setter is contravariant, so a `RangeValue<P>` setter cannot stand in
- * for a `RangeValue<P | 'custom'>` one — two consumers cast at the call site instead, which is
- * exactly the diagnostic the cast was hiding.
- */
-import { describe, expect, spyOn, test } from 'bun:test'
-import type { ReactNode } from 'react'
-import { MantineProvider } from '@mantine/core'
-import { render, screen } from '@testing-library/react'
-import type { FieldHandle, RangeField } from '../state'
-import { createLocalStore, field } from '../state'
-import { RangeFilter } from './range-filter'
-import type { RangeCustomPickerProps } from './range-filter'
-
-// Two stores, not two range fields in one: every range defaults its `from`/`to` param names, and
-// the store core rejects the collision at definition (see `assertNoParamCollision`).
-const store = createLocalStore({
-  key: 'tg-range',
-  fields: {
-    presetsOnly: field.range({ presets: ['7d', '30d'], fallback: '30d' }),
-    view: field.enum(['chart', 'table'], 'chart'),
-  },
-})
-
-const customStore = createLocalStore({
-  key: 'tg-range-custom',
-  fields: { withCustom: field.range({ presets: ['7d', '30d'], fallback: '30d', custom: true }) },
-})
-
-function Picker({ onChange }: RangeCustomPickerProps): ReactNode {
-  return (
-    <button
-      type="button"
-      onClick={() => {
-        onChange({ from: '2026-03-01', to: '2026-03-14' })
-      }}
-    >
-      pick march
-    </button>
-  )
-}
-
-/** A control that took a range handle from ITS OWN props — `C` widened, which must still bind. */
-function Wrapper({ handle }: { handle: FieldHandle<RangeField<'7d' | '30d'>> }): ReactNode {
-  return <RangeFilter field={handle} customPicker={Picker} />
-}
-
-// ── Valid — must type-check with no error ─────────────────────────────────────
-
-function Accepted(): ReactNode {
-  return (
-    <>
-      {/* The regression: no `custom`, therefore `RangeField<P, false>` — and no cast. */}
-      <RangeFilter field={store.field.presetsOnly} />
-      <RangeFilter field={store.field.presetsOnly} label="Window" />
-      <RangeFilter field={customStore.field.withCustom} customPicker={Picker} />
-      <Wrapper handle={customStore.field.withCustom} />
-    </>
-  )
-}
-
-// ── Invalid — each MUST be a tsc error, one directive per bad line ────────────
-
-function Rejected(): ReactNode {
-  return (
-    <>
-      {/* @ts-expect-error an enum handle is not a range handle, whatever `C` is */}
-      <RangeFilter field={store.field.view} />
-      {/* @ts-expect-error `value`/`onChange` is not the binding a basalt control takes (C2) */}
-      <RangeFilter value={{ preset: '7d' }} onChange={() => {}} />
-    </>
-  )
-}
-
-/** The first argument of every captured warn call. */
-function lines(warn: { mock: { calls: unknown[][] } }): string[] {
-  return warn.mock.calls.map((call) => String(call[0]))
-}
-
-describe('RangeFilterProps (type-guard)', () => {
-  test('both fixtures exist — tsc, not bun, is the assertion for the cases above', () => {
-    expect(typeof Accepted).toBe('function')
-    expect(typeof Rejected).toBe('function')
-  })
-
-  test('a custom-capable field with no picker warns once in dev — the affordance is unreachable', () => {
-    const warn = spyOn(console, 'warn').mockImplementation(() => {})
-    try {
-      render(
-        <MantineProvider>
-          <RangeFilter field={customStore.field.withCustom} label="Unreachable" />
-        </MantineProvider>,
-      )
-      expect(screen.getByRole('button', { name: '30d' })).toBeDefined()
-      expect(
-        lines(warn).filter((line) => line.includes("RangeFilter('Unreachable')")),
-      ).toHaveLength(1)
-      expect(lines(warn)[0]).toContain('customPicker')
-    } finally {
-      warn.mockRestore()
-    }
-  })
-
-  test('a preset-only field is silent — presets only is a configuration, not a mistake', () => {
-    const warn = spyOn(console, 'warn').mockImplementation(() => {})
-    try {
-      render(
-        <MantineProvider>
-          <RangeFilter field={store.field.presetsOnly} label="Silent" />
-        </MantineProvider>,
-      )
-      expect(lines(warn).filter((line) => line.includes("RangeFilter('Silent')"))).toHaveLength(0)
-    } finally {
-      warn.mockRestore()
-    }
-  })
-})

package/src/controls/sync-button.test.tsx

@@ -1,183 +0,0 @@
-/**
- * `SyncButton` — the age formatting and the syncing state (law C12, `docs/CONTROLS-SPEC.md` §3).
- *
- * The age is the part that had four hand-rolled copies across consumers, each with its own
- * rounding; `formatAge` is asserted directly so the boundaries are pinned, not inferred from one
- * rendered string.
- */
-import { MantineProvider } from '@mantine/core'
-import { fireEvent, render, screen } from '@testing-library/react'
-import { renderToStaticMarkup } from 'react-dom/server'
-import { describe, expect, test } from 'bun:test'
-import { AGE_REFRESH_MS, SyncButton, formatAge } from './sync-button'
-
-function renderSync(props: Partial<Parameters<typeof SyncButton>[0]> = {}) {
-  return render(
-    <MantineProvider>
-      <SyncButton syncing={false} scope="page" onSync={() => {}} {...props} />
-    </MantineProvider>,
-  )
-}
-
-describe('formatAge', () => {
-  test('anything under a minute is `just now`, so a fresh sync stops flickering', () => {
-    expect(formatAge(0)).toBe('just now')
-    expect(formatAge(59_000)).toBe('just now')
-  })
-
-  test('minutes, then hours, then days', () => {
-    expect(formatAge(60_000)).toBe('1m ago')
-    expect(formatAge(2 * 60_000)).toBe('2m ago')
-    expect(formatAge(59 * 60_000)).toBe('59m ago')
-    expect(formatAge(60 * 60_000)).toBe('1h ago')
-    expect(formatAge(23 * 60 * 60_000)).toBe('23h ago')
-    expect(formatAge(24 * 60 * 60_000)).toBe('1d ago')
-  })
-
-  test('the refresh interval is coarser than the smallest unit it renders', () => {
-    expect(AGE_REFRESH_MS).toBeLessThanOrEqual(60_000)
-  })
-})
-
-describe('SyncButton', () => {
-  test('renders the age beside the label on desktop', () => {
-    renderSync({ lastCompletedAt: Date.now() - 2 * 60_000 })
-    expect(screen.getByRole('button').textContent).toContain('Sync')
-    expect(screen.getByRole('button').textContent).toContain('2m ago')
-  })
-
-  test('a Date and an epoch number are the same input', () => {
-    renderSync({ lastCompletedAt: new Date(Date.now() - 3 * 60_000) })
-    expect(screen.getByRole('button').textContent).toContain('3m ago')
-  })
-
-  test('no age at all when nothing has completed yet', () => {
-    renderSync({ lastCompletedAt: null })
-    expect(screen.getByRole('button').textContent).toBe('Sync')
-  })
-
-  test('syncing announces itself and refuses a second click — WITHOUT losing focus', () => {
-    let presses = 0
-    renderSync({
-      syncing: true,
-      onSync: () => {
-        presses += 1
-      },
-    })
-    const button = screen.getByRole('button')
-
-    expect(button.getAttribute('aria-busy')).toBe('true')
-    expect(button.getAttribute('aria-disabled')).toBe('true')
-    // The NATIVE attribute is what drops focus to <body> mid-press, so it must stay off: a keyboard
-    // user who presses Sync has to still be standing on the button when the sync lands.
-    expect(button.hasAttribute('disabled')).toBe(false)
-    expect(button.hasAttribute('data-disabled')).toBe(true)
-
-    button.focus()
-    fireEvent.click(button)
-    expect(presses).toBe(0)
-    expect(document.activeElement).toBe(button)
-  })
-
-  test('an idle press does call onSync — the refusal above is not just a dead handler', () => {
-    let presses = 0
-    renderSync({
-      onSync: () => {
-        presses += 1
-      },
-    })
-    fireEvent.click(screen.getByRole('button'))
-    expect(presses).toBe(1)
-  })
-
-  test('the age is absent on the server, so hydration cannot mismatch it', () => {
-    // `Date.now()` during render is the whole bug: the server renders one age and a client hydrating
-    // a minute later renders another. Both must render NO age; the effect fills it in after mount.
-    const html = renderToStaticMarkup(
-      <MantineProvider>
-        <SyncButton
-          syncing={false}
-          scope="page"
-          onSync={() => {}}
-          lastCompletedAt={Date.now() - 5 * 60_000}
-        />
-      </MantineProvider>,
-    )
-    expect(html).not.toContain('5m ago')
-    expect(html).toContain('Sync')
-  })
-
-  test('an error puts the control in the danger tone', () => {
-    renderSync({ error: 'Upstream 503' })
-    expect(screen.getByRole('button').getAttribute('data-variant')).toBe('default')
-    expect(document.querySelector('[data-basalt-sync-scope="page"]')).not.toBeNull()
-  })
-
-  test('the error message is in the accessible name, not only in a hover tooltip', () => {
-    // A tooltip announces only while open, and Mantine's opens on hover ALONE by default — so
-    // without this the red colour is the entire signal for a keyboard or screen-reader user.
-    renderSync({ error: 'Rate limited' })
-    expect(screen.getByRole('button', { name: 'Sync — Rate limited' })).toBeDefined()
-  })
-
-  test('scope reaches the DOM so a call site is readable without reading the props', () => {
-    renderSync({ scope: 'global' })
-    expect(document.querySelector('[data-basalt-sync-scope="global"]')).not.toBeNull()
-  })
-})
-
-/**
- * The shape per scope. `scope` used to be documentation only; it now picks the form, because the
- * shell header has no room for a labelled button beside the breadcrumb, `PageBar` row 1 and every
- * other global action — and a page bar does (spec §3, law C12).
- */
-describe('the shape follows the scope', () => {
-  test('global renders an ActionIcon with no label text at any width', () => {
-    renderSync({ scope: 'global', label: 'Sync all' })
-    const button = screen.getByRole('button')
-    // Mantine's own class names are static strings (unlike a CSS-module hash), so which PRIMITIVE
-    // rendered is assertable — and it is the whole difference between the two forms.
-    expect(button.classList.contains('mantine-ActionIcon-root')).toBe(true)
-    // Icon-only on EVERY viewport, so there is no text to hide with a media query in the first
-    // place: the label reaches the user as the accessible name only.
-    expect(button.textContent).toBe('')
-    expect(screen.getByRole('button', { name: 'Sync all' })).toBeDefined()
-  })
-
-  test('a global button carries no rendered age either — the tooltip is its only home', () => {
-    renderSync({ scope: 'global', lastCompletedAt: Date.now() - 4 * 60_000 })
-    expect(screen.getByRole('button').textContent).toBe('')
-  })
-
-  test('page renders the labelled Button, and is named even once the label is hidden below sm', () => {
-    renderSync({ scope: 'page' })
-    const button = screen.getByRole('button')
-    expect(button.classList.contains('mantine-Button-root')).toBe(true)
-    expect(button.textContent).toBe('Sync')
-    // jsdom evaluates no media query, so the `display: none` below `sm` is not observable here —
-    // what IS observable is the half that makes it safe: `display: none` text leaves the
-    // accessibility tree, so the name has to come from `aria-label`, not from the children.
-    expect(button.getAttribute('aria-label')).toBe('Sync')
-  })
-
-  test('both scopes fold an error into the accessible name, not only into the tone', () => {
-    renderSync({ scope: 'global', error: 'Upstream 503' })
-    expect(screen.getByRole('button', { name: 'Sync — Upstream 503' })).toBeDefined()
-  })
-
-  test('a global button refuses a second click while syncing, exactly as the page form does', () => {
-    let presses = 0
-    renderSync({
-      scope: 'global',
-      syncing: true,
-      onSync: () => {
-        presses += 1
-      },
-    })
-    const button = screen.getByRole('button')
-    expect(button.getAttribute('aria-disabled')).toBe('true')
-    expect(button.hasAttribute('disabled')).toBe(false)
-    fireEvent.click(button)
-    expect(presses).toBe(0)
-  })
-})

package/src/dashboard/query-state.test.tsx

@@ -1,152 +0,0 @@
-/**
- * `QueryState` exists because shipping only `EmptyState` produced a correctness bug in a real
- * consumer: a 500 rendered "No images", a dropped connection rendered "Share not found — it may
- * have been deleted". Every assertion here is aimed at that failure mode rather than at chrome.
- *
- *  1. A FAILED query never renders the empty copy. This is the bug, stated as a test.
- *  2. A failed query WITH cached data keeps the page and adds a banner — a background refetch
- *     failing must not blank a screen that already works.
- *  3. `fetchStatus: 'idle'` with no data is EMPTY, not loading (the `enabled: false` case);
- *     `'fetching'` with no data is loading.
- *  4. A result missing a branch flag THROWS. `QueryStateLike` is a structural subset on purpose,
- *     so the compiler stops policing it — and every field it can lose fails silently in the
- *     direction of a false claim about the data.
- */
-import { MantineProvider } from '@mantine/core'
-import { render, screen } from '@testing-library/react'
-import { describe, expect, test } from 'bun:test'
-import type { ReactNode } from 'react'
-import { QueryState } from './query-state'
-import type { QueryStateLike } from './query-state'
-
-type Row = { id: number }
-
-function result(over: Partial<QueryStateLike<Row[]>>): QueryStateLike<Row[]> {
-  return {
-    data: undefined,
-    isError: false,
-    error: null,
-    fetchStatus: 'idle',
-    refetch: () => undefined,
-    ...over,
-  }
-}
-
-const EMPTY = { title: 'No images match', description: 'Widen the capture dates.' }
-
-function renderState(query: QueryStateLike<Row[]>, extra?: ReactNode): HTMLElement {
-  const { container } = render(
-    <MantineProvider>
-      <QueryState query={query} empty={EMPTY} errorTitle="Could not load images">
-        {(rows) => <div data-testid="body">{rows.length} rows</div>}
-      </QueryState>
-      {extra}
-    </MantineProvider>,
-  )
-  return container
-}
-
-describe('the branch a 500 must not take', () => {
-  test('an errored query renders the server message, never the empty copy', () => {
-    renderState(
-      result({ isError: true, error: { status: 500, value: { message: 'index is rebuilding' } } }),
-    )
-    expect(screen.getByText('index is rebuilding')).toBeTruthy()
-    expect(screen.queryByText('No images match')).toBeNull()
-    expect(screen.getByRole('button', { name: 'Retry' })).toBeTruthy()
-  })
-
-  test('an opaque 500 envelope falls back to the errorTitle copy plus the status', () => {
-    render(
-      <MantineProvider>
-        <QueryState
-          query={result({ isError: true, error: { status: 500, value: {} } })}
-          errorTitle="Could not load images"
-          errorFallback="The library did not answer."
-        >
-          {() => null}
-        </QueryState>
-      </MantineProvider>,
-    )
-    expect(screen.getByText('The library did not answer. (HTTP 500)')).toBeTruthy()
-  })
-
-  test('retry calls refetch', () => {
-    let calls = 0
-    renderState(result({ isError: true, error: new Error('down'), refetch: () => ++calls }))
-    ;(screen.getByRole('button', { name: 'Retry' }) as HTMLButtonElement).click()
-    expect(calls).toBe(1)
-  })
-})
-
-describe('cached data survives a failed refresh', () => {
-  test('error WITH data renders the body plus a banner, not the error page', () => {
-    renderState(result({ data: [{ id: 1 }], isError: true, error: new Error('refresh failed') }))
-    expect(screen.getByTestId('body').textContent).toBe('1 rows')
-    expect(screen.getByText('Showing cached data')).toBeTruthy()
-  })
-})
-
-describe('empty vs loading', () => {
-  test('no data + idle is EMPTY (the enabled:false case)', () => {
-    renderState(result({ fetchStatus: 'idle' }))
-    expect(screen.getByText('No images match')).toBeTruthy()
-  })
-
-  test('no data + fetching is LOADING', () => {
-    renderState(result({ fetchStatus: 'fetching' }))
-    expect(screen.queryByText('No images match')).toBeNull()
-    expect(screen.getByLabelText('Loading')).toBeTruthy()
-  })
-
-  test('an empty array is empty; a populated one renders children', () => {
-    renderState(result({ data: [] }))
-    expect(screen.getByText('No images match')).toBeTruthy()
-  })
-
-  test('isEmpty overrides the default test', () => {
-    render(
-      <MantineProvider>
-        <QueryState query={result({ data: [] })} empty={EMPTY} isEmpty={() => false}>
-          {(rows) => <div data-testid="body">{rows.length} rows</div>}
-        </QueryState>
-      </MantineProvider>,
-    )
-    expect(screen.getByTestId('body').textContent).toBe('0 rows')
-  })
-
-  test('omitting `empty` renders nothing rather than inventing copy', () => {
-    render(
-      <MantineProvider>
-        <QueryState query={result({ data: [] })}>{() => <div>rows</div>}</QueryState>
-      </MantineProvider>,
-    )
-    expect(screen.queryByText('rows')).toBeNull()
-  })
-})
-
-describe('a malformed result throws instead of asserting absence', () => {
-  const cases: [string, unknown][] = [
-    ['missing isError', { data: undefined, error: null, fetchStatus: 'idle', refetch: () => 0 }],
-    [
-      'misspelled fetchStatus',
-      { data: undefined, isError: false, error: null, fetchStatus: 'pending', refetch: () => 0 },
-    ],
-    ['missing refetch', { data: undefined, isError: false, error: null, fetchStatus: 'idle' }],
-    ['not an object at all', ['a', 'b']],
-  ]
-
-  for (const [name, bad] of cases) {
-    test(name, () => {
-      expect(() =>
-        render(
-          <MantineProvider>
-            <QueryState query={bad as QueryStateLike<Row[]>} empty={EMPTY}>
-              {() => null}
-            </QueryState>
-          </MantineProvider>,
-        ),
-      ).toThrow(/QueryState: `query`/)
-    })
-  }
-})

package/src/dashboard/settings-section.test.tsx

@@ -1,56 +0,0 @@
-/**
- * SettingsSection / DangerZone — the WidgetHeader composition (docs/CONTROLS-SPEC.md §2.2):
- * `description` renamed to `subtitle`, both now render an h2 (`tier="section"`) via `WidgetHeader`,
- * and `actions` reaches the header's actions slot.
- */
-import { MantineProvider } from '@mantine/core'
-import { render, screen } from '@testing-library/react'
-import { describe, expect, test } from 'bun:test'
-import type { ReactElement } from 'react'
-import { DangerZone, SettingsSection } from './settings-section'
-
-function renderWith(node: ReactElement) {
-  return render(<MantineProvider>{node}</MantineProvider>)
-}
-
-describe('SettingsSection composes WidgetHeader at the section tier', () => {
-  test('renders an h2 carrying the title', () => {
-    renderWith(
-      <SettingsSection title="Profile">
-        <div>rows</div>
-      </SettingsSection>,
-    )
-    expect(screen.getByRole('heading', { level: 2, name: 'Profile' })).toBeDefined()
-  })
-
-  test('subtitle (renamed from description) renders below the title', () => {
-    renderWith(
-      <SettingsSection title="Profile" subtitle="Your public identity.">
-        <div>rows</div>
-      </SettingsSection>,
-    )
-    expect(screen.getByText('Your public identity.')).toBeDefined()
-  })
-
-  test('actions reach the header actions slot', () => {
-    renderWith(
-      <SettingsSection title="Profile" actions={<button type="button">Export</button>}>
-        <div>rows</div>
-      </SettingsSection>,
-    )
-    expect(screen.getByRole('button', { name: 'Export' })).toBeDefined()
-  })
-})
-
-describe('DangerZone keeps its eyebrow alongside the WidgetHeader', () => {
-  test('renders the eyebrow and an h2 title', () => {
-    renderWith(
-      <DangerZone title="Delete workspace" subtitle="This action cannot be undone.">
-        <div>rows</div>
-      </DangerZone>,
-    )
-    expect(screen.getByText('Danger Zone')).toBeDefined()
-    expect(screen.getByRole('heading', { level: 2, name: 'Delete workspace' })).toBeDefined()
-    expect(screen.getByText('This action cannot be undone.')).toBeDefined()
-  })
-})