@open-mercato/ui 0.6.8-develop.7099.1.7ba2771d06 → 0.7.0

package/src/backend/inputs/__tests__/ComboboxInput.test.tsx

@@ -396,148 +396,6 @@ describe('ComboboxInput — eager label resolution', () => {
     rerender(<ComboboxInput value="b" onChange={() => {}} resolveLabel={resolveLabel} />)
     await waitFor(() => expect(getInput(container).value).toBe('Label-b'))
   })
-
-  it('shows a default value that arrives after autoFocus already took the field', async () => {
-    const options = [{ value: 'wh-1', label: 'Central warehouse' }]
-    const { container, rerender } = render(
-      <ComboboxInput value="" onChange={() => {}} autoFocus seedOptions={options} />,
-    )
-    expect(document.activeElement).toBe(getInput(container))
-    rerender(<ComboboxInput value="wh-1" onChange={() => {}} autoFocus seedOptions={options} />)
-    await waitFor(() => expect(getInput(container).value).toBe('Central warehouse'))
-  })
-
-  // Guards the opposite direction of the case above: it passes on both the old
-  // focus-based guard and the current typing-based one, so it is a behavior pin
-  // rather than a regression test for any specific bug.
-  it('does not overwrite the query while the user is typing into a focused field', async () => {
-    const options = [
-      { value: 'red', label: 'Red' },
-      { value: 'green', label: 'Green' },
-    ]
-    const { container, rerender } = render(
-      <ComboboxInput value="red" onChange={() => {}} seedOptions={options} />,
-    )
-    await waitFor(() => expect(getInput(container).value).toBe('Red'))
-    const input = getInput(container)
-    act(() => {
-      input.focus()
-      fireEvent.change(input, { target: { value: 'gre' } })
-    })
-    rerender(<ComboboxInput value="green" onChange={() => {}} seedOptions={options} />)
-    expect(getInput(container).value).toBe('gre')
-  })
-
-  // The regression the typing-based guard originally introduced: `selectValue` clears
-  // `userTypedRef` while the field keeps focus, so a follow-up load that no longer
-  // carries the picked option let the self-mapping placeholder overwrite the label with
-  // the raw record id. Fails on the intermediate implementation, passes on this one.
-  it('keeps a picked label when a follow-up load drops the option from the list', async () => {
-    const loadSuggestions = jest.fn(async (query?: string) =>
-      query === 'WH-B' ? [{ value: 'wh-b', label: 'Warehouse B (WH-B)' }] : [],
-    )
-    function Controlled() {
-      const [value, setValue] = React.useState('')
-      return (
-        <ComboboxInput
-          value={value}
-          onChange={setValue}
-          loadSuggestions={loadSuggestions}
-          allowCustomValues={false}
-        />
-      )
-    }
-    const { container } = render(<Controlled />)
-    const input = getInput(container)
-    act(() => {
-      input.focus()
-      fireEvent.change(input, { target: { value: 'WH-B' } })
-    })
-
-    const option = await screen.findByRole('option', { name: /Warehouse B \(WH-B\)/ })
-    act(() => {
-      fireEvent.click(option)
-    })
-    expect(getInput(container).value).toBe('Warehouse B (WH-B)')
-    expect(document.activeElement).toBe(getInput(container))
-
-    // Picking rewrote the query to the label, which re-fires the debounced loader; the
-    // route cannot match a composite label, so the option list comes back empty.
-    await waitFor(() => expect(loadSuggestions).toHaveBeenCalledWith('Warehouse B (WH-B)'))
-    await act(async () => {
-      await new Promise((res) => setTimeout(res, 250))
-    })
-    expect(getInput(container).value).toBe('Warehouse B (WH-B)')
-  })
-
-  it('adopts a real label that arrives while the field is focused', async () => {
-    const { container, rerender } = render(
-      <ComboboxInput value="wh-1" onChange={() => {}} seedOptions={[]} />,
-    )
-    const input = getInput(container)
-    act(() => {
-      input.focus()
-    })
-    expect(getInput(container).value).toBe('wh-1')
-
-    rerender(
-      <ComboboxInput
-        value="wh-1"
-        onChange={() => {}}
-        seedOptions={[{ value: 'wh-1', label: 'Central warehouse' }]}
-      />,
-    )
-    await waitFor(() => expect(getInput(container).value).toBe('Central warehouse'))
-  })
-
-  it('does not resurrect the previous label when the parent keeps the value after a clear', () => {
-    const onChange = jest.fn()
-    const { container } = render(
-      <ComboboxInput
-        value="red"
-        onChange={onChange}
-        clearable
-        seedOptions={[{ value: 'red', label: 'Red' }]}
-      />,
-    )
-    expect(getInput(container).value).toBe('Red')
-
-    act(() => {
-      fireEvent.click(screen.getByRole('button', { name: /clear value/i }))
-    })
-
-    expect(onChange).toHaveBeenCalledWith('')
-    expect(getInput(container).value).toBe('')
-  })
-
-  it('resumes syncing after a blur, so a later external change is not mistaken for typing', async () => {
-    const options = [
-      { value: 'red', label: 'Red' },
-      { value: 'green', label: 'Green' },
-    ]
-    const { container, rerender } = render(
-      <ComboboxInput value="red" onChange={() => {}} seedOptions={options} allowCustomValues={false} />,
-    )
-    const input = getInput(container)
-    act(() => {
-      input.focus()
-      fireEvent.change(input, { target: { value: 'gre' } })
-    })
-    expect(getInput(container).value).toBe('gre')
-
-    act(() => {
-      fireEvent.blur(input)
-    })
-    await waitFor(() => expect(getInput(container).value).toBe('Red'))
-
-    act(() => {
-      getInput(container).focus()
-    })
-    rerender(
-      <ComboboxInput value="green" onChange={() => {}} seedOptions={options} allowCustomValues={false} />,
-    )
-    await waitFor(() => expect(getInput(container).value).toBe('Green'))
-  })
 })
 
 describe('ComboboxInput accessibility', () => {

package/src/backend/inputs/__tests__/LookupSelect.test.tsx

@@ -162,79 +162,56 @@ describe('LookupSelect keyboard accessibility', () => {
     expect(input.value).toBe('')
     expect(escapeSpy).not.toHaveBeenCalled()
   })
-})
-
-// `disabled` used to gate only the search box, so a caller that locked the
-// control still shipped a live option list: the selected card kept its click and
-// Enter/Space handlers, "Clear selection" stayed reachable, and the action slot
-// could still create a new record. Issue #5248 depended on `disabled` meaning
-// "no interaction at all", so every one of those paths is pinned here.
-describe('LookupSelect disabled', () => {
-  const SELECTED = [{ id: 'product-1', title: 'Product One' }]
 
-  function renderDisabled(onChange: (next: string | null) => void) {
-    return render(
-      <LookupSelect
-        value="product-1"
-        onChange={onChange}
-        options={SELECTED}
-        disabled
-        actionSlot={
-          <button type="button" data-testid="quick-create">
-            Create
-          </button>
-        }
-        clearLabel="Clear selection"
-      />,
+  // Issue #5456 item 3: a `minQuery` of 0 makes `shouldSearch` true for the empty
+  // query, so the full option list renders before any interaction. Callers that
+  // want the collapsed "start typing" affordance must keep minQuery >= 1.
+  it('renders pre-expanded with minQuery=0 and collapsed with minQuery=1', async () => {
+    const expanded = render(
+      <LookupSelect value={null} onChange={() => {}} fetchItems={async () => ITEMS} minQuery={0} />,
     )
-  }
+    expect(await expanded.findAllByRole('option')).toHaveLength(2)
+    expanded.unmount()
 
-  it('still shows the current selection so the value stays readable', () => {
-    renderDisabled(() => {})
-    expect(screen.getByRole('option')).toHaveTextContent('Product One')
-  })
-
-  it('ignores clicks on the option row', () => {
-    const onChange = jest.fn()
-    renderDisabled(onChange)
-
-    fireEvent.click(screen.getByRole('option'))
+    const collapsed = render(
+      <LookupSelect value={null} onChange={() => {}} fetchItems={async () => ITEMS} minQuery={1} />,
+    )
+    expect(collapsed.queryByRole('listbox')).toBeNull()
+    expect(collapsed.getByText('Start typing to search.')).toBeInTheDocument()
 
-    expect(onChange).not.toHaveBeenCalled()
+    fireEvent.change(getInput(collapsed.container), { target: { value: 'F' } })
+    expect(await collapsed.findAllByRole('option')).toHaveLength(2)
   })
 
-  it('ignores Enter and Space on the option row and keeps it out of the tab order', () => {
+  // A selection must never be invisible. Before this, `shouldSearch` only made an
+  // exception for a set `value` when the caller ALSO passed `options`, so a
+  // minQuery >= 1 lookup without that prop collapsed over its own selection: no
+  // selected row, no checkmark and no clear control — the user could not see or
+  // undo what was chosen (review of #5481, order-line Status field).
+  it('keeps a made selection visible while collapsed, without an options prop', async () => {
     const onChange = jest.fn()
-    renderDisabled(onChange)
-    const option = screen.getByRole('option')
-
-    fireEvent.keyDown(option, { key: 'Enter' })
-    fireEvent.keyDown(option, { key: ' ' })
-
-    expect(onChange).not.toHaveBeenCalled()
-    expect(option).toHaveAttribute('tabindex', '-1')
-    expect(option).toHaveAttribute('aria-disabled', 'true')
-  })
+    const view = render(
+      <LookupSelect
+        value="plot-1"
+        onChange={onChange}
+        fetchItems={async () => ITEMS}
+        minQuery={1}
+      />,
+    )
 
-  it('hides the clear-selection button so the value cannot be nulled', () => {
-    renderDisabled(() => {})
-    expect(screen.queryByRole('button', { name: /clear selection/i })).toBeNull()
-  })
+    const selected = await view.findByRole('option', { selected: true })
+    expect(selected).toHaveTextContent(ITEMS[0].title)
 
-  it('hides the action slot so no new record can be created into a locked field', () => {
-    renderDisabled(() => {})
-    expect(screen.queryByTestId('quick-create')).toBeNull()
+    const clear = view.getByRole('button', { name: 'Clear selection' })
+    fireEvent.click(clear)
+    expect(onChange).toHaveBeenCalledWith(null)
   })
 
-  it('keeps the search box disabled and its keyboard path inert', () => {
-    const onChange = jest.fn()
-    const { container } = renderDisabled(onChange)
-    const input = getInput(container)
-
-    expect(input.disabled).toBe(true)
-    fireEvent.keyDown(input, { key: 'ArrowDown' })
-    fireEvent.keyDown(input, { key: 'Enter' })
-
-    expect(onChange).not.toHaveBeenCalled()
+  it('stays collapsed at minQuery >= 1 once the selection is cleared', async () => {
+    const view = render(
+      <LookupSelect value={null} onChange={() => {}} fetchItems={async () => ITEMS} minQuery={1} />,
+    )
+    expect(view.queryByRole('listbox')).toBeNull()
+    expect(view.getByText('Start typing to search.')).toBeInTheDocument()
   })
 })

package/src/backend/sidebar/SidebarCustomizationEditor.tsx

@@ -1579,10 +1579,11 @@ function SidebarPreview({
 
   return (
     <div className="relative w-[240px] overflow-hidden rounded-xl border bg-background shadow-sm">
-      {/* Match AppShell's full-width group boxes with padding applied by each inner region. */}
-      <div className="flex flex-col gap-3 py-4">
+      {/* Match AppShell's outer aside: border-r, py-4, px-3 — minus border-r since the
+          card border already serves that purpose, plus rounded so it reads as a preview tile. */}
+      <div className="flex flex-col gap-3 px-3 py-4">
         {/* Brand block — same classes as AppShell brand tile */}
-        <div className="mb-2 px-3">
+        <div className="mb-2">
           <div className="flex items-center gap-3 rounded-xl p-3">
             <Image
               src="/open-mercato.svg"
@@ -1595,13 +1596,11 @@ function SidebarPreview({
           </div>
         </div>
         {/* Search input mock — same container styling as the real sidebar */}
-        <div className="px-3">
-          <div className="mb-2 flex items-center gap-2 rounded-lg border border-border bg-background pl-2.5 pr-2 py-2 shadow-sm">
-            <Search className="size-4 shrink-0 text-muted-foreground" aria-hidden />
-            <span className="min-w-0 flex-1 text-sm text-muted-foreground/70 truncate">
-              {t('appShell.sidebarCustomizationPreviewSearchPlaceholder', 'Search...')}
-            </span>
-          </div>
+        <div className="mb-2 flex items-center gap-2 rounded-lg border border-border bg-background pl-2.5 pr-2 py-2 shadow-sm">
+          <Search className="size-4 shrink-0 text-muted-foreground" aria-hidden />
+          <span className="min-w-0 flex-1 text-sm text-muted-foreground/70 truncate">
+            {t('appShell.sidebarCustomizationPreviewSearchPlaceholder', 'Search...')}
+          </span>
         </div>
         {groups.length === 0 ? (
           <p className="px-2 text-sm text-muted-foreground">
@@ -1613,10 +1612,7 @@ function SidebarPreview({
               const visibleItems = group.items.filter((item) => item.hidden !== true)
               if (visibleItems.length === 0) return null
               return (
-                <div
-                  key={resolveGroupKey(group)}
-                  className={`px-3 ${gi < groups.length - 1 ? 'border-b pb-2' : ''}`}
-                >
+                <div key={resolveGroupKey(group)}>
                   <div className="w-full px-1 justify-between flex text-xs font-medium uppercase tracking-wider text-muted-foreground/70 py-1">
                     <span>{group.name}</span>
                   </div>
@@ -1645,6 +1641,7 @@ function SidebarPreview({
                       )
                     })}
                   </div>
+                  {gi < groups.length - 1 ? <div className="my-2 border-t -ml-3 -mr-4" /> : null}
                 </div>
               )
             })}

package/src/backend/utils/__tests__/useAutoDiscoveredFields.groupLabels.test.tsx

@@ -0,0 +1,59 @@
+/**
+ * @jest-environment jsdom
+ */
+import * as React from 'react'
+import { renderHook } from '@testing-library/react'
+import type { LegacyColumnDef as ColumnDef } from '@tanstack/react-table/legacy'
+import { I18nProvider } from '@open-mercato/shared/lib/i18n/context'
+import { useAutoDiscoveredFields } from '../useAutoDiscoveredFields'
+import type { CustomFieldDefDto } from '../customFieldDefs'
+
+type Row = { id: string; name: string }
+
+const COLUMNS: ColumnDef<Row>[] = [
+  { accessorKey: 'name', header: 'Name' },
+  { accessorKey: 'grouped', header: 'Grouped', meta: { columnChooserGroup: 'Shipping' } },
+]
+
+const CUSTOM_FIELD_DEFS = [
+  { key: 'note', label: 'Note', kind: 'text' },
+] as unknown as CustomFieldDefDto[]
+
+function wrapperFor(locale: string, dict: Record<string, string>) {
+  return function Wrapper({ children }: { children: React.ReactNode }) {
+    return <I18nProvider locale={locale} dict={dict}>{children}</I18nProvider>
+  }
+}
+
+function renderFields(locale: string, dict: Record<string, string>) {
+  return renderHook(
+    () => useAutoDiscoveredFields<Row>({ columns: COLUMNS, customFieldDefs: CUSTOM_FIELD_DEFS }),
+    { wrapper: wrapperFor(locale, dict) },
+  ).result.current
+}
+
+describe('useAutoDiscoveredFields group labels', () => {
+  it('falls back to English group labels when no translation is registered', () => {
+    const { columnChooserFields } = renderFields('en', {})
+    expect(columnChooserFields.find((field) => field.key === 'name')?.group).toBe('Columns')
+    expect(columnChooserFields.find((field) => field.key === 'cf_note')?.group).toBe('Custom Fields')
+  })
+
+  it('translates the default and custom-field group labels', () => {
+    const { columnChooserFields, advancedFilterFields } = renderFields('pl', {
+      'ui.columnChooser.defaultGroup': 'Kolumny',
+      'ui.columnChooser.customFieldsGroup': 'Pola niestandardowe',
+    })
+    expect(columnChooserFields.find((field) => field.key === 'name')?.group).toBe('Kolumny')
+    expect(columnChooserFields.find((field) => field.key === 'cf_note')?.group).toBe('Pola niestandardowe')
+    expect(advancedFilterFields.find((field) => field.key === 'cf_note')?.group).toBe('Pola niestandardowe')
+  })
+
+  it('keeps explicit column-chooser groups untouched', () => {
+    const { columnChooserFields } = renderFields('pl', {
+      'ui.columnChooser.defaultGroup': 'Kolumny',
+      'ui.columnChooser.customFieldsGroup': 'Pola niestandardowe',
+    })
+    expect(columnChooserFields.find((field) => field.key === 'grouped')?.group).toBe('Shipping')
+  })
+})

package/src/backend/utils/crud.ts

@@ -6,8 +6,6 @@ export type ListResponse<T> = {
   page: number
   pageSize: number
   totalPages: number
-  /** Present (true) when the server capped the count: `total`/`totalPages` are floors. */
-  totalIsCapped?: boolean
 }
 
 export type CrudExportFormat = 'csv' | 'json' | 'xml' | 'markdown'

package/src/backend/utils/useAutoDiscoveredFields.ts

@@ -2,6 +2,7 @@
 import * as React from 'react'
 import type { RowData } from '@tanstack/react-table'
 import type { LegacyColumnDef as ColumnDef } from '@tanstack/react-table/legacy'
+import { useOptionalT } from '@open-mercato/shared/lib/i18n/context'
 import type { FilterFieldDef as AdvancedFilterFieldDef, FilterFieldType, FilterOption } from '@open-mercato/shared/lib/query/advanced-filter'
 import type { ColumnChooserField } from '../columns/ColumnChooserPanel'
 import type { CustomFieldDefDto } from './customFieldDefs'
@@ -61,6 +62,11 @@ export function useAutoDiscoveredFields<T extends RowData = RowData>({
   columns,
   customFieldDefs,
 }: UseAutoDiscoveredFieldsInput<T>): UseAutoDiscoveredFieldsResult {
+  // Optional translator: this hook is a public entry point third-party modules
+  // render, and it worked without an I18nProvider before it needed labels.
+  const t = useOptionalT()
+  const defaultGroupLabel = t?.('ui.columnChooser.defaultGroup', 'Columns') ?? 'Columns'
+  const customFieldsGroupLabel = t?.('ui.columnChooser.customFieldsGroup', 'Custom Fields') ?? 'Custom Fields'
   return React.useMemo(() => {
     const filterFields: AdvancedFilterFieldDef[] = []
     const chooserFields: ColumnChooserField[] = []
@@ -99,7 +105,7 @@ export function useAutoDiscoveredFields<T extends RowData = RowData>({
         chooserFields.push({
           key: accessorKey,
           label,
-          group: meta?.columnChooserGroup ?? 'Columns',
+          group: meta?.columnChooserGroup ?? defaultGroupLabel,
           alwaysVisible: meta?.alwaysVisible ?? i === 0,
           defaultVisible: true,
         })
@@ -118,7 +124,7 @@ export function useAutoDiscoveredFields<T extends RowData = RowData>({
           key: filterKey,
           label: def.label || def.key,
           type,
-          group: 'Custom Fields',
+          group: customFieldsGroupLabel,
         }
         if (type === 'select' && Array.isArray(def.options) && def.options.length) {
           field.options = normalizeCustomFieldFilterOptions(def.options)
@@ -130,12 +136,12 @@ export function useAutoDiscoveredFields<T extends RowData = RowData>({
         chooserFields.push({
           key: filterKey,
           label: def.label || def.key,
-          group: def.group?.title ?? 'Custom Fields',
+          group: def.group?.title ?? customFieldsGroupLabel,
           defaultVisible: false,
         })
       }
     }
 
     return { advancedFilterFields: filterFields, columnChooserFields: chooserFields }
-  }, [columns, customFieldDefs])
+  }, [columns, customFieldDefs, defaultGroupLabel, customFieldsGroupLabel])
 }

package/src/primitives/__tests__/alert.test.tsx

@@ -189,47 +189,7 @@ describe('Alert primitive', () => {
       </Alert>,
     )
     expect(screen.getByText('Saved').tagName).toBe('H5')
-    expect(screen.getByText('Your changes were saved.').tagName).toBe('DIV')
-  })
-
-  describe('AlertDescription accepts block-level children', () => {
-    it('renders a div so nested paragraphs stay valid HTML', () => {
-      const { container } = render(
-        <Alert status="information">
-          <AlertDescription>
-            <p>First paragraph.</p>
-            <p>Second paragraph.</p>
-          </AlertDescription>
-        </Alert>,
-      )
-      expect(screen.getByText('First paragraph.').parentElement?.tagName).toBe('DIV')
-      expect(container.querySelectorAll('p p')).toHaveLength(0)
-    })
-
-    it('keeps a nested list out of a paragraph', () => {
-      const { container } = render(
-        <Alert status="warning">
-          <AlertDescription>
-            <p>These records changed:</p>
-            <ul>
-              <li>r-1</li>
-            </ul>
-          </AlertDescription>
-        </Alert>,
-      )
-      expect(container.querySelectorAll('p ul')).toHaveLength(0)
-      expect(container.querySelectorAll('p p')).toHaveLength(0)
-    })
-
-    it('forwards a ref to the rendered div', () => {
-      const ref = React.createRef<HTMLDivElement>()
-      render(
-        <Alert>
-          <AlertDescription ref={ref}>Body</AlertDescription>
-        </Alert>,
-      )
-      expect(ref.current).toBeInstanceOf(HTMLDivElement)
-    })
+    expect(screen.getByText('Your changes were saved.').tagName).toBe('P')
   })
 
   describe('legacy variant prop (BC)', () => {

package/src/primitives/__tests__/icon-button.test.tsx

@@ -38,73 +38,3 @@ describe('IconButton solid variants', () => {
     expect(className).not.toContain('dark:bg-input')
   })
 })
-
-describe('IconButton pressed state', () => {
-  // The pressed surface must be restated under `dark:` for the same reason:
-  // `variant="outline"` (`dark:bg-input/30`) and `variant="ghost"`
-  // (`dark:hover:bg-accent/50`) otherwise outrank `aria-pressed:bg-primary`
-  // while `aria-pressed:text-primary-foreground` still applies, leaving a
-  // dark icon on a dark surface (invisible favorite/watch toggles).
-  it.each(['outline', 'ghost'] as const)('keeps the primary fill on a pressed %s button in dark mode', (variant) => {
-    const classes = iconButtonVariants({ variant })
-    expect(classes).toContain('not-disabled:aria-pressed:bg-primary')
-    expect(classes).toContain('dark:not-disabled:aria-pressed:bg-primary')
-    expect(classes).toContain('dark:not-disabled:aria-pressed:hover:bg-primary-hover')
-  })
-
-  // A toggle can be pressed and disabled at once — an active editor tool on a
-  // read-only document. The pressed rules are more specific than the
-  // `disabled:` surface, so without a not-disabled gate the disabled control
-  // renders as a primary, actionable button in both themes.
-  it.each(['outline', 'ghost'] as const)(
-    'never lets the pressed surface outrank the disabled surface on a %s button',
-    (variant) => {
-      const classes = iconButtonVariants({ variant })
-      expect(classes).toContain('disabled:bg-bg-disabled')
-      expect(classes).toContain('disabled:text-text-disabled')
-      for (const pressed of classes.split(' ').filter((cls) => cls.includes('aria-pressed:'))) {
-        expect(pressed).toContain('not-disabled:aria-pressed:')
-      }
-    },
-  )
-
-  it('renders a pressed disabled toggle with only not-disabled-gated pressed rules', () => {
-    const { getByRole } = render(
-      <IconButton variant="outline" aria-label="Highlight" aria-pressed disabled>
-        <svg />
-      </IconButton>,
-    )
-    const classes = getByRole('button').className.split(' ')
-    expect(classes).toContain('disabled:bg-bg-disabled')
-    expect(classes).not.toContain('aria-pressed:bg-primary')
-    expect(classes).not.toContain('dark:aria-pressed:bg-primary')
-    expect(classes).toContain('not-disabled:aria-pressed:bg-primary')
-  })
-
-  // `enabled:` compiles to `&:enabled`, which the CSS spec restricts to form
-  // elements. `IconButton` supports `asChild` and is rendered onto links across
-  // the app (MessagesIcon, RoleAssignmentRow, DealsSection), so an `enabled:`
-  // gate would silently drop the pressed state on every one of those hosts.
-  // `not-disabled:` (`&:not(:disabled)`) matches a non-form host just fine.
-  it('keeps the pressed surface on an asChild anchor host', () => {
-    const { getByRole } = render(
-      <IconButton variant="ghost" asChild aria-pressed>
-        <a href="/inbox" aria-label="Messages">
-          <svg />
-        </a>
-      </IconButton>,
-    )
-    const anchor = getByRole('link')
-    const classes = anchor.className.split(' ')
-    expect(anchor.tagName).toBe('A')
-    expect(classes).toContain('not-disabled:aria-pressed:bg-primary')
-    expect(classes).toContain('not-disabled:aria-pressed:text-primary-foreground')
-    expect(classes).toContain('dark:not-disabled:aria-pressed:bg-primary')
-    // The whole point of the fix: no pressed rule may be gated on `:enabled`,
-    // which can never match an anchor.
-    for (const pressed of classes.filter((cls) => cls.includes('aria-pressed:'))) {
-      expect(pressed).not.toContain('enabled:aria-pressed:')
-      expect(pressed).toContain('not-disabled:aria-pressed:')
-    }
-  })
-})

package/src/primitives/__tests__/notification.test.tsx

@@ -26,7 +26,7 @@ describe('Notification primitive', () => {
   it('renders title as AlertTitle and description below', () => {
     render(<Notification title="John commented" description="On the latest deal" />)
     expect(screen.getByText('John commented').tagName).toBe('H5')
-    expect(screen.getByText('On the latest deal').tagName).toBe('DIV')
+    expect(screen.getByText('On the latest deal').tagName).toBe('P')
   })
 
   it('description gets opacity-70 (DS opacity scale; was opacity-72 in early v5, snapped to scale per .ai/ds-rules.md)', () => {

package/src/primitives/__tests__/pagination.test.tsx

@@ -297,57 +297,3 @@ describe('Pagination', () => {
     expect(ref.current?.getAttribute('data-slot')).toBe('pagination')
   })
 })
-
-describe('Pagination with a capped total (totalIsCapped)', () => {
-  // 100 rows / pageSize 10 → a floor of 10 pages; the real set is larger.
-  const capped = { page: 1, pageSize: 10, total: 100, totalIsCapped: true, onPageChange: () => {} }
-
-  it('renders the capped page info with a trailing plus', () => {
-    const { container } = render(<Pagination {...capped} />)
-    const info = container.querySelector('[data-slot="pagination-info"]')
-    expect(info?.textContent).toBe('Page 1 of 10+')
-  })
-
-  it('suppresses the last-page jump — it would present the floor as the end of the data', () => {
-    const { container } = render(<Pagination {...capped} />)
-    expect(container.querySelector('[data-slot="pagination-last"]')).toBeNull()
-    expect(container.querySelector('[data-slot="pagination-first"]')).not.toBeNull()
-  })
-
-  it('keeps Next enabled past the floor while hasNextPage is true', () => {
-    const onPageChange = jest.fn()
-    const { container } = render(
-      <Pagination {...capped} page={10} hasNextPage onPageChange={onPageChange} />,
-    )
-    const next = container.querySelector('[data-slot="pagination-next"]') as HTMLButtonElement
-    expect(next.disabled).toBe(false)
-    fireEvent.click(next)
-    expect(onPageChange).toHaveBeenCalledWith(11)
-  })
-
-  it('disables Next at the floor when hasNextPage reports a short page', () => {
-    const { container } = render(<Pagination {...capped} page={10} hasNextPage={false} />)
-    const next = container.querySelector('[data-slot="pagination-next"]') as HTMLButtonElement
-    expect(next.disabled).toBe(true)
-  })
-
-  it('never clamps a deep-linked page down to the floor', () => {
-    const { container } = render(<Pagination {...capped} page={37} hasNextPage />)
-    const current = container.querySelector('[data-slot="pagination-page"][data-state="on"]')
-    expect(current?.textContent).toBe('37')
-    const info = container.querySelector('[data-slot="pagination-info"]')
-    expect(info?.textContent).toBe('Page 37 of 37+')
-  })
-
-  it('keeps exact-total behavior byte-identical when the flag is absent', () => {
-    const onPageChange = jest.fn()
-    const { container } = render(
-      <Pagination page={10} pageSize={10} total={100} onPageChange={onPageChange} />,
-    )
-    const next = container.querySelector('[data-slot="pagination-next"]') as HTMLButtonElement
-    expect(next.disabled).toBe(true)
-    expect(container.querySelector('[data-slot="pagination-last"]')).not.toBeNull()
-    const info = container.querySelector('[data-slot="pagination-info"]')
-    expect(info?.textContent).toBe('Page 10 of 10')
-  })
-})