@prenta/admin 1.15.0 → 1.17.0

package/src/__tests__/views/seo-ai-visibility.render.test.tsx

@@ -0,0 +1,279 @@
+// @vitest-environment happy-dom
+import type { ReactNode } from 'react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { fireEvent, render, screen, waitFor, within } from '@testing-library/react'
+import type { SeoGeoReport } from '../../lib/seo-service.js'
+
+function report(over: Partial<SeoGeoReport> = {}): SeoGeoReport {
+  return {
+    enabled: true,
+    window: { from: '2026-08-14', to: '2026-09-10', days: 28 },
+    firstSeenAt: '2026-08-01',
+    crawl: {
+      // Whole-window total from the server — includes the capped "other"
+      // bucket, so it is deliberately larger than the sum of `bots[].hits`.
+      total: { hits: 21, prevHits: 12 },
+      series: [
+        { date: '2026-09-09', hits: { GPTBot: 3, Googlebot: 5 } },
+        { date: '2026-09-10', hits: { GPTBot: 1 } },
+      ],
+      bots: [
+        {
+          bot: 'Googlebot',
+          category: 'search',
+          hits: 5,
+          prevHits: 4,
+          lastSeenAt: '2026-09-09',
+          policy: 'allowed',
+        },
+        {
+          bot: 'GPTBot',
+          category: 'training',
+          hits: 4,
+          prevHits: 8,
+          lastSeenAt: '2026-09-10',
+          policy: 'blocked_still_crawling',
+        },
+        {
+          bot: 'ClaudeBot',
+          category: 'training',
+          hits: 0,
+          prevHits: null,
+          lastSeenAt: null,
+          policy: 'blocked',
+        },
+      ],
+      topPaths: [
+        {
+          path: '/pricing',
+          hits: 6,
+          bots: ['GPTBot', 'Googlebot'],
+          entityId: 'doc-1',
+          entityTitle: 'Pricing',
+          collection: 'pages',
+        },
+        {
+          path: '/blog/launch',
+          hits: 4,
+          bots: ['GPTBot'],
+          entityId: 'doc-2',
+          entityTitle: 'Launch post',
+          collection: 'blog',
+        },
+        { path: '/legacy', hits: 3, bots: ['Googlebot'] },
+      ],
+      otherHits: 12,
+    },
+    referrals: {
+      total: { visits: 9, prevVisits: 3 },
+      engines: [
+        { engine: 'ChatGPT', visits: 7, prevVisits: 3 },
+        { engine: 'Perplexity', visits: 2, prevVisits: null },
+      ],
+      topPaths: [
+        {
+          path: '/pricing',
+          visits: 8,
+          engines: ['ChatGPT', 'Perplexity'],
+          entityId: 'doc-1',
+          entityTitle: 'Pricing',
+          collection: 'pages',
+        },
+        { path: '/blog/x', visits: 1, engines: ['ChatGPT'] },
+      ],
+      otherVisits: 4,
+    },
+    ...over,
+  }
+}
+
+const EMPTY_WINDOW: Pick<SeoGeoReport, 'crawl' | 'referrals'> = {
+  crawl: { total: { hits: 0, prevHits: null }, series: [], bots: [], topPaths: [], otherHits: 0 },
+  referrals: { total: { visits: 0, prevVisits: null }, engines: [], topPaths: [], otherVisits: 0 },
+}
+
+const fetchSeoGeo = vi.fn(async (_days: number): Promise<SeoGeoReport> => report())
+vi.mock('../../lib/seo-service.js', () => ({ fetchSeoGeo: (d: number) => fetchSeoGeo(d) }))
+// recharts needs layout; stub the chart so the table assertions drive the test.
+vi.mock('recharts', () => ({
+  ResponsiveContainer: ({ children }: { children: ReactNode }) => (
+    <div data-testid="chart">{children}</div>
+  ),
+  BarChart: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  Bar: () => null,
+  XAxis: () => null,
+  YAxis: () => null,
+  Tooltip: () => null,
+  Legend: () => null,
+  CartesianGrid: () => null,
+}))
+
+const { AiVisibilityTab } = await import('../../views/seo/AiVisibilityTab.js')
+
+beforeEach(() => {
+  fetchSeoGeo.mockReset()
+  fetchSeoGeo.mockImplementation(async () => report())
+})
+
+describe('AiVisibilityTab', () => {
+  it('renders bots with policy text, deltas, and top paths with editor links gated on entityId', async () => {
+    const onNavigate = vi.fn()
+    render(<AiVisibilityTab onNavigate={onNavigate} />)
+    await screen.findByRole('table', { name: /crawlers/i })
+    expect(fetchSeoGeo).toHaveBeenCalledWith(28)
+
+    const crawlers = screen.getByRole('table', { name: /crawlers/i })
+    expect(within(crawlers).getByText('Blocked — still crawling')).toBeTruthy()
+    expect(within(crawlers).getByText('Allowed')).toBeTruthy()
+    expect(within(crawlers).getByText('Blocked')).toBeTruthy()
+    expect(within(crawlers).getAllByText('AI training', { selector: 'td' })).toHaveLength(2)
+    expect(within(crawlers).getByText('Search', { selector: 'td' })).toBeTruthy()
+    // null prevHits (ClaudeBot) and null lastSeenAt both render as an em dash.
+    expect(within(crawlers).getAllByText('—').length).toBeGreaterThanOrEqual(2)
+    // +25% (5 vs 4) and -50% (4 vs 8).
+    expect(within(crawlers).getByText('+25%')).toBeTruthy()
+    expect(within(crawlers).getByText('-50%')).toBeTruthy()
+
+    // Headline crawl number comes from `crawl.total`, not from summing bots.
+    const crawlSummary = screen.getByRole('group', { name: /crawl summary/i })
+    expect(within(crawlSummary).getByText('21')).toBeTruthy()
+    expect(within(crawlSummary).getByText('+75%')).toBeTruthy()
+
+    expect(screen.getByTestId('chart')).toBeTruthy()
+
+    const cited = screen.getByRole('table', { name: /top cited pages/i })
+    fireEvent.click(within(cited).getByRole('button', { name: /open pricing in editor/i }))
+    expect(onNavigate).toHaveBeenCalledWith('/pages/doc-1/edit')
+    expect(within(cited).queryByRole('button', { name: /open \/blog\/x/i })).toBeNull()
+    expect(within(cited).getByText('/blog/x')).toBeTruthy()
+
+    // Post-type collections route through the post editor, not the pages one.
+    const crawled = screen.getByRole('table', { name: /top crawled pages/i })
+    fireEvent.click(within(crawled).getByRole('button', { name: /open launch post in editor/i }))
+    expect(onNavigate).toHaveBeenLastCalledWith('/posts/blog/doc-2/edit')
+    expect(within(crawled).queryByRole('button', { name: /open \/legacy/i })).toBeNull()
+
+    expect(screen.getByText(/12 hits on paths beyond the daily cap/i)).toBeTruthy()
+    expect(screen.getByText(/4 visits on paths beyond the daily cap/i)).toBeTruthy()
+    expect(screen.getByText(/self-reported by your middleware/i)).toBeTruthy()
+  })
+
+  it('renders paths as plain text when there is no onNavigate, even with an entityId', async () => {
+    render(<AiVisibilityTab />)
+    const cited = await screen.findByRole('table', { name: /top cited pages/i })
+    expect(within(cited).queryByRole('button')).toBeNull()
+    expect(within(cited).getByText('/pricing')).toBeTruthy()
+  })
+
+  it('switching the window refetches', async () => {
+    render(<AiVisibilityTab />)
+    await screen.findByRole('table', { name: /crawlers/i })
+    const group = screen.getByRole('group', { name: /^window$/i })
+    const seven = within(group).getByRole('button', { name: /7 days/i })
+    expect(seven.getAttribute('aria-pressed')).toBe('false')
+    expect(
+      within(group)
+        .getByRole('button', { name: /28 days/i })
+        .getAttribute('aria-pressed'),
+    ).toBe('true')
+    fireEvent.click(seven)
+    await waitFor(() => expect(fetchSeoGeo).toHaveBeenLastCalledWith(7))
+    expect(seven.getAttribute('aria-pressed')).toBe('true')
+  })
+
+  it('keeps the clicked window button focused and enabled while the refetch is in flight', async () => {
+    render(<AiVisibilityTab />)
+    await screen.findByRole('table', { name: /crawlers/i })
+    // Hold the second request open so we can inspect the loading state.
+    let release: (() => void) | undefined
+    fetchSeoGeo.mockImplementationOnce(
+      () =>
+        new Promise<SeoGeoReport>((resolve) => {
+          release = () => resolve(report())
+        }),
+    )
+    const seven = screen.getByRole('button', { name: /7 days/i })
+    seven.focus()
+    fireEvent.click(seven)
+    await waitFor(() => expect(fetchSeoGeo).toHaveBeenLastCalledWith(7))
+    expect((seven as HTMLButtonElement).disabled).toBe(false)
+    expect(document.activeElement).toBe(seven)
+    release?.()
+    await screen.findByRole('table', { name: /crawlers/i })
+  })
+
+  it('exposes the null-baseline dash to assistive tech, not only via title', async () => {
+    render(<AiVisibilityTab />)
+    const crawlers = await screen.findByRole('table', { name: /crawlers/i })
+    expect(within(crawlers).getAllByText('No full prior window yet').length).toBeGreaterThan(0)
+    expect(screen.getByText(/first seen/i)).toBeTruthy()
+    expect(screen.queryByText(/collecting since/i)).toBeNull()
+  })
+
+  it('shows the disabled state with a settings button (disabledReason: settings)', async () => {
+    fetchSeoGeo.mockResolvedValue(
+      report({ enabled: false, disabledReason: 'settings', firstSeenAt: null, ...EMPTY_WINDOW }),
+    )
+    const onNavigate = vi.fn()
+    render(<AiVisibilityTab onNavigate={onNavigate} />)
+    await screen.findByText(/measurement is off/i)
+    // The header (window switch + Refresh) stays available in every state.
+    expect(screen.getByRole('button', { name: /refresh/i })).toBeTruthy()
+    fireEvent.click(screen.getByRole('button', { name: /open seo settings/i }))
+    expect(onNavigate).toHaveBeenCalledWith('/settings?tab=seo')
+  })
+
+  it('falls back to the settings copy when enabled:false carries no disabledReason (older core)', async () => {
+    fetchSeoGeo.mockResolvedValue(report({ enabled: false, firstSeenAt: null, ...EMPTY_WINDOW }))
+    render(<AiVisibilityTab onNavigate={vi.fn()} />)
+    await screen.findByText(/measurement is off/i)
+    expect(screen.getByRole('button', { name: /open seo settings/i })).toBeTruthy()
+  })
+
+  it('shows the not-migrated state without a settings action (disabledReason: unavailable)', async () => {
+    fetchSeoGeo.mockResolvedValue(
+      report({ enabled: false, disabledReason: 'unavailable', firstSeenAt: null, ...EMPTY_WINDOW }),
+    )
+    render(<AiVisibilityTab onNavigate={vi.fn()} />)
+    await screen.findByText(/geo tables not migrated/i)
+    expect(screen.getByText(/prisma migrate deploy/i)).toBeTruthy()
+    expect(screen.getByText(/0018_geo_daily/i)).toBeTruthy()
+    expect(screen.queryByText(/measurement is off/i)).toBeNull()
+    expect(screen.queryByRole('button', { name: /open seo settings/i })).toBeNull()
+    expect(screen.getByRole('button', { name: /refresh/i })).toBeTruthy()
+  })
+
+  it('shows the not-reporting state with a middleware-snippet action when nothing has ever arrived', async () => {
+    fetchSeoGeo.mockResolvedValue(report({ firstSeenAt: null, ...EMPTY_WINDOW }))
+    const onNavigate = vi.fn()
+    render(<AiVisibilityTab onNavigate={onNavigate} />)
+    await screen.findByText(/site middleware is not reporting yet/i)
+    expect(screen.queryByRole('table')).toBeNull()
+    fireEvent.click(screen.getByRole('button', { name: /show middleware snippet/i }))
+    expect(onNavigate).toHaveBeenCalledWith('/settings?tab=seo')
+  })
+
+  it('omits the middleware-snippet action when there is no navigator', async () => {
+    fetchSeoGeo.mockResolvedValue(report({ firstSeenAt: null, ...EMPTY_WINDOW }))
+    render(<AiVisibilityTab />)
+    await screen.findByText(/site middleware is not reporting yet/i)
+    expect(screen.queryByRole('button', { name: /show middleware snippet/i })).toBeNull()
+  })
+
+  it('shows an empty state when reporting but the window is empty', async () => {
+    fetchSeoGeo.mockResolvedValue(report(EMPTY_WINDOW))
+    render(<AiVisibilityTab />)
+    await screen.findByText(/no ai crawler or referral activity in this window/i)
+    expect(screen.queryByRole('table')).toBeNull()
+  })
+
+  it('shows an error state with retry', async () => {
+    fetchSeoGeo.mockRejectedValueOnce(new Error('boom'))
+    render(<AiVisibilityTab />)
+    const alert = await screen.findByRole('alert')
+    expect(within(alert).getByText('boom')).toBeTruthy()
+    fireEvent.click(screen.getByRole('button', { name: /retry/i }))
+    await screen.findByRole('table', { name: /crawlers/i })
+    expect(fetchSeoGeo).toHaveBeenCalledTimes(2)
+  })
+})

package/src/__tests__/views/seo-geo-settings-card.render.test.tsx

@@ -0,0 +1,253 @@
+// @vitest-environment happy-dom
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { fireEvent, render, screen, waitFor } from '@testing-library/react'
+
+type Settings = { enabled: boolean; retentionDays: number }
+type UpdateResult = { ok: boolean; error?: string }
+
+let current: Settings = { enabled: true, retentionDays: 90 }
+/** When set, the next PUT waits on this so a test can observe the in-flight state. */
+let putGate: Promise<void> | null = null
+
+function deferred(): { promise: Promise<void>; resolve: () => void } {
+  let resolve!: () => void
+  const promise = new Promise<void>((r) => {
+    resolve = r
+  })
+  return { promise, resolve }
+}
+
+async function defaultUpdate(patch: Partial<Settings>): Promise<UpdateResult> {
+  if (putGate) await putGate
+  current = { ...current, ...patch }
+  return { ok: true }
+}
+const fetchGeoSettings = vi.fn(async (): Promise<Settings | null> => ({ ...current }))
+const updateGeoSettings = vi.fn(defaultUpdate)
+vi.mock('../../lib/seo-service.js', () => ({
+  SEO_GEO_RETENTION: { min: 7, max: 365 },
+  fetchGeoSettings: () => fetchGeoSettings(),
+  updateGeoSettings: (p: Partial<Settings>) => updateGeoSettings(p),
+}))
+const toastSuccess = vi.fn()
+const toastError = vi.fn()
+vi.mock('sonner', () => ({
+  toast: {
+    success: (...a: unknown[]) => toastSuccess(...a),
+    error: (...a: unknown[]) => toastError(...a),
+    warning: vi.fn(),
+    info: vi.fn(),
+  },
+}))
+
+const { SeoGeoSettingsCard } = await import('../../views/settings/SeoGeoSettingsCard.js')
+
+const SWITCH = /record ai crawler and referral activity/i
+const RETENTION = /retention \(days\)/i
+
+beforeEach(() => {
+  current = { enabled: true, retentionDays: 90 }
+  putGate = null
+  fetchGeoSettings.mockClear()
+  fetchGeoSettings.mockImplementation(async () => ({ ...current }))
+  updateGeoSettings.mockClear()
+  updateGeoSettings.mockImplementation(defaultUpdate)
+  toastSuccess.mockClear()
+  toastError.mockClear()
+})
+
+describe('SeoGeoSettingsCard', () => {
+  it('renders the toggle, retention, and both middleware snippets', async () => {
+    render(<SeoGeoSettingsCard canEdit />)
+    const toggle = await screen.findByRole('switch', { name: SWITCH })
+    expect(toggle.getAttribute('aria-checked')).toBe('true')
+    expect((screen.getByLabelText(RETENTION) as HTMLInputElement).value).toBe('90')
+    expect(screen.getByText(/observeGeoTraffic\(request/)).toBeTruthy()
+    expect(screen.getByText(/createAstroRedirectMiddleware/)).toBeTruthy()
+    // Scrollable snippets are focusable and named so keyboard users can scroll them.
+    for (const name of ['Next.js middleware snippet', 'Astro middleware snippet']) {
+      const pre = screen.getByLabelText(name)
+      expect(pre.tagName).toBe('PRE')
+      expect(pre.getAttribute('tabindex')).toBe('0')
+    }
+    // The kill-switch consequences are spelled out in the card copy.
+    const card = screen.getByRole('region', { name: 'AI visibility' })
+    expect(card.textContent ?? '').toMatch(/drops incoming beacons/i)
+    expect(card.textContent ?? '').toMatch(/AI visibility tab/i)
+    // This card takes no `onNavigate`, so it must not link anywhere.
+    expect(card.querySelector('a')).toBeNull()
+  })
+
+  it('toggling PUTs { enabled: false }, reloads, and reflects the server state', async () => {
+    render(<SeoGeoSettingsCard canEdit />)
+    fireEvent.click(await screen.findByRole('switch', { name: SWITCH }))
+    await waitFor(() => expect(updateGeoSettings).toHaveBeenCalledWith({ enabled: false }))
+    await waitFor(() => expect(fetchGeoSettings).toHaveBeenCalledTimes(2))
+    await waitFor(() =>
+      expect(screen.getByRole('switch', { name: SWITCH }).getAttribute('aria-checked')).toBe(
+        'false',
+      ),
+    )
+    expect(toastSuccess).toHaveBeenCalledWith('AI visibility measurement disabled')
+  })
+
+  it('marks the card busy while a save is in flight and keeps the toggle focused', async () => {
+    const gate = deferred()
+    putGate = gate.promise
+    render(<SeoGeoSettingsCard canEdit />)
+    const toggle = await screen.findByRole('switch', { name: SWITCH })
+    const card = screen.getByRole('region', { name: 'AI visibility' })
+    toggle.focus()
+    fireEvent.click(toggle)
+    await waitFor(() => expect(card.getAttribute('aria-busy')).toBe('true'))
+    expect((toggle as HTMLButtonElement).disabled).toBe(false)
+    expect(document.activeElement).toBe(toggle)
+    gate.resolve()
+    await waitFor(() => expect(card.getAttribute('aria-busy')).toBeNull())
+  })
+
+  it('surfaces a failed toggle PUT as a toast and keeps the previous state', async () => {
+    updateGeoSettings.mockResolvedValueOnce({ ok: false, error: 'enabled must be a boolean' })
+    render(<SeoGeoSettingsCard canEdit />)
+    fireEvent.click(await screen.findByRole('switch', { name: SWITCH }))
+    await waitFor(() => expect(toastError).toHaveBeenCalledWith('enabled must be a boolean'))
+    expect(screen.getByRole('switch', { name: SWITCH }).getAttribute('aria-checked')).toBe('true')
+    expect(toastSuccess).not.toHaveBeenCalled()
+    expect(fetchGeoSettings).toHaveBeenCalledTimes(1)
+  })
+
+  it('clamps retention to 7–365 and commits on blur', async () => {
+    render(<SeoGeoSettingsCard canEdit />)
+    const input = (await screen.findByLabelText(RETENTION)) as HTMLInputElement
+    fireEvent.change(input, { target: { value: '1000' } })
+    fireEvent.blur(input)
+    await waitFor(() => expect(updateGeoSettings).toHaveBeenCalledWith({ retentionDays: 365 }))
+    await waitFor(() => expect(input.value).toBe('365'))
+    expect(toastSuccess).toHaveBeenCalledWith('Retention set to 365 days')
+
+    fireEvent.change(input, { target: { value: '2' } })
+    fireEvent.blur(input)
+    await waitFor(() => expect(updateGeoSettings).toHaveBeenLastCalledWith({ retentionDays: 7 }))
+    await waitFor(() => expect(input.value).toBe('7'))
+  })
+
+  it('commits retention on Enter', async () => {
+    render(<SeoGeoSettingsCard canEdit />)
+    const input = (await screen.findByLabelText(RETENTION)) as HTMLInputElement
+    // Enter commits by blurring the (focused) input, so the blur path is the
+    // single commit point and a following real blur cannot double-PUT.
+    input.focus()
+    fireEvent.change(input, { target: { value: '30' } })
+    fireEvent.keyDown(input, { key: 'Enter' })
+    await waitFor(() => expect(updateGeoSettings).toHaveBeenCalledWith({ retentionDays: 30 }))
+    expect(updateGeoSettings).toHaveBeenCalledTimes(1)
+  })
+
+  it('does not PUT when retention is blurred unchanged', async () => {
+    render(<SeoGeoSettingsCard canEdit />)
+    const input = (await screen.findByLabelText(RETENTION)) as HTMLInputElement
+    fireEvent.blur(input)
+    fireEvent.change(input, { target: { value: '90' } })
+    fireEvent.blur(input)
+    expect(updateGeoSettings).not.toHaveBeenCalled()
+    expect(input.value).toBe('90')
+  })
+
+  it('shows an inline error for a non-numeric retention instead of a toast or a PUT', async () => {
+    render(<SeoGeoSettingsCard canEdit />)
+    const input = (await screen.findByLabelText(RETENTION)) as HTMLInputElement
+    fireEvent.change(input, { target: { value: '' } })
+    fireEvent.blur(input)
+    const error = await screen.findByText(/whole number of days/i)
+    expect(input.getAttribute('aria-invalid')).toBe('true')
+    expect(input.getAttribute('aria-describedby') ?? '').toContain(error.id)
+    expect(updateGeoSettings).not.toHaveBeenCalled()
+    expect(toastError).not.toHaveBeenCalled()
+    // Typing again clears the error; a valid commit then lands.
+    fireEvent.change(input, { target: { value: '14' } })
+    expect(input.getAttribute('aria-invalid')).toBeNull()
+    fireEvent.blur(input)
+    await waitFor(() => expect(updateGeoSettings).toHaveBeenCalledWith({ retentionDays: 14 }))
+  })
+
+  it('rejects a fractional retention with the inline error and no PUT', async () => {
+    render(<SeoGeoSettingsCard canEdit />)
+    const input = (await screen.findByLabelText(RETENTION)) as HTMLInputElement
+    fireEvent.change(input, { target: { value: '7.5' } })
+    fireEvent.blur(input)
+    await screen.findByText(/whole number of days/i)
+    expect(input.getAttribute('aria-invalid')).toBe('true')
+    expect(input.value).toBe('7.5')
+    expect(updateGeoSettings).not.toHaveBeenCalled()
+    expect(toastError).not.toHaveBeenCalled()
+  })
+
+  it('a failed second queued commit reverts to the first commit’s confirmed value', async () => {
+    // A: 90→30 is held in flight; B: →60 is blurred behind it and fails only
+    // after A's result has rendered. The revert must land on 30 (what the
+    // server holds), not the 90 that B's commit closed over.
+    const gateA = deferred()
+    const gateB = deferred()
+    updateGeoSettings.mockImplementation(async (patch) => {
+      if (updateGeoSettings.mock.calls.length === 1) {
+        await gateA.promise
+        current = { ...current, ...patch }
+        return { ok: true }
+      }
+      await gateB.promise
+      return { ok: false, error: 'nope' }
+    })
+    render(<SeoGeoSettingsCard canEdit />)
+    const input = (await screen.findByLabelText(RETENTION)) as HTMLInputElement
+    fireEvent.change(input, { target: { value: '30' } })
+    fireEvent.blur(input)
+    await waitFor(() => expect(updateGeoSettings).toHaveBeenCalledWith({ retentionDays: 30 }))
+    fireEvent.change(input, { target: { value: '60' } })
+    fireEvent.blur(input)
+    expect(updateGeoSettings).toHaveBeenCalledTimes(1)
+
+    gateA.resolve()
+    await waitFor(() => expect(toastSuccess).toHaveBeenCalledWith('Retention set to 30 days'))
+    await waitFor(() => expect(input.value).toBe('30'))
+    await waitFor(() => expect(updateGeoSettings).toHaveBeenCalledWith({ retentionDays: 60 }))
+
+    gateB.resolve()
+    await waitFor(() => expect(toastError).toHaveBeenCalledWith('nope'))
+    // Let the failed commit's revert (a microtask after the toast) render
+    // before asserting; a stale-closure revert would now show "90".
+    await new Promise((r) => setTimeout(r, 50))
+    expect(input.value).toBe('30')
+    expect(toastSuccess).toHaveBeenCalledTimes(1)
+  })
+
+  it('reverts retention to the last saved value when its PUT fails', async () => {
+    updateGeoSettings.mockResolvedValueOnce({ ok: false, error: 'nope' })
+    render(<SeoGeoSettingsCard canEdit />)
+    const input = (await screen.findByLabelText(RETENTION)) as HTMLInputElement
+    fireEvent.change(input, { target: { value: '1000' } })
+    fireEvent.blur(input)
+    await waitFor(() => expect(updateGeoSettings).toHaveBeenCalledWith({ retentionDays: 365 }))
+    await waitFor(() => expect(toastError).toHaveBeenCalledWith('nope'))
+    await waitFor(() => expect(input.value).toBe('90'))
+    expect(toastSuccess).not.toHaveBeenCalled()
+  })
+
+  it('disables controls without edit rights', async () => {
+    render(<SeoGeoSettingsCard canEdit={false} />)
+    const toggle = (await screen.findByRole('switch', { name: SWITCH })) as HTMLButtonElement
+    expect(toggle.disabled).toBe(true)
+    expect((screen.getByLabelText(RETENTION) as HTMLInputElement).disabled).toBe(true)
+    // Read-only users still see the setup snippets.
+    expect(screen.getByText(/observeGeoTraffic\(request/)).toBeTruthy()
+  })
+
+  it('shows an error state with Retry when settings fail to load', async () => {
+    fetchGeoSettings.mockResolvedValueOnce(null)
+    render(<SeoGeoSettingsCard canEdit />)
+    const retry = await screen.findByRole('button', { name: /retry/i })
+    expect(screen.getByRole('alert').textContent ?? '').toMatch(/AI visibility settings/i)
+    fireEvent.click(retry)
+    await screen.findByRole('switch', { name: SWITCH })
+    expect(fetchGeoSettings).toHaveBeenCalledTimes(2)
+  })
+})