@freighttech/ui 0.13.18

package/src/backend/dynamic-table/__tests__/perspectivePersonalization.test.ts

@@ -0,0 +1,188 @@
+import {
+  apiToDynamicTable,
+  apiTemplateToDynamicTable,
+  dynamicTableToApi,
+  parsePerspectiveOrigin,
+  parsePerspectivePublication,
+  templateVersionOf,
+} from '../utils/perspectiveTransforms'
+import { BASE_VIEW_PERSPECTIVE_NAME } from '../types/perspective'
+import type { PerspectiveDto, RolePerspectiveDto } from '@open-mercato/shared/modules/perspectives/types'
+
+/**
+ * PERSONAL VIEWS + SHARED TEMPLATES — the wire contract.
+ *
+ * The binding model (3 Aug 2026): every view is private by default; a user may
+ * publish one as a shared TEMPLATE that others COPY; each copy records the
+ * template and version it came from so later drift can be surfaced rather than
+ * discovered.
+ *
+ * Everything below travels inside `settings.filters`, not beside it. That is
+ * not a stylistic choice: the upstream zod schema for perspective settings
+ * strips unknown TOP-LEVEL keys, so an `origin` field next to `columnOrder`
+ * would be silently dropped on the way to the database. These tests exist to
+ * make that constraint fail loudly if anyone "tidies" the transform.
+ */
+
+const dto = (over: Partial<PerspectiveDto> = {}): PerspectiveDto => ({
+  id: 'p-1',
+  name: 'Open transports',
+  tableId: 'folders-transport',
+  settings: { columnOrder: ['ref', 'client'], columnVisibility: { ref: true, client: true } },
+  isDefault: false,
+  createdAt: '2026-08-01T10:00:00.000Z',
+  updatedAt: null,
+  ...over,
+})
+
+const allColumns = ['ref', 'client', 'carrier']
+
+describe('personalization metadata survives a save → load round trip', () => {
+  it('carries origin, publication and the base-view flag through the filters channel', () => {
+    const settings = dynamicTableToApi({
+      id: 'p-1',
+      name: 'Copied view',
+      columns: { visible: ['ref'], hidden: ['client'] },
+      filters: [],
+      sorting: [],
+      origin: {
+        templateId: 'tmpl-9',
+        version: '2026-08-02T09:00:00.000Z',
+        name: 'Ops standard',
+        copiedAt: '2026-08-03T08:00:00.000Z',
+      },
+      publication: { roleIds: ['role-a'], publishedAt: '2026-08-03T09:00:00.000Z' },
+      isBaseView: false,
+    })
+
+    const filters = settings.filters as Record<string, unknown>
+    // The load-bearing assertion: these keys are INSIDE `filters`.
+    expect(filters._origin).toEqual({
+      templateId: 'tmpl-9',
+      version: '2026-08-02T09:00:00.000Z',
+      name: 'Ops standard',
+      copiedAt: '2026-08-03T08:00:00.000Z',
+    })
+    expect(filters._published).toEqual({
+      roleIds: ['role-a'],
+      publishedAt: '2026-08-03T09:00:00.000Z',
+    })
+    expect((settings as Record<string, unknown>).origin).toBeUndefined()
+
+    const round = apiToDynamicTable(dto({ settings }), allColumns)
+    expect(round.origin?.templateId).toBe('tmpl-9')
+    expect(round.origin?.version).toBe('2026-08-02T09:00:00.000Z')
+    expect(round.publication?.roleIds).toEqual(['role-a'])
+  })
+
+  it('does not grow empty metadata keys on a plain personal view', () => {
+    const settings = dynamicTableToApi({
+      id: 'p-1',
+      name: 'Plain',
+      columns: { visible: ['ref'], hidden: [] },
+      filters: [],
+      sorting: [],
+    })
+    const filters = settings.filters as Record<string, unknown>
+    expect('_origin' in filters).toBe(false)
+    expect('_published' in filters).toBe(false)
+    expect('_baseView' in filters).toBe(false)
+  })
+})
+
+describe('the base-view row', () => {
+  it('is recognised only when BOTH the flag and the reserved name agree', () => {
+    const settings = dynamicTableToApi({
+      id: 'p-base',
+      name: BASE_VIEW_PERSPECTIVE_NAME,
+      columns: { visible: ['ref'], hidden: ['client'] },
+      filters: [],
+      sorting: [],
+      isBaseView: true,
+    })
+    expect(apiToDynamicTable(dto({ name: BASE_VIEW_PERSPECTIVE_NAME, settings }), allColumns).isBaseView).toBe(true)
+
+    // A hand-edited settings blob must not be able to make an ordinary named
+    // view vanish from the tab strip.
+    expect(apiToDynamicTable(dto({ name: 'My view', settings }), allColumns).isBaseView).toBe(false)
+  })
+
+  it('keeps a normal view unflagged', () => {
+    expect(apiToDynamicTable(dto(), allColumns).isBaseView).toBe(false)
+  })
+})
+
+describe('defensive parsing', () => {
+  it('drops an origin with no usable version rather than half-trusting it', () => {
+    expect(parsePerspectiveOrigin({ templateId: 't-1' })).toBeUndefined()
+    expect(parsePerspectiveOrigin({ version: 'v' })).toBeUndefined()
+    expect(parsePerspectiveOrigin(null)).toBeUndefined()
+    expect(parsePerspectiveOrigin('nonsense')).toBeUndefined()
+    expect(parsePerspectiveOrigin({ templateId: 't-1', version: 'v1' })).toEqual({
+      templateId: 't-1',
+      version: 'v1',
+      name: '',
+      copiedAt: '',
+    })
+  })
+
+  it('drops a publication with no roles — an audience of nobody is not a publication', () => {
+    expect(parsePerspectivePublication({ roleIds: [] })).toBeUndefined()
+    expect(parsePerspectivePublication({ roleIds: [1, 2] })).toBeUndefined()
+    expect(parsePerspectivePublication({ roleIds: ['r-1', ''] })).toEqual({
+      roleIds: ['r-1'],
+      publishedAt: '',
+    })
+  })
+})
+
+describe('shared templates', () => {
+  const roleDto = (over: Partial<RolePerspectiveDto> = {}): RolePerspectiveDto => ({
+    ...dto(),
+    id: 'tmpl-1',
+    name: 'Ops standard',
+    roleId: 'role-a',
+    roleName: 'Operations',
+    tenantId: 'ten-1',
+    organizationId: 'org-1',
+    isDefault: true,
+    createdAt: '2026-08-01T10:00:00.000Z',
+    updatedAt: '2026-08-02T11:00:00.000Z',
+    ...over,
+  })
+
+  it('versions a template by updatedAt, falling back to createdAt', () => {
+    expect(templateVersionOf(roleDto())).toBe('2026-08-02T11:00:00.000Z')
+    expect(templateVersionOf(roleDto({ updatedAt: null }))).toBe('2026-08-01T10:00:00.000Z')
+  })
+
+  it('never carries someone else\'s default or base flag into the reader\'s space', () => {
+    const template = apiTemplateToDynamicTable(roleDto(), allColumns)
+    // `isDefault: true` on the ROLE row means "the role default"; copying it
+    // must not hijack which view opens for the person taking the copy.
+    expect(template.isDefault).toBe(false)
+    expect(template.isBaseView).toBe(false)
+    expect(template.publication).toBeUndefined()
+    expect(template.roleId).toBe('role-a')
+    expect(template.roleName).toBe('Operations')
+    expect(template.version).toBe('2026-08-02T11:00:00.000Z')
+  })
+
+  it('decodes a template exactly like the view it was made from', () => {
+    const settings = dynamicTableToApi({
+      id: 'p-1',
+      name: 'Ops standard',
+      color: 'green',
+      columns: { visible: ['ref', 'carrier'], hidden: ['client'] },
+      filters: [{ id: 'f1', field: 'client', operator: 'contains', value: 'ACME' } as never],
+      sorting: [{ id: 's1', field: 'ref', direction: 'desc' }],
+    })
+    const personal = apiToDynamicTable(dto({ settings }), allColumns)
+    const template = apiTemplateToDynamicTable(roleDto({ settings }), allColumns)
+
+    expect(template.columns).toEqual(personal.columns)
+    expect(template.filters).toEqual(personal.filters)
+    expect(template.sorting).toEqual(personal.sorting)
+    expect(template.color).toEqual(personal.color)
+  })
+})

package/src/backend/dynamic-table/__tests__/perspectiveResolver.test.ts

@@ -0,0 +1,133 @@
+import { resolvePerspectiveState } from '../handlers/perspectiveHandlers'
+import type { ColumnDef } from '../types/index'
+import type { PerspectiveConfig } from '../types/perspective'
+
+/**
+ * Spec 0 / Phase 3 — `resolvePerspectiveState` is the SINGLE place a saved view
+ * becomes table state.
+ *
+ * Before the collapse there were two: one effect that ran
+ * `initializePerspectiveState` (which honours `defaultHiddenColumns`) and a second
+ * "sync controlled props" effect that copied `perspective.columns.*` straight onto
+ * state (which does not). Both ran on the same commit against the same props, so
+ * whether the host's hidden columns survived a view switch depended on effect
+ * ordering. These tests pin the one resolver both paths now share.
+ */
+
+const cols = (...keys: string[]): ColumnDef[] => keys.map((data) => ({ data }))
+
+const perspective = (over: Partial<PerspectiveConfig> = {}): PerspectiveConfig => ({
+  id: 'p1',
+  name: 'My view',
+  columns: { visible: ['a', 'b'], hidden: ['c'] },
+  filters: [],
+  sorting: [],
+  ...over,
+})
+
+describe('resolvePerspectiveState — default view (no perspective)', () => {
+  it('shows every column when the host hides none', () => {
+    const state = resolvePerspectiveState({ baseColumns: cols('a', 'b', 'c') })
+
+    expect(state.visibleColumns).toEqual(['a', 'b', 'c'])
+    expect(state.hiddenColumns).toEqual([])
+  })
+
+  it('honours defaultHiddenColumns', () => {
+    const state = resolvePerspectiveState({
+      baseColumns: cols('a', 'b', 'c'),
+      defaultHiddenColumns: ['b'],
+    })
+
+    expect(state.visibleColumns).toEqual(['a', 'c'])
+    expect(state.hiddenColumns).toEqual(['b'])
+  })
+
+  it('ignores a defaultHiddenColumns key the table does not declare', () => {
+    const state = resolvePerspectiveState({
+      baseColumns: cols('a', 'b'),
+      defaultHiddenColumns: ['b', 'ghost'],
+    })
+
+    expect(state.hiddenColumns).toEqual(['b'])
+  })
+
+  it('treats an explicit null perspective the same as omitting it', () => {
+    const withNull = resolvePerspectiveState({
+      baseColumns: cols('a', 'b'),
+      perspective: null,
+      defaultHiddenColumns: ['b'],
+    })
+    const omitted = resolvePerspectiveState({
+      baseColumns: cols('a', 'b'),
+      defaultHiddenColumns: ['b'],
+    })
+
+    expect(withNull).toEqual(omitted)
+  })
+
+  it('resets every rule list, so clearing a view really clears it', () => {
+    const state = resolvePerspectiveState({ baseColumns: cols('a') })
+
+    expect(state.filters).toEqual([])
+    expect(state.sortRules).toEqual([])
+    expect(state.groupRules).toEqual([])
+    expect(state.aggregations).toEqual([])
+    expect(state.lookupColumns).toEqual([])
+    expect(state.dateFormat).toBeUndefined()
+  })
+})
+
+describe('resolvePerspectiveState — a saved view', () => {
+  it('takes the view’s columns, filters and sorting verbatim', () => {
+    const state = resolvePerspectiveState({
+      baseColumns: cols('a', 'b', 'c'),
+      perspective: perspective({
+        filters: [{ id: 'f1', field: 'a', operator: 'contains', values: ['x'] }],
+        sorting: [{ id: 's1', field: 'b', direction: 'desc' }],
+      }),
+      defaultHiddenColumns: ['a'],
+    })
+
+    // The saved view wins over the host default: `a` stays visible.
+    expect(state.visibleColumns).toEqual(['a', 'b'])
+    expect(state.hiddenColumns).toEqual(['c'])
+    expect(state.filters).toHaveLength(1)
+    expect(state.sortRules).toEqual([{ id: 's1', field: 'b', direction: 'desc' }])
+  })
+
+  it('defaults the optional rule lists a legacy view omits', () => {
+    const legacy = {
+      id: 'p1',
+      name: 'Legacy',
+      columns: { visible: ['a'], hidden: [] },
+      filters: [],
+      sorting: [],
+    } as PerspectiveConfig
+
+    const state = resolvePerspectiveState({ baseColumns: cols('a'), perspective: legacy })
+
+    expect(state.groupRules).toEqual([])
+    expect(state.aggregations).toEqual([])
+    expect(state.lookupColumns).toEqual([])
+  })
+
+  it('carries the view-scoped date format through', () => {
+    const state = resolvePerspectiveState({
+      baseColumns: cols('a'),
+      perspective: perspective({ dateFormat: 'dd.MM.yyyy' }),
+    })
+
+    expect(state.dateFormat).toBe('dd.MM.yyyy')
+  })
+
+  it('is a pure function of its input — same input, equal output', () => {
+    const input = {
+      baseColumns: cols('a', 'b'),
+      perspective: perspective(),
+      defaultHiddenColumns: ['b'],
+    }
+
+    expect(resolvePerspectiveState(input)).toEqual(resolvePerspectiveState(input))
+  })
+})

package/src/backend/dynamic-table/__tests__/perspectiveState.defaultGrouping.test.ts

@@ -0,0 +1,306 @@
+/**
+ * `defaultGrouping` — a host's opening grouping when no saved view is active.
+ *
+ * It exists because a table that should OPEN grouped (the documents list opens
+ * grouped by case) previously had no way to say so: grouping arrived only from a
+ * saved perspective, so a host could get there only by writing a view into the
+ * database on the user's behalf.
+ *
+ * Two properties carry the whole feature and both are asserted here:
+ *
+ *  1. A saved perspective REPLACES it, never merges with it. Merging would make
+ *     "I saved this view deliberately ungrouped" unsayable — the default would
+ *     climb back in on every reload.
+ *  2. A rule naming a column the table does not declare is DROPPED. Applied, it
+ *     would fold every row under `undefined` and present one section called
+ *     "Ungrouped" with nothing on screen explaining why.
+ */
+import { resolvePerspectiveState, createPerspectiveHandlers } from '../handlers/perspectiveHandlers'
+import { apiToDynamicTable } from '../utils/perspectiveTransforms'
+import type { PerspectiveDto, PerspectiveSettings } from '@open-mercato/shared/modules/perspectives/types'
+import type { ColumnDef } from '../types/index'
+import type { GroupRule } from '../types/grouping'
+import type { PerspectiveConfig } from '../types/perspective'
+
+function cols(...keys: string[]): ColumnDef[] {
+  return keys.map((k) => ({ data: k }) as ColumnDef)
+}
+
+function rule(field: string, direction: 'asc' | 'desc' = 'asc'): GroupRule {
+  return { id: `g-${field}`, field, direction }
+}
+
+function perspective(over: Partial<PerspectiveConfig>): PerspectiveConfig {
+  return {
+    id: 'p1',
+    name: 'Saved',
+    columns: { visible: ['name', 'caseNumber'], hidden: [] },
+    filters: [],
+    sorting: [],
+    ...over,
+  } as PerspectiveConfig
+}
+
+describe('resolvePerspectiveState — defaultGrouping', () => {
+  it('seeds the default view when no perspective is active', () => {
+    const state = resolvePerspectiveState({
+      baseColumns: cols('name', 'caseNumber', 'documentType'),
+      perspective: null,
+      defaultGrouping: [rule('caseNumber')],
+    })
+    expect(state.groupRules).toEqual([rule('caseNumber')])
+  })
+
+  it('defaults to no grouping when the host declares none', () => {
+    const state = resolvePerspectiveState({
+      baseColumns: cols('name', 'caseNumber'),
+      perspective: null,
+    })
+    expect(state.groupRules).toEqual([])
+  })
+
+  it('drops a rule naming a column the table does not declare', () => {
+    const state = resolvePerspectiveState({
+      baseColumns: cols('name', 'documentType'),
+      perspective: null,
+      defaultGrouping: [rule('caseNumber'), rule('documentType')],
+    })
+    expect(state.groupRules).toEqual([rule('documentType')])
+  })
+
+  it('a saved perspective REPLACES the default, it does not merge with it', () => {
+    const state = resolvePerspectiveState({
+      baseColumns: cols('name', 'caseNumber', 'documentType'),
+      perspective: perspective({ grouping: [rule('documentType')] }),
+      defaultGrouping: [rule('caseNumber')],
+    })
+    expect(state.groupRules).toEqual([rule('documentType')])
+  })
+
+  /**
+   * The one that matters most. A user who groups by nothing and saves has made a
+   * decision; if the default merged back in, their view would silently regroup
+   * itself every time they opened it and nothing on screen would say why.
+   */
+  it('a perspective saved with NO grouping opens ungrouped, default or not', () => {
+    const state = resolvePerspectiveState({
+      baseColumns: cols('name', 'caseNumber'),
+      perspective: perspective({ grouping: [] }),
+      defaultGrouping: [rule('caseNumber')],
+    })
+    expect(state.groupRules).toEqual([])
+  })
+
+  /**
+   * The base view is a personalization of the DEFAULT view, and it is written on
+   * a user's first visit as a complete column snapshot. Without this, adding a
+   * column to a table's config is invisible for ever to everyone who has already
+   * opened it — measured on the documents list, where a `caseNumber` column
+   * produced the old ten headers and no group sections.
+   */
+  describe('a base view does not freeze out columns it has never seen', () => {
+    const base = (over: Partial<PerspectiveConfig>): PerspectiveConfig => perspective({
+      name: '__base__',
+      isBaseView: true,
+      ...over,
+    })
+
+    it('adopts a new column at its DECLARED position, not appended at the end', () => {
+      const state = resolvePerspectiveState({
+        baseColumns: cols('name', 'caseNumber', 'documentType', 'actions'),
+        perspective: base({
+          columns: { visible: ['name', 'documentType', 'actions'], hidden: ['caseNumber'] },
+          unseenColumns: ['caseNumber'],
+        }),
+      })
+      expect(state.visibleColumns).toEqual(['name', 'caseNumber', 'documentType', 'actions'])
+    })
+
+    it('respects a column the user HID — no opinion means absent, not hidden', () => {
+      const state = resolvePerspectiveState({
+        baseColumns: cols('name', 'caseNumber', 'documentType'),
+        perspective: base({
+          columns: { visible: ['name'], hidden: ['documentType', 'caseNumber'] },
+          unseenColumns: ['caseNumber'],
+        }),
+      })
+      expect(state.visibleColumns).toEqual(['name', 'caseNumber'])
+      expect(state.hiddenColumns).toEqual(['documentType'])
+    })
+
+    it('adopts the default grouping when it names a column this view never saw', () => {
+      const state = resolvePerspectiveState({
+        baseColumns: cols('name', 'caseNumber'),
+        perspective: base({
+          columns: { visible: ['name'], hidden: ['caseNumber'] },
+          unseenColumns: ['caseNumber'],
+          grouping: [],
+        }),
+        defaultGrouping: [rule('caseNumber')],
+      })
+      expect(state.groupRules).toEqual([rule('caseNumber')])
+    })
+
+    /**
+     * The other half, and the one that keeps this honest. Once the column IS in
+     * the user's set, an empty grouping is a DECISION — they ungrouped it — and
+     * re-imposing the default would undo that on every reload.
+     */
+    it('does NOT re-impose the default once the user has the column and ungrouped it', () => {
+      const state = resolvePerspectiveState({
+        baseColumns: cols('name', 'caseNumber'),
+        perspective: base({
+          columns: { visible: ['name', 'caseNumber'], hidden: [] },
+          unseenColumns: [],
+          grouping: [],
+        }),
+        defaultGrouping: [rule('caseNumber')],
+      })
+      expect(state.groupRules).toEqual([])
+    })
+
+    it('never touches a NAMED view — its columns were chosen', () => {
+      const state = resolvePerspectiveState({
+        baseColumns: cols('name', 'caseNumber', 'documentType'),
+        perspective: perspective({
+          columns: { visible: ['name'], hidden: ['caseNumber', 'documentType'] },
+          unseenColumns: ['caseNumber'],
+          grouping: [],
+        }),
+        defaultGrouping: [rule('caseNumber')],
+      })
+      expect(state.visibleColumns).toEqual(['name'])
+      expect(state.groupRules).toEqual([])
+    })
+  })
+
+  it('leaves the rest of the default state alone', () => {
+    const state = resolvePerspectiveState({
+      baseColumns: cols('name', 'caseNumber', 'documentType'),
+      perspective: null,
+      defaultHiddenColumns: ['documentType'],
+      defaultGrouping: [rule('caseNumber')],
+    })
+    expect(state.visibleColumns).toEqual(['name', 'caseNumber'])
+    expect(state.hiddenColumns).toEqual(['documentType'])
+    expect(state.filters).toEqual([])
+    expect(state.sortRules).toEqual([])
+  })
+})
+
+/**
+ * The half of the mechanism that lives in the transform, tested against the
+ * shape a real stored base view has. Taken from the `__base__` row this feature
+ * was debugged on: `columnOrder` and `columnVisibility` list the ten columns the
+ * documents table had before `caseNumber` was added.
+ */
+describe('apiToDynamicTable — unseenColumns', () => {
+  const storedBaseView = (order: string[]): PerspectiveDto => ({
+    id: 'a15eebda-7c7a-4d98-922c-7d0b17657ec6',
+    name: '__base__',
+    tableId: 'freight_documents',
+    isDefault: false,
+    createdAt: '2026-08-20T00:00:00Z',
+    settings: {
+      filters: { v: 2, rows: [], _baseView: true },
+      sorting: [],
+      grouping: [],
+      columnOrder: order,
+      columnVisibility: Object.fromEntries(order.map((c) => [c, true])),
+    } as unknown as PerspectiveSettings,
+  })
+
+  it('reports a column the stored row has never heard of', () => {
+    const config = apiToDynamicTable(
+      storedBaseView(['name', 'documentType', 'createdAt']),
+      ['name', 'caseNumber', 'documentType', 'createdAt'],
+    )
+    expect(config.unseenColumns).toEqual(['caseNumber'])
+    // …and the derived `hidden` list is exactly why it had to be computed here:
+    // it cannot tell this column from one the user hid.
+    expect(config.columns.hidden).toContain('caseNumber')
+  })
+
+  it('reports nothing when the row has an opinion about every column', () => {
+    const config = apiToDynamicTable(
+      storedBaseView(['name', 'caseNumber']),
+      ['name', 'caseNumber'],
+    )
+    expect(config.unseenColumns).toEqual([])
+  })
+
+  /** A column explicitly turned OFF is an opinion, not an absence. */
+  it('does not report a column the row explicitly hid', () => {
+    const dto = storedBaseView(['name', 'caseNumber'])
+    ;(dto.settings as unknown as { columnVisibility: Record<string, boolean> })
+      .columnVisibility.caseNumber = false
+    const config = apiToDynamicTable(dto, ['name', 'caseNumber'])
+    expect(config.unseenColumns).toEqual([])
+    expect(config.columns.hidden).toContain('caseNumber')
+  })
+
+  /** A legacy row with no column config at all has no opinions to preserve —
+   *  the table's own defaults are already being honoured for it. */
+  it('reports nothing for a legacy row with an empty columnOrder', () => {
+    const config = apiToDynamicTable(storedBaseView([]), ['name', 'caseNumber'])
+    expect(config.unseenColumns).toEqual([])
+  })
+})
+
+/**
+ * Selecting the "Default view" tab.
+ *
+ * This is the path that actually broke the feature in the browser: `defaultGrouping`
+ * arrived on the props correctly, the resolver returned the right rule, and the grid
+ * still drew ONE ungrouped section — because `handlePerspectiveSelect(null)` had its
+ * own hand-rolled idea of the default view and set `groupRules` to `[]` behind it.
+ *
+ * These assert the two properties that second implementation got wrong.
+ */
+describe('createPerspectiveHandlers — selecting the default view', () => {
+  function harness(defaults: { defaultHiddenColumns?: string[]; defaultGrouping?: GroupRule[] }) {
+    const calls: Record<string, unknown> = {}
+    const set = (key: string) => ((v: unknown) => { calls[key] = v }) as never
+    const handlers = createPerspectiveHandlers({
+      tableRef: { current: document.createElement('div') },
+      columns: cols('name', 'caseNumber', 'documentType'),
+      savedPerspectives: [],
+      activePerspectiveId: null,
+      setVisibleColumns: set('visible'),
+      setHiddenColumns: set('hidden'),
+      setFilters: set('filters'),
+      setSortRules: set('sort'),
+      setGroupRules: set('group'),
+      setAggregations: set('agg'),
+      setLookupColumns: set('lookup'),
+      setRollupColumns: set('rollup'),
+      setFormulas: set('formulas'),
+      setConditionalFormats: set('formats'),
+      setFrozenColumns: set('frozen'),
+      setDateFormat: set('dateFormat'),
+      setInternalActivePerspectiveId: set('activeId'),
+      ...defaults,
+    })
+    return { handlers, calls }
+  }
+
+  it('restores the host default GROUPING, not an empty one', () => {
+    const { handlers, calls } = harness({ defaultGrouping: [rule('caseNumber')] })
+    handlers.handlePerspectiveSelect(null)
+    expect(calls.group).toEqual([rule('caseNumber')])
+  })
+
+  it('honours defaultHiddenColumns instead of revealing every column', () => {
+    const { handlers, calls } = harness({ defaultHiddenColumns: ['documentType'] })
+    handlers.handlePerspectiveSelect(null)
+    expect(calls.visible).toEqual(['name', 'caseNumber'])
+    expect(calls.hidden).toEqual(['documentType'])
+  })
+
+  it('still clears filters and sorting — that part was always right', () => {
+    const { handlers, calls } = harness({ defaultGrouping: [rule('caseNumber')] })
+    handlers.handlePerspectiveSelect(null)
+    expect(calls.filters).toEqual([])
+    expect(calls.sort).toEqual([])
+  })
+})