@startsimpli/ui 0.4.141 → 0.4.142

package/src/components/history/RevisionFields.tsx

@@ -26,7 +26,7 @@
  *   reason, rather than showing a deletion that never happened.
  */
 import { useState } from 'react';
-import { ChevronRight, EyeOff, Scissors } from 'lucide-react';
+import { ChevronRight, EyeOff, History, Scissors, Undo2 } from 'lucide-react';
 
 import { cn } from '../../lib/utils';
 import { DiffViewer } from '../diff';
@@ -53,6 +53,9 @@ function preview(value: unknown): string {
 
 const CLAMP = 'max-h-40 overflow-y-auto whitespace-pre-wrap break-words';
 
+const RESTORE_BUTTON =
+  'inline-flex items-center gap-1 rounded border border-border bg-background px-2 py-1 text-xs text-foreground transition-colors hover:bg-accent';
+
 /** One side of a change. ABSENCE IS RENDERED AS ABSENCE — an em dash with
  *  screen-reader text — never as an empty box that looks like "" was stored. */
 function Side({ label, has, value }: { label: string; has: boolean; value: unknown }) {
@@ -156,9 +159,26 @@ export interface RevisionFieldsProps {
   /** Map a wire field name to something a reader recognises. Identity by
    *  default — see `types.ts` on why this module never re-cases a name. */
   fieldLabel?: (field: string) => string;
+  /** Offer "Restore this value" on this field (bd startsim-zkyk4). The panel
+   *  answers false wherever a restore would change nothing — on the row whose
+   *  value IS the current one — or would be refused. */
+  canRestoreField?: (field: string) => boolean;
+  onRestoreField?: (field: string) => void;
+  /** Offer "Restore this version" — the whole record as it stood after this
+   *  sitting. Omitted where it would be a no-op or the trail is partial. */
+  onRestoreVersion?: () => void;
+  /** "Show only this field's history" — the panel's ?field= narrowing. */
+  onNarrowToField?: (field: string) => void;
 }
 
-export function RevisionFields({ sitting, fieldLabel = (f) => f }: RevisionFieldsProps) {
+export function RevisionFields({
+  sitting,
+  fieldLabel = (f) => f,
+  canRestoreField,
+  onRestoreField,
+  onRestoreVersion,
+  onNarrowToField,
+}: RevisionFieldsProps) {
   const [open, setOpen] = useState<string | null>(null);
   const entries: Array<[string, FoldedFieldChange]> = [
     ...Object.keys(sitting.changed)
@@ -216,8 +236,40 @@ export function RevisionFields({ sitting, fieldLabel = (f) => f }: RevisionField
                   <span className="ms-auto shrink-0 text-muted-foreground">{KIND_LABEL[kind]}</span>
                 </button>
                 {isOpen && (
-                  <div className="border-t border-border bg-muted/20 px-3 py-2">
+                  <div className="space-y-2 border-t border-border bg-muted/20 px-3 py-2">
                     <FieldBody field={field} change={change} />
+                    {(onNarrowToField ||
+                      (onRestoreField &&
+                        field !== 'name (title)' &&
+                        kind !== 'withheld' &&
+                        (canRestoreField?.(field) ?? true))) && (
+                      <div className="flex flex-wrap items-center gap-2">
+                        {onRestoreField &&
+                          field !== 'name (title)' &&
+                          kind !== 'withheld' &&
+                          (canRestoreField?.(field) ?? true) && (
+                            <button
+                              type="button"
+                              className={RESTORE_BUTTON}
+                              data-testid={`revision-restore-field-${field}`}
+                              onClick={() => onRestoreField(field)}
+                            >
+                              <Undo2 className="h-3.5 w-3.5" aria-hidden="true" />
+                              Restore this value
+                            </button>
+                          )}
+                        {onNarrowToField && field !== 'name (title)' && (
+                          <button
+                            type="button"
+                            className="inline-flex items-center gap-1 text-xs text-muted-foreground underline-offset-2 hover:underline"
+                            onClick={() => onNarrowToField(field)}
+                          >
+                            <History className="h-3.5 w-3.5" aria-hidden="true" />
+                            Only this field&apos;s history
+                          </button>
+                        )}
+                      </div>
+                    )}
                   </div>
                 )}
               </li>
@@ -225,6 +277,20 @@ export function RevisionFields({ sitting, fieldLabel = (f) => f }: RevisionField
           })}
         </ul>
       )}
+
+      {onRestoreVersion && (
+        <div>
+          <button
+            type="button"
+            className={RESTORE_BUTTON}
+            data-testid="revision-restore-version"
+            onClick={onRestoreVersion}
+          >
+            <Undo2 className="h-3.5 w-3.5" aria-hidden="true" />
+            Restore this version
+          </button>
+        </div>
+      )}
     </div>
   );
 }

package/src/components/history/StaleSaveDialog.tsx

@@ -77,6 +77,21 @@ export interface StaleSaveDialogProps {
   fieldLabel?: (field: string) => string;
   /** Extra content, below the fields and above the footer. */
   children?: ReactNode;
+  /**
+   * COPY FOR A CONFLICT THAT IS NOT AN EDITOR'S (bd startsim-zkyk4). The defaults
+   * are the draft editor's words — "your edits are still here" — which are true
+   * there and false for a refused RESTORE, where nothing was typed. A host that
+   * reuses this dialog for another kind of write says what that write was; the
+   * structure, the safe default focus and the one path that adopts the server's
+   * version are unchanged.
+   */
+  reassurance?: ReactNode;
+  /** "while you were editing" — the clause after "<actor> changed <record>". */
+  whilePhrase?: string;
+  dismissLabel?: string;
+  reviewLabel?: string;
+  keepMineLabel?: string;
+  acceptTheirsLabel?: string;
   classNames?: StaleSaveDialogClassNames;
 }
 
@@ -119,6 +134,12 @@ export function StaleSaveDialog({
   fieldLabel = (field) => field,
   children,
   classNames,
+  reassurance = 'Your edits are still here and have not been saved.',
+  whilePhrase = 'while you were editing',
+  dismissLabel = 'Keep editing',
+  reviewLabel = 'See what changed',
+  keepMineLabel = 'Save mine, replacing their change',
+  acceptTheirsLabel = 'Discard my edits and load theirs',
 }: StaleSaveDialogProps) {
   const css = { ...STALE_SAVE_DIALOG_DEFAULTS, ...classNames };
   const focusTarget = useRef<HTMLButtonElement | null>(null);
@@ -175,18 +196,18 @@ export function StaleSaveDialog({
                   {...(actor?.actorKind ? { kind: actor.actorKind } : {})}
                   {...(actor?.actorKindSource ? { kindSource: actor.actorKindSource } : {})}
                 />
-                <span>changed {recordLabel} while you were editing.</span>
+                <span>changed {recordLabel} {whilePhrase}.</span>
               </>
             ) : (
               /* NEVER "someone", and never a guess at a machine. The record
                  changed; who is a separate question this dialog answers only
                  when the trail actually said. */
-              <span>{`${recordLabel.charAt(0).toUpperCase()}${recordLabel.slice(1)} changed while you were editing.`}</span>
+              <span>{`${recordLabel.charAt(0).toUpperCase()}${recordLabel.slice(1)} changed ${whilePhrase}.`}</span>
             )}
           </h2>
           {/* THE LOAD-BEARING SENTENCE, and it comes first for that reason. */}
           <p className={css.reassurance} data-testid="stale-save-reassurance">
-            Your edits are still here and have not been saved.
+            {reassurance}
           </p>
         </div>
 
@@ -234,7 +255,7 @@ export function StaleSaveDialog({
               disabled={busy}
               onClick={onAcceptTheirs}
             >
-              Discard my edits and load theirs
+              {acceptTheirsLabel}
             </button>
           )}
           <button
@@ -246,7 +267,7 @@ export function StaleSaveDialog({
             data-testid="stale-save-dismiss"
             onClick={onDismiss}
           >
-            Keep editing
+            {dismissLabel}
           </button>
           {onReviewChange && (
             <button
@@ -256,7 +277,7 @@ export function StaleSaveDialog({
               data-testid="stale-save-review"
               onClick={onReviewChange}
             >
-              See what changed
+              {reviewLabel}
             </button>
           )}
           {onKeepMine && (
@@ -267,7 +288,7 @@ export function StaleSaveDialog({
               disabled={busy}
               onClick={onKeepMine}
             >
-              {busy ? 'Saving…' : 'Save mine, replacing their change'}
+              {busy ? 'Saving…' : keepMineLabel}
             </button>
           )}
         </div>

package/src/components/history/__tests__/field-attribution.test.tsx

@@ -0,0 +1,213 @@
+/**
+ * RED for bd startsim-vjhbw — "edited by X · 2h ago" beside a field, over
+ * `GET /entities/<id>/field-authors/` (server bd startsim-6sso4).
+ *
+ * The three readings that must never be confused:
+ * - an ENTRY: somebody (or something) last wrote this field — say who, mark a
+ *   machine, and open that field's history on click;
+ * - NO ENTRY: not edited SINCE THE TRAIL BEGAN. Live rows predate the trail, so
+ *   this is never "never edited";
+ * - HISTORY OFF (`recorded: false`, `fields: null`): we do not know, and we say
+ *   that — NOT "nobody edited".
+ */
+import { render, screen, fireEvent, waitFor } from '@testing-library/react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+
+import {
+  FieldAttribution,
+  FieldAuthorsNotice,
+  fieldAuthorOf,
+  normalizeFieldAuthors,
+  useFieldAuthors,
+} from '../index'
+import type { FieldAuthorsResponse } from '../types'
+
+const NOW = Date.parse('2026-10-07T12:00:00.000Z')
+
+const recorded: FieldAuthorsResponse = {
+  entity_id: 'e1',
+  version: 7,
+  history: { enabled: true, declared_by: 'default' },
+  recorded: true,
+  trail_starts: { version: 3, at: '2026-10-01T09:00:00.000Z', from_creation: false },
+  fields: {
+    blog: {
+      version: 7,
+      at: new Date(NOW - 2 * 3_600_000).toISOString(),
+      actor_sub: 'u-jurga',
+      actor_label: 'jurga@ogmc.example',
+      actor_kind: 'person',
+      actor_kind_source: 'claim',
+      source: 'patch',
+    },
+    team_verdict: {
+      version: 6,
+      at: new Date(NOW - 3_600_000).toISOString(),
+      actor_sub: 'svc:n8n-ogmc',
+      actor_label: 'svc:n8n-ogmc',
+      actor_kind: 'machine',
+      actor_kind_source: 'claim',
+      source: 'upsert',
+    },
+    title: {
+      version: 5,
+      at: new Date(NOW - 60_000).toISOString(),
+      actor_sub: 'u-alex',
+      actor_label: 'alex@ogmc.example',
+      actor_kind: 'person',
+      actor_kind_source: 'claim',
+      source: 'restore',
+      restored_from: 2,
+    },
+  },
+  name: null,
+}
+
+const off: FieldAuthorsResponse = {
+  entity_id: 'e1',
+  version: 4,
+  history: { enabled: false, declared_by: 'type' },
+  recorded: false,
+  trail_starts: null,
+  fields: null,
+  name: null,
+  detail: 'History is switched off for records of this type, so field authors are not recorded.',
+}
+
+beforeAll(() => {
+  jest.useFakeTimers({ now: NOW, doNotFake: ['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval', 'queueMicrotask', 'nextTick', 'setImmediate', 'clearImmediate'] })
+})
+afterAll(() => jest.useRealTimers())
+
+describe('normalizeFieldAuthors — either spelling, failing closed on kind', () => {
+  it('reads snake and camel alike', () => {
+    const camel = {
+      entityId: 'e1',
+      version: 2,
+      recorded: true,
+      trailStarts: { version: 1, at: '2026-10-01T00:00:00Z', fromCreation: true },
+      fields: { blog: { version: 2, at: '2026-10-02T00:00:00Z', actorSub: 'u', actorLabel: 'a@b.c', actorKind: 'person', actorKindSource: 'claim', source: 'patch' } },
+    }
+    const n = normalizeFieldAuthors(camel as never)
+    expect(n.recorded).toBe(true)
+    expect(n.trailStarts).toMatchObject({ version: 1, fromCreation: true })
+    expect(fieldAuthorOf(n, 'blog')).toMatchObject({ actorLabel: 'a@b.c', actorKind: 'person' })
+  })
+
+  it('an unrecognised kind reads unknown — never person', () => {
+    const n = normalizeFieldAuthors({
+      ...recorded,
+      fields: { blog: { ...recorded.fields!.blog!, actor_kind: 'robot' as never } },
+    })
+    expect(fieldAuthorOf(n, 'blog')?.actorKind).toBe('unknown')
+  })
+
+  it('history off is NOT the same as an empty field map', () => {
+    const n = normalizeFieldAuthors(off)
+    expect(n.recorded).toBe(false)
+    expect(fieldAuthorOf(n, 'blog')).toBeUndefined()
+  })
+})
+
+describe('FieldAttribution — an entry', () => {
+  it('names the person and how long ago', () => {
+    render(<FieldAttribution authors={recorded} field="blog" />)
+    const el = screen.getByTestId('field-attribution-blog')
+    expect(el).toHaveTextContent(/jurga@ogmc\.example/)
+    expect(el).toHaveTextContent(/2 hours ago/)
+    expect(screen.queryByTestId('actor-kind')).not.toBeInTheDocument()
+  })
+
+  it('ALWAYS marks a machine, through ActorIdentity', () => {
+    render(<FieldAttribution authors={recorded} field="team_verdict" />)
+    expect(screen.getByTestId('actor-kind')).toHaveTextContent(/machine/)
+    // ActorIdentity's accessible title, not a second vocabulary.
+    expect(screen.getByTestId('actor-identity')).toHaveAttribute('title', expect.stringMatching(/machine made this change/i))
+  })
+
+  it('says a restore was a restore, and from which version', () => {
+    render(<FieldAttribution authors={recorded} field="title" />)
+    expect(screen.getByTestId('field-attribution-title')).toHaveTextContent(/restored.*v2/i)
+  })
+
+  it('clicking opens that field’s history', () => {
+    const onOpenHistory = jest.fn()
+    render(<FieldAttribution authors={recorded} field="blog" onOpenHistory={onOpenHistory} />)
+    fireEvent.click(screen.getByRole('button', { name: /history of blog/i }))
+    expect(onOpenHistory).toHaveBeenCalledWith('blog')
+  })
+
+  it('is plain text, not a button, when the host offers no history', () => {
+    render(<FieldAttribution authors={recorded} field="blog" />)
+    expect(screen.queryByRole('button')).not.toBeInTheDocument()
+  })
+
+  it('links to the actor’s recent edits when the host gives a URL for them', () => {
+    render(<FieldAttribution authors={recorded} field="blog" actorHref={(sub) => `/activity?actor=${sub}`} />)
+    expect(screen.getByRole('link', { name: /their recent edits/i })).toHaveAttribute('href', '/activity?actor=u-jurga')
+  })
+})
+
+describe('FieldAttribution — no entry', () => {
+  it('says "not edited since history began", with the date — never "never edited"', () => {
+    render(<FieldAttribution authors={recorded} field="angle" />)
+    const el = screen.getByTestId('field-attribution-angle')
+    expect(el).toHaveTextContent(/not edited since/i)
+    expect(el.textContent).not.toMatch(/never/i)
+  })
+
+  it('says "since it was created" when the trail began at creation', () => {
+    render(
+      <FieldAttribution
+        authors={{ ...recorded, trail_starts: { version: 1, at: '2026-10-01T09:00:00Z', from_creation: true } }}
+        field="angle"
+      />,
+    )
+    expect(screen.getByTestId('field-attribution-angle')).toHaveTextContent(/not edited since it was created/i)
+  })
+})
+
+describe('FieldAttribution — history off', () => {
+  it('says it is not recorded, and does not claim nobody edited it', () => {
+    render(<FieldAttribution authors={off} field="blog" />)
+    const el = screen.getByTestId('field-attribution-blog')
+    expect(el).toHaveTextContent(/not recorded/i)
+    expect(el.textContent).not.toMatch(/not edited|nobody|never/i)
+  })
+
+  it('FieldAuthorsNotice repeats the server sentence once', () => {
+    render(<FieldAuthorsNotice authors={off} />)
+    expect(screen.getByTestId('field-authors-notice')).toHaveTextContent(/switched off/)
+  })
+
+  it('FieldAuthorsNotice says nothing when history is recorded', () => {
+    const { container } = render(<FieldAuthorsNotice authors={recorded} />)
+    expect(container).toBeEmptyDOMElement()
+  })
+})
+
+describe('FieldAttribution — loading', () => {
+  it('renders nothing until the authors arrive', () => {
+    const { container } = render(<FieldAttribution authors={undefined} field="blog" />)
+    expect(container).toBeEmptyDOMElement()
+  })
+})
+
+describe('useFieldAuthors — injected client, cached per key', () => {
+  function Probe({ get }: { get: () => Promise<FieldAuthorsResponse> }) {
+    const q = useFieldAuthors({ client: { get }, queryKey: ['entity', 'e1', 'field-authors', 7] })
+    return <FieldAttribution authors={q.data} field="blog" />
+  }
+
+  it('fetches once and renders through FieldAttribution', async () => {
+    const get = jest.fn().mockResolvedValue(recorded)
+    const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+    render(
+      <QueryClientProvider client={qc}>
+        <Probe get={get} />
+      </QueryClientProvider>,
+    )
+    await waitFor(() => expect(screen.getByTestId('field-attribution-blog')).toHaveTextContent(/jurga/))
+    expect(get).toHaveBeenCalledTimes(1)
+  })
+})

package/src/components/history/__tests__/record-activity-panel.test.tsx

@@ -0,0 +1,179 @@
+/**
+ * RED for bd startsim-ucg5u — everything one person (or one agent) changed,
+ * across records, over `GET /api/v1/revisions/` (server bd startsim-ivr3n),
+ * composed on the shared ActivityFeedPanel rather than a second feed.
+ *
+ * Contract traps this pins:
+ * - cursor paging, no count, never `?page=`;
+ * - a blank actor/scope is a 400, so empty filters are OMITTED, not sent blank;
+ * - filters are the host's (the URL), the panel only reports changes;
+ * - the person filter's value is the actor's SUB, the label is their address;
+ * - adjacent saves fold only within ONE record — two records never merge.
+ */
+import { render, screen, fireEvent, waitFor, within } from '@testing-library/react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+
+import { RecordActivityPanel, foldFeed, revisionFeedParams } from '../index'
+import type { RevisionFeedRow } from '../types'
+
+function mount(ui: React.ReactElement) {
+  const qc = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: 0 } } })
+  return render(<QueryClientProvider client={qc}>{ui}</QueryClientProvider>)
+}
+
+const T0 = Date.parse('2026-10-07T12:00:00.000Z')
+const at = (ms: number) => new Date(T0 + ms).toISOString()
+
+function row(id: string, entity: { id: string; type: string; name: string }, over: Partial<RevisionFeedRow> = {}): RevisionFeedRow {
+  return {
+    id,
+    version: 2,
+    action: 'updated',
+    source: 'patch',
+    created_at: at(0),
+    actor_sub: 'u-jurga',
+    actor_label: 'jurga@ogmc.example',
+    actor_kind: 'person',
+    actor_kind_source: 'claim',
+    metadata: { changed: { blog: { before: 'old', after: 'new' } } },
+    entity,
+    ...over,
+  }
+}
+
+const draftA = { id: 'd-a', type: 'draft', name: 'Gulf logistics brief' }
+const draftB = { id: 'd-b', type: 'draft', name: 'Riyadh expansion' }
+
+describe('revisionFeedParams — only what the route accepts, never blank', () => {
+  it('omits blank values and maps nothing it does not know', () => {
+    expect(
+      revisionFeedParams({ actor: '', actor_kind: 'machine', type: 'draft', scope: ' ', since: '2026-10-05T00:00:00.000Z' }),
+    ).toEqual({ actor_kind: 'machine', type: 'draft', since: '2026-10-05T00:00:00.000Z' })
+    expect(revisionFeedParams({ q: 'x', page: '2' } as never)).toEqual({})
+  })
+})
+
+describe('foldFeed — sittings never cross records', () => {
+  it('folds adjacent saves on the SAME record by the same actor', () => {
+    const rows = [
+      row('3', draftA, { version: 3, created_at: at(60_000) }),
+      row('2', draftA, { version: 2, created_at: at(0) }),
+    ]
+    const out = foldFeed(rows)
+    expect(out).toHaveLength(1)
+    expect(out[0]!.sitting.saves).toBe(2)
+  })
+
+  it('never folds two different records together, however close', () => {
+    const rows = [
+      row('3', draftA, { version: 3, created_at: at(1000) }),
+      row('2', draftB, { version: 2, created_at: at(0) }),
+    ]
+    expect(foldFeed(rows)).toHaveLength(2)
+  })
+})
+
+describe('RecordActivityPanel', () => {
+  it('reads by cursor, with only the non-blank filters, and links each row to its record', async () => {
+    const list = jest.fn().mockResolvedValue({ next: null, next_cursor: null, results: [row('1', draftA)] })
+    mount(
+      <RecordActivityPanel
+        client={{ list }}
+        filters={{ actor: 'u-jurga', actor_kind: '' }}
+        onFiltersChange={jest.fn()}
+        recordHref={(e) => `/draft/${e.id}`}
+      />,
+    )
+    const link = await screen.findByRole('link', { name: /Gulf logistics brief/ })
+    expect(link).toHaveAttribute('href', '/draft/d-a')
+    const sent = list.mock.calls[0][0]
+    expect(sent).toMatchObject({ actor: 'u-jurga' })
+    expect(sent).not.toHaveProperty('actor_kind')
+    expect(sent).not.toHaveProperty('page')
+    expect(screen.queryByText(/showing .* of/i)).not.toBeInTheDocument()
+  })
+
+  it('marks a machine row, and leaves a claimed person calm', async () => {
+    const list = jest.fn().mockResolvedValue({
+      next: null,
+      results: [
+        row('2', draftA, { actor_sub: 'svc:n8n-ogmc', actor_label: 'svc:n8n-ogmc', actor_kind: 'machine', created_at: at(3_600_000) }),
+        row('1', draftB),
+      ],
+    })
+    mount(<RecordActivityPanel client={{ list }} filters={{}} onFiltersChange={jest.fn()} />)
+    const marks = await screen.findAllByTestId('actor-kind')
+    expect(marks).toHaveLength(1)
+    expect(marks[0]).toHaveTextContent(/machine/)
+  })
+
+  it('names the fields changed, and the inline diff opens on expand', async () => {
+    const list = jest.fn().mockResolvedValue({ next: null, results: [row('1', draftA)] })
+    mount(<RecordActivityPanel client={{ list }} filters={{}} onFiltersChange={jest.fn()} />)
+    expect(await screen.findByText(/Edited blog/)).toBeInTheDocument()
+    fireEvent.click(screen.getByRole('button', { name: /blog/ }))
+    expect(await screen.findByText('Before')).toBeInTheDocument()
+  })
+
+  it('the person filter offers subs as values and addresses as labels', async () => {
+    const onFiltersChange = jest.fn()
+    const list = jest.fn().mockResolvedValue({ next: null, results: [row('1', draftA)] })
+    mount(<RecordActivityPanel client={{ list }} filters={{}} onFiltersChange={onFiltersChange} />)
+    await screen.findByText(/Edited blog/)
+    const person = screen.getByLabelText(/person/i) as HTMLSelectElement
+    const opt = within(person).getByRole('option', { name: 'jurga@ogmc.example' }) as HTMLOptionElement
+    expect(opt.value).toBe('u-jurga')
+    fireEvent.change(person, { target: { value: 'u-jurga' } })
+    expect(onFiltersChange).toHaveBeenCalledWith({ actor: 'u-jurga' })
+  })
+
+  it('person vs machine is a filter of its own', async () => {
+    const onFiltersChange = jest.fn()
+    const list = jest.fn().mockResolvedValue({ next: null, results: [] })
+    mount(<RecordActivityPanel client={{ list }} filters={{}} onFiltersChange={onFiltersChange} />)
+    fireEvent.change(await screen.findByLabelText(/made by/i), { target: { value: 'machine' } })
+    expect(onFiltersChange).toHaveBeenCalledWith({ actor_kind: 'machine' })
+  })
+
+  it('record type comes from the host options', async () => {
+    const onFiltersChange = jest.fn()
+    const list = jest.fn().mockResolvedValue({ next: null, results: [] })
+    mount(
+      <RecordActivityPanel
+        client={{ list }}
+        filters={{}}
+        onFiltersChange={onFiltersChange}
+        typeOptions={[{ value: 'topic', label: 'Topics' }, { value: 'draft', label: 'Drafts' }]}
+      />,
+    )
+    fireEvent.change(await screen.findByLabelText(/record type/i), { target: { value: 'draft' } })
+    expect(onFiltersChange).toHaveBeenCalledWith({ type: 'draft' })
+  })
+
+  it('"this week" sets since to the start of the week', async () => {
+    const onFiltersChange = jest.fn()
+    const list = jest.fn().mockResolvedValue({ next: null, results: [] })
+    mount(<RecordActivityPanel client={{ list }} filters={{}} onFiltersChange={onFiltersChange} />)
+    fireEvent.click(await screen.findByRole('button', { name: /this week/i }))
+    const arg = onFiltersChange.mock.calls[0][0]
+    // A local Monday midnight, as an instant.
+    expect(new Date(arg.since).getDay()).toBe(1)
+    expect(new Date(arg.since).getHours()).toBe(0)
+    expect(new Date(arg.since).getTime()).toBeLessThanOrEqual(Date.now())
+    expect(Date.now() - new Date(arg.since).getTime()).toBeLessThan(8 * 86_400_000)
+  })
+
+  it('"only their edits" narrows to that actor', async () => {
+    const onFiltersChange = jest.fn()
+    const list = jest.fn().mockResolvedValue({ next: null, results: [row('1', draftA)] })
+    mount(<RecordActivityPanel client={{ list }} filters={{}} onFiltersChange={onFiltersChange} />)
+    fireEvent.click(await screen.findByRole('button', { name: /only jurga@ogmc\.example/i }))
+    expect(onFiltersChange).toHaveBeenCalledWith({ actor: 'u-jurga' })
+  })
+
+  it('an empty filtered feed says it is filtered, not that nothing happened', async () => {
+    const list = jest.fn().mockResolvedValue({ next: null, results: [] })
+    mount(<RecordActivityPanel client={{ list }} filters={{ actor_kind: 'machine' }} onFiltersChange={jest.fn()} />)
+    expect(await screen.findByText(/no edits match/i)).toBeInTheDocument()
+  })
+})