@startsimpli/ui 0.4.141 → 0.4.143

package/src/components/history/__tests__/record-history-restore.test.tsx

@@ -0,0 +1,373 @@
+/**
+ * RED for bd startsim-zkyk4 — restore, as a person meets it in the history panel.
+ *
+ * The rules that matter:
+ * - offered only when the host supplies `restore`, and only where it would change
+ *   something (never on the row that IS the current value);
+ * - nothing is written until a confirm that SHOWS what will change;
+ * - every restore carries a version (the route 428s without one), and it is the
+ *   version the HOST holds, not one the panel guesses;
+ * - a 412 reuses StaleSaveDialog, and only an explicit choice adopts the version
+ *   the refusal named;
+ * - after a restore the panel re-reads the trail and the host is told, so its own
+ *   editor state can reload;
+ * - the restore revision reads "Restored … from vN".
+ */
+import { render, screen, waitFor, fireEvent, within } from '@testing-library/react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+
+import { RecordHistoryPanel } from '../RecordHistoryPanel'
+import type { EntityRevision, RevisionClient, RevisionPage } from '../types'
+
+function mount(ui: React.ReactElement) {
+  const client = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: 0 } } })
+  return render(<QueryClientProvider client={client}>{ui}</QueryClientProvider>)
+}
+
+const T0 = Date.parse('2026-10-07T12:00:00.000Z')
+const at = (ms: number) => new Date(T0 + ms).toISOString()
+
+function rev(version: number, changed: Record<string, unknown>, over: Partial<EntityRevision> = {}): EntityRevision {
+  return {
+    id: `r${version}`,
+    version,
+    action: 'updated',
+    source: 'patch',
+    // An hour apart, so nothing folds and each version is its own row.
+    created_at: at(version * 3_600_000),
+    actor_sub: version % 2 ? 'u-jurga' : 'u-alex',
+    actor_label: version % 2 ? 'jurga@ogmc.example' : 'alex@ogmc.example',
+    actor_kind: 'person',
+    actor_kind_source: 'claim',
+    metadata: { changed: changed as never },
+    ...over,
+  }
+}
+
+const trail: EntityRevision[] = [
+  rev(3, { blog: { before: 'Jurga paragraph', after: 'Machine paragraph' } }, {
+    actor_sub: 'svc:n8n',
+    actor_label: 'svc:n8n',
+    actor_kind: 'machine',
+  }),
+  rev(2, { blog: { before: 'First', after: 'Jurga paragraph' } }),
+  rev(1, { blog: { after: 'First' } }, { action: 'created' }),
+]
+
+function page(results: EntityRevision[], over: Partial<RevisionPage> = {}): RevisionPage {
+  return { count: results.length, next: null, previous: null, results, ...over }
+}
+
+function clientWith(over: Partial<RevisionClient> = {}, results = trail) {
+  return {
+    list: jest.fn().mockResolvedValue(page(results)),
+    restore: jest.fn().mockResolvedValue({
+      status: 200,
+      body: { id: 'e1', version: 4, restore: { restored_from: 2, fields: ['blog'], revision: 4 } },
+    }),
+    ...over,
+  }
+}
+
+/** The history row for one version, by its "vN" subtitle. */
+async function rowFor(version: number): Promise<HTMLElement> {
+  const label = await screen.findByText(`v${version}`)
+  return label.closest('[data-activity-id]') as HTMLElement
+}
+
+async function openField(version: number, field = 'blog') {
+  const row = await rowFor(version)
+  fireEvent.click(within(row).getByRole('button', { name: new RegExp(field) }))
+  return row
+}
+
+describe('RecordHistoryPanel — restore is offered only where it means something', () => {
+  it('offers nothing when the host supplies no restore', async () => {
+    const { list } = clientWith()
+    mount(<RecordHistoryPanel client={{ list }} currentVersion={3} />)
+    await openField(2)
+    expect(screen.queryByRole('button', { name: /restore this value/i })).not.toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: /restore this version/i })).not.toBeInTheDocument()
+  })
+
+  it('offers nothing when the host says the viewer cannot write', async () => {
+    mount(<RecordHistoryPanel client={clientWith()} currentVersion={3} canRestore={false} />)
+    await openField(2)
+    expect(screen.queryByRole('button', { name: /restore this value/i })).not.toBeInTheDocument()
+  })
+
+  it('offers "Restore this value" on an older field change, and NOT on the current one', async () => {
+    mount(<RecordHistoryPanel client={clientWith()} currentVersion={3} />)
+    const older = await openField(2)
+    expect(within(older).getByRole('button', { name: /restore this value/i })).toBeInTheDocument()
+    const newest = await openField(3)
+    expect(within(newest).queryByRole('button', { name: /restore this value/i })).not.toBeInTheDocument()
+  })
+
+  it('offers "Restore this version" on every row but the newest', async () => {
+    mount(<RecordHistoryPanel client={clientWith()} currentVersion={3} />)
+    const older = await rowFor(2)
+    expect(within(older).getByRole('button', { name: /restore this version/i })).toBeInTheDocument()
+    const newest = await rowFor(3)
+    expect(within(newest).queryByRole('button', { name: /restore this version/i })).not.toBeInTheDocument()
+  })
+
+  it('a narrowed (?field=) panel never offers a WHOLE-record restore — its trail is partial', async () => {
+    const client = clientWith()
+    mount(<RecordHistoryPanel client={client} currentVersion={3} field="blog" />)
+    const older = await openField(2)
+    expect(within(older).queryByRole('button', { name: /restore this version/i })).not.toBeInTheDocument()
+    expect(within(older).getByRole('button', { name: /restore this value/i })).toBeInTheDocument()
+  })
+})
+
+describe('RecordHistoryPanel — the confirm shows what will change, and writes nothing until confirmed', () => {
+  it('shows the field, from now to the restored value, with a line diff', async () => {
+    const client = clientWith()
+    mount(<RecordHistoryPanel client={client} currentVersion={3} />)
+    const row = await openField(2)
+    fireEvent.click(within(row).getByRole('button', { name: /restore this value/i }))
+    const dialog = await screen.findByTestId('restore-confirm-dialog')
+    expect(dialog).toHaveTextContent(/v2/)
+    expect(within(dialog).getByTestId('restore-preview-blog')).toHaveTextContent(/Machine paragraph/)
+    expect(within(dialog).getByTestId('restore-preview-blog')).toHaveTextContent(/Jurga paragraph/)
+    expect(client.restore).not.toHaveBeenCalled()
+  })
+
+  it('Cancel writes nothing', async () => {
+    const client = clientWith()
+    mount(<RecordHistoryPanel client={client} currentVersion={3} />)
+    const row = await openField(2)
+    fireEvent.click(within(row).getByRole('button', { name: /restore this value/i }))
+    fireEvent.click(await screen.findByTestId('restore-cancel'))
+    expect(screen.queryByTestId('restore-confirm-dialog')).not.toBeInTheDocument()
+    expect(client.restore).not.toHaveBeenCalled()
+  })
+
+  it('confirming sends revision, fields AND the host-held version', async () => {
+    const client = clientWith()
+    mount(<RecordHistoryPanel client={client} currentVersion={3} />)
+    const row = await openField(2)
+    fireEvent.click(within(row).getByRole('button', { name: /restore this value/i }))
+    fireEvent.click(await screen.findByTestId('restore-confirm'))
+    await waitFor(() => expect(client.restore).toHaveBeenCalledTimes(1))
+    expect(client.restore).toHaveBeenCalledWith({ version: 2, fields: ['blog'], expectedVersion: 3 })
+  })
+
+  it('a whole-version restore omits fields', async () => {
+    const client = clientWith()
+    mount(<RecordHistoryPanel client={client} currentVersion={3} />)
+    const row = await rowFor(2)
+    fireEvent.click(within(row).getByRole('button', { name: /restore this version/i }))
+    fireEvent.click(await screen.findByTestId('restore-confirm'))
+    await waitFor(() => expect(client.restore).toHaveBeenCalledWith({ version: 2, expectedVersion: 3 }))
+  })
+
+  it('reads the version from a FUNCTION at confirm time, so an autosave in between is honoured', async () => {
+    const client = clientWith()
+    let held = 3
+    mount(<RecordHistoryPanel client={client} currentVersion={() => held} />)
+    const row = await openField(2)
+    fireEvent.click(within(row).getByRole('button', { name: /restore this value/i }))
+    held = 7
+    fireEvent.click(await screen.findByTestId('restore-confirm'))
+    await waitFor(() =>
+      expect(client.restore).toHaveBeenCalledWith(expect.objectContaining({ expectedVersion: 7 })),
+    )
+  })
+
+  it('runs the host beforeRestore hook FIRST (to stop pending autosaves)', async () => {
+    const order: string[] = []
+    const client = clientWith({
+      restore: jest.fn().mockImplementation(async () => {
+        order.push('restore')
+        return { status: 200, body: { version: 4, restore: { restored_from: 2, fields: ['blog'], revision: 4 } } }
+      }),
+    })
+    mount(
+      <RecordHistoryPanel
+        client={client}
+        currentVersion={3}
+        beforeRestore={async () => {
+          order.push('before')
+        }}
+      />,
+    )
+    const row = await openField(2)
+    fireEvent.click(within(row).getByRole('button', { name: /restore this value/i }))
+    fireEvent.click(await screen.findByTestId('restore-confirm'))
+    await waitFor(() => expect(order).toEqual(['before', 'restore']))
+  })
+})
+
+describe('RecordHistoryPanel — the host hook around the send', () => {
+  it('reads the version AFTER beforeRestore, so a flushed save is not a 412 against itself', async () => {
+    const client = clientWith()
+    let held = 3
+    mount(
+      <RecordHistoryPanel
+        client={client}
+        currentVersion={() => held}
+        beforeRestore={async () => {
+          held = 4
+        }}
+      />,
+    )
+    const row = await openField(2)
+    fireEvent.click(within(row).getByRole('button', { name: /restore this value/i }))
+    fireEvent.click(await screen.findByTestId('restore-confirm'))
+    await waitFor(() =>
+      expect(client.restore).toHaveBeenCalledWith(expect.objectContaining({ expectedVersion: 4 })),
+    )
+  })
+
+  it('a beforeRestore that throws ABORTS the restore and says why', async () => {
+    const client = clientWith()
+    mount(
+      <RecordHistoryPanel
+        client={client}
+        currentVersion={3}
+        beforeRestore={async () => {
+          throw new Error('Your edit could not be saved first.')
+        }}
+      />,
+    )
+    const row = await openField(2)
+    fireEvent.click(within(row).getByRole('button', { name: /restore this value/i }))
+    fireEvent.click(await screen.findByTestId('restore-confirm'))
+    expect(await screen.findByTestId('restore-error')).toHaveTextContent(/could not be saved first/)
+    expect(client.restore).not.toHaveBeenCalled()
+  })
+
+  it('runs the returned cleanup once the restore settles, even on a refusal', async () => {
+    const cleanup = jest.fn()
+    const client = clientWith({ restore: jest.fn().mockResolvedValue({ status: 409, body: { detail: 'no' } }) })
+    mount(<RecordHistoryPanel client={client} currentVersion={3} beforeRestore={() => cleanup} />)
+    const row = await openField(2)
+    fireEvent.click(within(row).getByRole('button', { name: /restore this value/i }))
+    fireEvent.click(await screen.findByTestId('restore-confirm'))
+    await screen.findByTestId('restore-error')
+    expect(cleanup).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('RecordHistoryPanel — after the restore', () => {
+  it('tells the host, then re-reads the trail', async () => {
+    const onRestored = jest.fn()
+    const client = clientWith()
+    mount(<RecordHistoryPanel client={client} currentVersion={3} onRestored={onRestored} />)
+    const row = await openField(2)
+    fireEvent.click(within(row).getByRole('button', { name: /restore this value/i }))
+    fireEvent.click(await screen.findByTestId('restore-confirm'))
+    await waitFor(() => expect(onRestored).toHaveBeenCalledTimes(1))
+    expect(onRestored.mock.calls[0][0]).toMatchObject({ kind: 'restored', version: 4 })
+    await waitFor(() => expect(client.list.mock.calls.length).toBeGreaterThanOrEqual(2))
+    expect(screen.queryByTestId('restore-confirm-dialog')).not.toBeInTheDocument()
+    expect(await screen.findByTestId('restore-done')).toHaveTextContent(/v2/)
+  })
+
+  it('a refusal other than 412 stays in the dialog with the server sentence', async () => {
+    const client = clientWith({
+      restore: jest.fn().mockResolvedValue({ status: 409, body: { detail: 'the trail truncated blog' } }),
+    })
+    mount(<RecordHistoryPanel client={client} currentVersion={3} />)
+    const row = await openField(2)
+    fireEvent.click(within(row).getByRole('button', { name: /restore this value/i }))
+    fireEvent.click(await screen.findByTestId('restore-confirm'))
+    expect(await screen.findByTestId('restore-error')).toHaveTextContent('the trail truncated blog')
+    expect(screen.getByTestId('restore-confirm-dialog')).toBeInTheDocument()
+  })
+})
+
+describe('RecordHistoryPanel — a stale restore reuses StaleSaveDialog', () => {
+  const stale = () =>
+    clientWith({
+      restore: jest
+        .fn()
+        .mockResolvedValueOnce({ status: 412, body: { current_version: 5, detail: 'stale' } })
+        .mockResolvedValueOnce({ status: 200, body: { version: 6, restore: { restored_from: 2, fields: ['blog'], revision: 6 } } }),
+    })
+
+  it('opens the stale dialog and does NOT retry on its own', async () => {
+    const client = stale()
+    mount(<RecordHistoryPanel client={client} currentVersion={3} />)
+    const row = await openField(2)
+    fireEvent.click(within(row).getByRole('button', { name: /restore this value/i }))
+    fireEvent.click(await screen.findByTestId('restore-confirm'))
+    expect(await screen.findByTestId('stale-save-dialog')).toBeInTheDocument()
+    expect(client.restore).toHaveBeenCalledTimes(1)
+    // Not the editor's sentence — nothing was being typed.
+    expect(screen.getByTestId('stale-save-reassurance')).not.toHaveTextContent(/your edits/i)
+  })
+
+  it('"restore anyway" is the only path that adopts current_version', async () => {
+    const onRestored = jest.fn()
+    const client = stale()
+    mount(<RecordHistoryPanel client={client} currentVersion={3} onRestored={onRestored} />)
+    const row = await openField(2)
+    fireEvent.click(within(row).getByRole('button', { name: /restore this value/i }))
+    fireEvent.click(await screen.findByTestId('restore-confirm'))
+    fireEvent.click(await screen.findByTestId('stale-save-keep-mine'))
+    await waitFor(() => expect(client.restore).toHaveBeenCalledTimes(2))
+    expect(client.restore.mock.calls[1][0]).toEqual({ version: 2, fields: ['blog'], expectedVersion: 5 })
+    await waitFor(() => expect(onRestored).toHaveBeenCalled())
+  })
+
+  it('"see what changed" closes it and re-reads the trail without writing', async () => {
+    const client = stale()
+    mount(<RecordHistoryPanel client={client} currentVersion={3} />)
+    const row = await openField(2)
+    fireEvent.click(within(row).getByRole('button', { name: /restore this value/i }))
+    fireEvent.click(await screen.findByTestId('restore-confirm'))
+    fireEvent.click(await screen.findByTestId('stale-save-review'))
+    await waitFor(() => expect(screen.queryByTestId('stale-save-dialog')).not.toBeInTheDocument())
+    expect(client.restore).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('RecordHistoryPanel — the restore row and the policy', () => {
+  it('a restore revision reads "Restored blog from v2"', async () => {
+    const restored = rev(4, { blog: { before: 'Machine paragraph', after: 'Jurga paragraph' } }, {
+      source: 'restore',
+      metadata: {
+        changed: { blog: { before: 'Machine paragraph', after: 'Jurga paragraph' } },
+        restored_from: 2,
+        restored_fields: ['blog'],
+      } as never,
+    })
+    mount(<RecordHistoryPanel client={clientWith({}, [restored, ...trail])} currentVersion={4} />)
+    expect(await screen.findByText(/Restored blog from v2/)).toBeInTheDocument()
+  })
+
+  it('a restore never folds into the edit before it, even by the same person a second later', async () => {
+    const restored = rev(4, { blog: { before: 'x', after: 'y' } }, {
+      source: 'restore',
+      created_at: at(3 * 3_600_000 + 1000),
+      actor_sub: 'svc:n8n',
+      actor_label: 'svc:n8n',
+      actor_kind: 'machine',
+      metadata: { changed: { blog: { before: 'x', after: 'y' } }, restored_from: 2 } as never,
+    })
+    mount(<RecordHistoryPanel client={clientWith({}, [restored, ...trail])} currentVersion={4} />)
+    expect(await screen.findByText('v4')).toBeInTheDocument()
+    expect(screen.getByText('v3')).toBeInTheDocument()
+  })
+
+  it('reads the history policy off the envelope when the host does not pass it', async () => {
+    const client = {
+      list: jest.fn().mockResolvedValue(page([], { history: { enabled: false, declared_by: 'type' } })),
+    }
+    mount(<RecordHistoryPanel client={client} />)
+    expect(await screen.findByTestId('record-history-declared-off')).toBeInTheDocument()
+  })
+
+  it('passes ?field= to the reader when narrowed, and offers a way back to everything', async () => {
+    const client = clientWith()
+    const onClearField = jest.fn()
+    mount(<RecordHistoryPanel client={client} field="blog" onClearField={onClearField} />)
+    await waitFor(() => expect(client.list).toHaveBeenCalled())
+    expect(client.list.mock.calls[0][0]).toMatchObject({ field: 'blog' })
+    fireEvent.click(await screen.findByTestId('record-history-clear-field'))
+    expect(onClearField).toHaveBeenCalled()
+  })
+})

package/src/components/history/__tests__/restore.test.ts

@@ -0,0 +1,209 @@
+/**
+ * RED for bd startsim-zkyk4 — the pure half of "Restore this value / Restore this
+ * version": what a restore to revision N would change, read off the trail the
+ * panel already holds, and what the server said when asked.
+ *
+ * The server's definition is the contract (start-simpli-api
+ * tenant-starter/apps/api/revision_history.py `_state_at`): the record at N is
+ * rebuilt BACKWARDS from now by undoing every edit after N, newest first — a key
+ * whose `before` is absent was created after N and is removed. So the preview
+ * must agree with that rule exactly, or the confirm dialog promises one change
+ * and the server makes another.
+ */
+import {
+  latestFieldVersions,
+  parseRestoreOutcome,
+  restorePreview,
+} from '../restore'
+import type { EntityRevision } from '../types'
+
+const T0 = Date.parse('2026-10-07T12:00:00.000Z')
+const at = (ms: number) => new Date(T0 + ms).toISOString()
+
+function rev(version: number, changed: Record<string, unknown>, over: Partial<EntityRevision> = {}): EntityRevision {
+  return {
+    id: `r${version}`,
+    version,
+    action: version === 1 ? 'created' : 'updated',
+    source: 'patch',
+    created_at: at(version * 60_000),
+    actor_sub: 'u1',
+    actor_label: 'jurga@ogmc.example',
+    actor_kind: 'person',
+    actor_kind_source: 'claim',
+    metadata: { changed: changed as never },
+    ...over,
+  }
+}
+
+// Newest first, as the route orders them.
+const trail: EntityRevision[] = [
+  rev(4, { blog: { before: 'B machine', after: 'B reviewer 2' } }),
+  rev(3, { blog: { before: 'B jurga', after: 'B machine' }, team_notes: { after: 'note' } }),
+  rev(2, { blog: { before: 'B draft', after: 'B jurga' }, title: { before: 'T1', after: 'T2' } }),
+  rev(1, { blog: { after: 'B draft' }, title: { after: 'T1' } }),
+]
+
+describe('restorePreview — agrees with the server rebuild', () => {
+  it('a FIELD restore to v2 moves only that field, from now back to its value at v2', () => {
+    const p = restorePreview(trail, 2, { fields: ['blog'] })
+    expect(p.complete).toBe(true)
+    expect(p.changes).toHaveLength(1)
+    expect(p.changes[0]).toMatchObject({
+      field: 'blog',
+      current: { has: true, value: 'B reviewer 2' },
+      restored: { has: true, value: 'B jurga' },
+    })
+    expect(p.noop).toBe(false)
+  })
+
+  it('a WHOLE restore to v2 also REMOVES a key that was created after v2', () => {
+    const p = restorePreview(trail, 2)
+    const byField = Object.fromEntries(p.changes.map((c) => [c.field, c]))
+    expect(Object.keys(byField).sort()).toEqual(['blog', 'team_notes'])
+    expect(byField.team_notes).toMatchObject({
+      current: { has: true, value: 'note' },
+      restored: { has: false },
+    })
+    // title did not move after v2 — nothing to say about it.
+    expect(byField.title).toBeUndefined()
+  })
+
+  it('restoring the CURRENT version is a no-op, said as one', () => {
+    const p = restorePreview(trail, 4)
+    expect(p.noop).toBe(true)
+    expect(p.changes).toEqual([])
+  })
+
+  it('a field nobody touched after N is a no-op for that field', () => {
+    expect(restorePreview(trail, 2, { fields: ['title'] }).noop).toBe(true)
+  })
+
+  it('a field that ends up where it started is not a change', () => {
+    const roundTrip = [
+      rev(3, { blog: { before: 'x', after: 'a' } }),
+      rev(2, { blog: { before: 'a', after: 'x' } }),
+      rev(1, { blog: { after: 'a' } }),
+    ]
+    expect(restorePreview(roundTrip, 1).noop).toBe(true)
+  })
+
+  it('a truncated or omitted side after N makes the value UNKNOWABLE — the server 409s', () => {
+    const t = [
+      rev(3, { blog: { before: 'long…', truncated: true, after: 'short' } }),
+      rev(2, { blog: { before: 'a', after: 'long…' } }),
+    ]
+    const p = restorePreview(t, 2)
+    expect(p.unknowable).toEqual(['blog'])
+    const omitted = [
+      rev(3, { blog: {} }, { metadata: { changed: { blog: {} }, values_omitted: true } }),
+      rev(2, { blog: { before: 'a', after: 'b' } }),
+    ]
+    // The server cannot know the NAME either on an omitted row (the cap drops
+    // the name side with the values), so a whole restore over it is refused.
+    expect(restorePreview(omitted, 2).unknowable).toEqual(['blog', 'name'])
+    expect(restorePreview(omitted, 2, { fields: ['blog'] }).unknowable).toEqual(['blog'])
+  })
+
+  it('a WITHHELD field is left as it is by a whole restore, and named as such', () => {
+    const t = [
+      rev(3, { body: {} }, { redacted_fields: ['body'] }),
+      rev(2, { blog: { before: 'a', after: 'b' } }),
+    ]
+    const p = restorePreview(t, 2)
+    expect(p.withheld).toEqual(['body'])
+    expect(p.changes.map((c) => c.field)).not.toContain('body')
+  })
+
+  it('INCOMPLETE when a row between N and now is not loaded — never a confident preview', () => {
+    // v3 missing: the chain from 2 to 4 has a hole.
+    const holey = [trail[0]!, trail[2]!, trail[3]!]
+    const p = restorePreview(holey, 2)
+    expect(p.complete).toBe(false)
+  })
+
+  it('the name column moves on a whole restore only', () => {
+    const t = [
+      rev(3, {}, { metadata: { changed: {}, name: { before: 'Old', after: 'New' } } }),
+      rev(2, { blog: { before: 'a', after: 'b' } }),
+    ]
+    expect(restorePreview(t, 2).name).toMatchObject({
+      current: { has: true, value: 'New' },
+      restored: { has: true, value: 'Old' },
+    })
+    expect(restorePreview(t, 2, { fields: ['blog'] }).name).toBeUndefined()
+  })
+
+  it('an ATTEMPT row (held back, nothing moved) changes nothing', () => {
+    const t = [
+      rev(3, {}, { metadata: { changed: {}, preserved: ['blog'] } }),
+      rev(2, { blog: { before: 'a', after: 'b' } }),
+    ]
+    expect(restorePreview(t, 2).noop).toBe(true)
+  })
+})
+
+describe('latestFieldVersions — which fields have moved since a row', () => {
+  it('maps each field to the newest version that changed it', () => {
+    expect(latestFieldVersions(trail)).toEqual({ blog: 4, team_notes: 3, title: 2 })
+  })
+})
+
+describe('parseRestoreOutcome — every answer the route gives', () => {
+  const ok = {
+    status: 200,
+    body: {
+      id: 'e1',
+      version: 5,
+      data: { blog: 'B jurga' },
+      restore: { restored_from: 2, fields: ['blog'], revision: 5 },
+    },
+  }
+
+  it('200 → restored, with the new version and the moved fields', () => {
+    expect(parseRestoreOutcome(ok)).toMatchObject({
+      kind: 'restored',
+      version: 5,
+      summary: { restoredFrom: 2, fields: ['blog'], revision: 5 },
+    })
+  })
+
+  it('200 with revision null → restored, but NOTHING changed', () => {
+    const noop = { status: 200, body: { ...ok.body, version: 4, restore: { restored_from: 2, fields: [], revision: null } } }
+    expect(parseRestoreOutcome(noop)).toMatchObject({ kind: 'restored', summary: { revision: null } })
+  })
+
+  it('reads a camelised body too', () => {
+    const camel = { status: 200, body: { version: 5, restore: { restoredFrom: 2, fields: ['blog'], revision: 5 } } }
+    expect(parseRestoreOutcome(camel)).toMatchObject({ summary: { restoredFrom: 2 } })
+  })
+
+  it('412, resolved OR thrown → stale, carrying current_version', () => {
+    const refusal = { status: 412, body: { current_version: 6, detail: 'stale' } }
+    expect(parseRestoreOutcome(refusal)).toMatchObject({ kind: 'stale', currentVersion: 6 })
+    const thrown = Object.assign(new Error('412'), { status: 412, body: { current_version: 6 } })
+    expect(parseRestoreOutcome(thrown)).toMatchObject({ kind: 'stale', currentVersion: 6 })
+  })
+
+  it.each([
+    [428, /version/i],
+    [403, /access/i],
+    [404, /no longer|not available|no such/i],
+    [409, /.+/],
+    [400, /.+/],
+  ])('%s → refused, with a sentence a person can read', (status, sentence) => {
+    const out = parseRestoreOutcome({ status, body: {} })
+    expect(out.kind).toBe('refused')
+    if (out.kind === 'refused') {
+      expect(out.status).toBe(status)
+      expect(out.message).toMatch(sentence)
+    }
+  })
+
+  it('prefers the server detail when there is one (400 names the field)', () => {
+    const out = parseRestoreOutcome({ status: 400, body: { fields: ['blog is not declared on type draft'] } })
+    expect(out.kind === 'refused' && out.message).toMatch(/blog is not declared/)
+    const out2 = parseRestoreOutcome({ status: 409, body: { detail: 'history is off' } })
+    expect(out2.kind === 'refused' && out2.message).toBe('history is off')
+  })
+})

package/src/components/history/index.ts

@@ -22,7 +22,13 @@
  * `kind`/`kindSource` — rather than deciding locally, because "absent" read as
  * "a machine did this" is the single worst failure available here.
  */
-export { RecordHistoryPanel, REVISION_ENTRY_TYPES } from './RecordHistoryPanel';
+export {
+  RecordHistoryPanel,
+  REVISION_ENTRY_ICONS,
+  REVISION_ENTRY_TYPES,
+  revisionEntryType,
+  versionNote,
+} from './RecordHistoryPanel';
 export type { RecordHistoryPanelProps } from './RecordHistoryPanel';
 
 export { RevisionFields } from './RevisionFields';
@@ -56,6 +62,58 @@ export type {
 
 export { diffLines, unifiedTextDiff } from './text-diff';
 
+/* -------------------------------------------------------------------------- */
+/*  RESTORE (bd startsim-zkyk4) — "Restore this value / this version"         */
+/* -------------------------------------------------------------------------- */
+
+export { RestoreConfirmDialog } from './RestoreConfirmDialog';
+export type { RestoreConfirmDialogProps } from './RestoreConfirmDialog';
+export { latestFieldVersions, parseRestoreOutcome, restorePreview } from './restore';
+export type {
+  ParsedRestoreOutcome,
+  RestoreFieldChange,
+  RestorePreview,
+  RestoreSide,
+  RestoreSummary,
+} from './restore';
+
+/* -------------------------------------------------------------------------- */
+/*  FIELD AUTHORS (bd startsim-vjhbw) — "edited by X · 2h ago"                */
+/* -------------------------------------------------------------------------- */
+
+export {
+  FieldAttribution,
+  FieldAuthorsNotice,
+  fieldAuthorOf,
+  normalizeFieldAuthors,
+  useFieldAuthors,
+} from './FieldAttribution';
+export type {
+  FieldAttributionProps,
+  NormalizedFieldAuthor,
+  NormalizedFieldAuthors,
+  UseFieldAuthorsOptions,
+} from './FieldAttribution';
+
+/* -------------------------------------------------------------------------- */
+/*  ACROSS RECORDS (bd startsim-ucg5u) — the edit feed                        */
+/* -------------------------------------------------------------------------- */
+
+export { RecordActivityPanel } from './RecordActivityPanel';
+export type { RecordActivityOption, RecordActivityPanelProps } from './RecordActivityPanel';
+export {
+  REVISION_FEED_ACTOR_KINDS,
+  REVISION_FEED_FILTER_KEYS,
+  foldFeed,
+  localDateInput,
+  localDayEnd,
+  localDayStart,
+  revisionFeedFiltersFrom,
+  revisionFeedParams,
+  startOfThisWeek,
+} from './revision-feed';
+export type { FeedSitting } from './revision-feed';
+
 /* -------------------------------------------------------------------------- */
 /*  THE CONDITIONAL WRITE (bd startsim-jkkn7.3)                               */
 /*                                                                            */
@@ -115,8 +173,21 @@ export type {
   ActorKindSource,
   EntityRevision,
   RevisionAction,
+  FieldAuthor,
+  FieldAuthorsClient,
+  FieldAuthorsResponse,
+  FieldAuthorsTrailStart,
+  RestoreOutcome,
+  RestoreRequest,
   RevisionClient,
+  RevisionFeedClient,
+  RevisionFeedEntity,
+  RevisionFeedFilters,
+  RevisionFeedPage,
+  RevisionFeedQuery,
+  RevisionFeedRow,
   RevisionFieldChange,
+  RevisionHistoryPolicy,
   RevisionMetadata,
   RevisionPage,
   RevisionPrecondition,