@prenta/admin 0.92.0 → 0.93.0

package/src/__tests__/components/reflow-meter.render.test.tsx

@@ -0,0 +1,144 @@
+// @vitest-environment happy-dom
+import { describe, expect, it, vi } from 'vitest'
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { ReflowMeter } from '../../components/ReflowMeter.js'
+import type { ReflowGuardResult, ReflowRow } from '../../hooks/useReflowGuard.js'
+import { BREAKPOINTS } from '../../lib/breakpoints.js'
+
+function rows(overrides: Partial<Record<string, Partial<ReflowRow>>> = {}): ReflowRow[] {
+  return BREAKPOINTS.map((bp) => {
+    const o = overrides[bp.id] ?? {}
+    const lines = o.lines ?? 2
+    const was = o.was ?? 2
+    return { id: bp.id, lines, was, diff: lines - was, state: o.state ?? 'same' }
+  })
+}
+
+function guard(partial: Partial<ReflowGuardResult> = {}): ReflowGuardResult {
+  const r = partial.rows ?? rows()
+  return {
+    rows: r,
+    grown: partial.grown ?? r.filter((x) => x.diff > 0),
+    worst: partial.worst ?? null,
+    delta: partial.delta ?? 0,
+    ...partial,
+  }
+}
+
+describe('ReflowMeter', () => {
+  it('reports the line count for the breakpoint being viewed, not the worst one', () => {
+    // "lines here" has to mean the canvas the editor is actually looking at.
+    // Showing the worst breakpoint's count under a canvas rendering a different
+    // one makes the editor mistrust both numbers.
+    const { container } = render(
+      <ReflowMeter
+        guard={guard({ rows: rows({ mobile: { lines: 5 }, laptop: { lines: 2 } }) })}
+        length={64}
+        device="laptop"
+        onProof={() => {}}
+      />,
+    )
+    const readout = container.querySelector('span')!.textContent!.replace(/\s+/g, ' ')
+    expect(readout).toContain('2 lines here')
+    expect(readout).not.toContain('5 lines here')
+    cleanup()
+  })
+
+  it('states the character delta with its direction', () => {
+    render(
+      <ReflowMeter guard={guard({ delta: 12 })} length={80} device="wide" onProof={() => {}} />,
+    )
+    expect(screen.getByText('(+12)')).toBeTruthy()
+    cleanup()
+
+    render(
+      <ReflowMeter guard={guard({ delta: -9 })} length={40} device="wide" onProof={() => {}} />,
+    )
+    expect(screen.getByText('(-9)')).toBeTruthy()
+    cleanup()
+  })
+
+  it('names the line count and its published value on every dot', () => {
+    // Colour alone must not carry the finding. Each dot's accessible name says
+    // what it measured and what it was, so the whole readout is reachable
+    // without seeing the tones.
+    render(
+      <ReflowMeter
+        guard={guard({
+          rows: rows({ mobile: { lines: 4, was: 2, state: 'grew-badly' } }),
+          worst: 'mobile',
+        })}
+        length={64}
+        device="wide"
+        onProof={() => {}}
+      />,
+    )
+    const dot = screen.getByRole('button', { name: /^Mobile: 4 lines/ })
+    expect(dot.textContent).toContain('was 2 when published')
+    // The dot and the alert's proof button are distinguishable by name — two
+    // controls reading "Proof on Mobile" in one region are the same control to
+    // anyone navigating by voice or screen reader.
+    expect(screen.getByRole('button', { name: 'Proof on Mobile' })).not.toBe(dot)
+    cleanup()
+  })
+
+  it('takes the canvas to the breakpoint a dot names', () => {
+    const onProof = vi.fn()
+    render(
+      <ReflowMeter
+        guard={guard({ rows: rows({ mobile: { lines: 4, was: 2, state: 'grew-badly' } }) })}
+        length={64}
+        device="wide"
+        onProof={onProof}
+      />,
+    )
+    fireEvent.click(screen.getByRole('button', { name: /^Mobile: 4 lines/ }))
+    expect(onProof).toHaveBeenCalledWith('mobile')
+    cleanup()
+  })
+
+  it('stays silent when nothing grew', () => {
+    // The alert is the interrupting element. It must appear only when wrapping
+    // actually changed, or editors learn to scroll past it.
+    render(<ReflowMeter guard={guard()} length={40} device="wide" onProof={() => {}} />)
+    expect(screen.queryByText(/Wrapping changed/)).toBeNull()
+    cleanup()
+  })
+
+  it('says "every breakpoint" rather than listing all six', () => {
+    const all = rows(
+      Object.fromEntries(BREAKPOINTS.map((b) => [b.id, { lines: 3, was: 2, state: 'grew' }])),
+    )
+    render(
+      <ReflowMeter
+        guard={guard({ rows: all, worst: 'mobile' })}
+        length={90}
+        device="wide"
+        onProof={() => {}}
+      />,
+    )
+    expect(screen.getByText('every breakpoint')).toBeTruthy()
+    cleanup()
+  })
+
+  it('names the breakpoints while the list is short enough to read', () => {
+    render(
+      <ReflowMeter
+        guard={guard({
+          rows: rows({
+            mobile: { lines: 4, was: 2, state: 'grew-badly' },
+            tabletP: { lines: 3, was: 2, state: 'grew' },
+          }),
+          worst: 'mobile',
+        })}
+        length={90}
+        device="wide"
+        onProof={() => {}}
+      />,
+    )
+    expect(screen.getByText('Tablet Portrait, Mobile')).toBeTruthy()
+    // The proof button names the one worth looking at, not the list.
+    expect(screen.getByRole('button', { name: 'Proof on Mobile' })).toBeTruthy()
+    cleanup()
+  })
+})

package/src/__tests__/components/seo-char-count.test.tsx

@@ -6,22 +6,42 @@ import { SeoCharCount } from '../../components/seo/SeoCharCount.js'
 describe('SeoCharCount', () => {
   it('shows a neutral empty state', () => {
     render(<SeoCharCount value="" min={30} max={60} />)
-    expect(screen.getByText('0/60')).toBeTruthy()
+    expect(screen.getByText(/0 \/ 60 characters/)).toBeTruthy()
   })
 
   it('marks a value within the ideal range as good', () => {
     render(<SeoCharCount value={'x'.repeat(40)} min={30} max={60} />)
-    expect(screen.getByText(/40\/60 · good/)).toBeTruthy()
+    expect(screen.getByText(/40 \/ 60 characters · good/)).toBeTruthy()
   })
 
-  it('flags a value over the max as too long (destructive)', () => {
+  it('says the tail will be truncated rather than just "too long"', () => {
+    // Over and under are different problems. "Will be truncated" tells the
+    // editor the words are written but nobody will read them.
     const { container } = render(<SeoCharCount value={'x'.repeat(70)} min={30} max={60} />)
-    expect(screen.getByText(/70\/60 · too long/)).toBeTruthy()
+    expect(screen.getByText(/70 \/ 60 characters · will be truncated/)).toBeTruthy()
     expect(container.querySelector('.text-destructive')).toBeTruthy()
   })
 
-  it('hints to aim for the range when below min', () => {
+  it('says too short rather than restating the target range', () => {
+    // "Aim for 30–60" describes the goal without saying which way to edit.
     render(<SeoCharCount value={'x'.repeat(10)} min={30} max={60} />)
-    expect(screen.getByText(/aim for 30–60/)).toBeTruthy()
+    expect(screen.getByText(/10 \/ 60 characters · too short/)).toBeTruthy()
+  })
+
+  it('caps the meter at full instead of overflowing', () => {
+    // A bar that kept growing past the maximum would imply more is better.
+    const { container } = render(<SeoCharCount value={'x'.repeat(200)} min={30} max={60} />)
+    const fill = container.querySelector('span[aria-hidden] > span') as HTMLElement | null
+    expect(fill?.style.width).toBe('100%')
+  })
+
+  it('has no short or good state for a cap-only field', () => {
+    // Without a minimum there is no target to hit, only a ceiling not to cross.
+    // The count is split across JSX text nodes, so match on the rendered text.
+    const { container } = render(<SeoCharCount value={'x'.repeat(5)} max={200} />)
+    const text = container.textContent ?? ''
+    expect(text).toContain('5 / 200 characters')
+    expect(text).not.toContain('too short')
+    expect(text).not.toContain('good')
   })
 })

package/src/__tests__/components/serp-preview.render.test.tsx

@@ -0,0 +1,32 @@
+// @vitest-environment happy-dom
+import { describe, expect, it } from 'vitest'
+import { render, screen } from '@testing-library/react'
+import { SerpPreview } from '../../components/seo/SerpPreview.js'
+
+describe('SerpPreview', () => {
+  it('shows url, title and description as a searcher sees them', () => {
+    render(
+      <SerpPreview
+        title="Headless CMS for modern teams"
+        url="https://example.com/about"
+        description="Prenta gives developers an API-first architecture."
+      />,
+    )
+    expect(screen.getByText('https://example.com/about')).toBeTruthy()
+    expect(screen.getByText('Headless CMS for modern teams')).toBeTruthy()
+  })
+
+  it('renders the title in the search-result blue, not the brand accent', () => {
+    // The card's job is to look like the thing being previewed. Painted in the
+    // brand colour it previews the admin instead.
+    render(<SerpPreview title="T" url="u" description="d" />)
+    // Assert on the class list rather than a CSS selector — escaping `[`, `#`
+    // and `]` in a selector is brittle and fails for the wrong reason.
+    expect(screen.getByText('T').className).toContain('#1a0dab')
+  })
+
+  it('says what a missing description means rather than rendering blank', () => {
+    render(<SerpPreview title="T" url="u" description="" />)
+    expect(screen.getByText(/Search engines will improvise one/i)).toBeTruthy()
+  })
+})

package/src/__tests__/lib/breakpoints.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest'
+import {
+  BREAKPOINTS,
+  DEFAULT_BREAKPOINT,
+  breakpointsInGroup,
+  coerceBreakpointId,
+  fitScale,
+  getBreakpoint,
+} from '../../lib/breakpoints.js'
+
+describe('breakpoint presets', () => {
+  it('renders 4K at the CSS width such displays report, not the physical one', () => {
+    // 3840 is the pixel count; 2560 is what a stylesheet sees once DPR is
+    // applied. Rendering at 3840 would put the canvas in a container-query
+    // bucket no real visitor is ever in.
+    expect(getBreakpoint('4k').width).toBe(2560)
+  })
+
+  it('has exactly one preset above the 2000px container-query step', () => {
+    // The canvas's `@container (min-width: 2000px)` branch scales type and
+    // padding up. If no preset exercised it, the branch would be untestable
+    // from the editor.
+    const above = BREAKPOINTS.filter((b) => b.width >= 2000)
+    expect(above.map((b) => b.id)).toEqual(['4k'])
+  })
+
+  it('covers every container-query step with a distinct width', () => {
+    const widths = BREAKPOINTS.map((b) => b.width)
+    expect(widths).toEqual([2560, 1920, 1440, 1024, 768, 390])
+    expect(new Set(widths).size).toBe(widths.length)
+  })
+
+  it('groups presets in menu order', () => {
+    expect(breakpointsInGroup('DESKTOP').map((b) => b.id)).toEqual(['4k', 'wide', 'laptop'])
+    expect(breakpointsInGroup('TABLET').map((b) => b.id)).toEqual(['tabletL', 'tabletP'])
+    expect(breakpointsInGroup('MOBILE').map((b) => b.id)).toEqual(['mobile'])
+  })
+
+  it('falls back to the default for an unknown id', () => {
+    expect(getBreakpoint('nope' as never).id).toBe(DEFAULT_BREAKPOINT)
+  })
+})
+
+describe('coerceBreakpointId', () => {
+  it('maps retired v0.92 ids onto their equivalent width', () => {
+    // `1080p` was 1440px and `tablet` was 768px. Mapping by width keeps an
+    // editor that was open across the upgrade on the same preview.
+    expect(getBreakpoint(coerceBreakpointId('1080p')).width).toBe(1440)
+    expect(getBreakpoint(coerceBreakpointId('tablet')).width).toBe(768)
+  })
+
+  it('passes through current ids and defaults anything else', () => {
+    expect(coerceBreakpointId('tabletL')).toBe('tabletL')
+    expect(coerceBreakpointId('garbage')).toBe(DEFAULT_BREAKPOINT)
+    expect(coerceBreakpointId(undefined)).toBe(DEFAULT_BREAKPOINT)
+    expect(coerceBreakpointId(1920)).toBe(DEFAULT_BREAKPOINT)
+  })
+})
+
+describe('fitScale', () => {
+  it('shrinks a wide breakpoint to the available width', () => {
+    expect(fitScale(800, 1600)).toBe(0.5)
+  })
+
+  it('never scales above 1', () => {
+    // A 390px mobile canvas stretched across a 1200px column would render text
+    // at 3x the size a visitor sees — worse than useless as a proof.
+    expect(fitScale(1200, 390)).toBe(1)
+  })
+
+  it('returns 1 at 100% zoom regardless of available width', () => {
+    expect(fitScale(400, 2560, 1)).toBe(1)
+  })
+
+  it('returns 1 rather than 0 or NaN before the first measurement', () => {
+    // The sentinel reads 0 on the very first paint. Propagating that would
+    // produce `scale(0)` and a canvas that measures as zero-height, which then
+    // feeds back into the next measurement.
+    expect(fitScale(0, 1920)).toBe(1)
+    expect(fitScale(Number.NaN, 1920)).toBe(1)
+    expect(fitScale(-10, 1920)).toBe(1)
+    expect(fitScale(800, 0)).toBe(1)
+  })
+})

package/src/__tests__/lib/canvas-edit-chrome.test.ts

@@ -0,0 +1,56 @@
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import {
+  CANVAS_EDIT_TIP_STORAGE_KEY,
+  dismissCanvasEditTip,
+  injectPreviewEditChrome,
+  isCanvasEditTipDismissed,
+  PREVIEW_EDITABLE_FIELD_CHROME_CSS,
+} from '../../lib/canvas-edit-chrome.js'
+
+// happy-dom localStorage is non-functional in this Node setup — stub a Map.
+const storage = new Map<string, string>()
+vi.stubGlobal('localStorage', {
+  getItem: (key: string) => storage.get(key) ?? null,
+  setItem: (key: string, value: string) => void storage.set(key, String(value)),
+  removeItem: (key: string) => void storage.delete(key),
+  clear: () => storage.clear(),
+})
+
+describe('canvas-edit-chrome', () => {
+  afterEach(() => {
+    storage.clear()
+  })
+
+  it('tracks tip dismiss in localStorage', () => {
+    expect(isCanvasEditTipDismissed()).toBe(false)
+    dismissCanvasEditTip()
+    expect(isCanvasEditTipDismissed()).toBe(true)
+    expect(localStorage.getItem(CANVAS_EDIT_TIP_STORAGE_KEY)).toBe('1')
+  })
+
+  it('injects editable field chrome into a same-origin iframe document', () => {
+    const iframe = document.createElement('iframe')
+    document.body.appendChild(iframe)
+    const doc = iframe.contentDocument
+    expect(doc).toBeTruthy()
+    if (!doc) return
+
+    expect(injectPreviewEditChrome(iframe)).toBe(true)
+    const style = doc.head.querySelector('style[data-prenta-edit-chrome]')
+    expect(style?.textContent).toContain('[data-cms-field]')
+    expect(style?.textContent).toContain('data-cms-field-kind')
+    expect(PREVIEW_EDITABLE_FIELD_CHROME_CSS.length).toBeGreaterThan(0)
+    expect(doc.documentElement.getAttribute('data-prenta-preview-editing')).toBe('true')
+
+    // Refresh is idempotent — one style tag.
+    expect(injectPreviewEditChrome(iframe)).toBe(true)
+    expect(doc.head.querySelectorAll('style[data-prenta-edit-chrome]')).toHaveLength(1)
+
+    iframe.remove()
+  })
+
+  it('returns false when iframe has no contentDocument', () => {
+    expect(injectPreviewEditChrome(null)).toBe(false)
+  })
+})

package/src/__tests__/lib/media-format.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from 'vitest'
+import {
+  assetWash,
+  displayName,
+  formatBadge,
+  ratioLabel,
+  CROP_RATIO,
+} from '../../lib/media-format.js'
+
+describe('ratioLabel', () => {
+  it('names the ratios an editor recognises', () => {
+    expect(ratioLabel(1920, 1080)).toBe('16:9')
+    expect(ratioLabel(2400, 1600)).toBe('3:2')
+    expect(ratioLabel(1200, 630)).toBe('1.91:1')
+    expect(ratioLabel(800, 800)).toBe('1:1')
+    expect(ratioLabel(1080, 1350)).toBe('4:5')
+    expect(ratioLabel(1080, 1920)).toBe('9:16')
+  })
+
+  it('tolerates an off-by-a-pixel scan', () => {
+    // 2401×1600 is 1.5006, not 1.5. An editor should still read "3:2" rather
+    // than "1.50:1" — the tolerance is what makes the label useful on real
+    // assets instead of only on synthetic ones.
+    expect(ratioLabel(2401, 1600)).toBe('3:2')
+  })
+
+  it('reports the number when nothing named is close', () => {
+    expect(ratioLabel(1000, 300)).toBe('3.33:1')
+  })
+
+  it('says nothing when dimensions are unknown', () => {
+    // The library does not always carry width/height. Inventing "1.00:1" would
+    // be a confident wrong answer about the one thing this label exists for.
+    expect(ratioLabel(undefined, undefined)).toBeNull()
+    expect(ratioLabel(0, 100)).toBeNull()
+    expect(ratioLabel(100, 0)).toBeNull()
+  })
+})
+
+describe('formatBadge', () => {
+  it('uses the file extension', () => {
+    expect(formatBadge('team-offsite.jpg')).toBe('JPG')
+    expect(formatBadge('/uploads/dashboard-hero.PNG')).toBe('PNG')
+  })
+
+  it('ignores a query string', () => {
+    expect(formatBadge('https://cdn.example.com/a/b.webp?token=abc123&x=1')).toBe('WEBP')
+  })
+
+  it('falls back to the MIME subtype when there is no extension', () => {
+    // Signed CDN links and upload routes often have no extension at all.
+    expect(formatBadge('https://cdn.example.com/asset/9f3a2', 'image/avif')).toBe('AVIF')
+    expect(formatBadge('https://cdn.example.com/asset/9f3a2', 'image/svg+xml')).toBe('SVG')
+  })
+
+  it('never renders an empty chip', () => {
+    expect(formatBadge('')).toBe('FILE')
+    expect(formatBadge('no-extension-here')).toBe('FILE')
+  })
+})
+
+describe('displayName', () => {
+  it('shows the filename, not the path or the token', () => {
+    expect(displayName('https://cdn.example.com/media/team-offsite-2026.jpg?sig=xyz')).toBe(
+      'team-offsite-2026.jpg',
+    )
+  })
+
+  it('decodes an escaped name', () => {
+    expect(displayName('/media/team%20offsite.jpg')).toBe('team offsite.jpg')
+  })
+})
+
+describe('assetWash', () => {
+  it('gives the same asset the same colour every time', () => {
+    // Recognising a thumbnail depends on it not changing between renders.
+    expect(assetWash('hero.jpg')).toBe(assetWash('hero.jpg'))
+    expect(assetWash('hero.jpg')).not.toBe(assetWash('other.jpg'))
+  })
+})
+
+describe('CROP_RATIO', () => {
+  it('describes the crop the template renders, not the asset', () => {
+    // Showing the asset's own ratio would tell an editor their portrait photo
+    // is fine, then crop its subject out on the page.
+    expect(CROP_RATIO.section).toBe('16 / 10')
+    expect(CROP_RATIO.social).toBe('1.91 / 1')
+  })
+})

package/src/__tests__/lib/page-audit-input.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, it } from 'vitest'
+import { auditPage } from '@prenta/core/seo/page-audit'
+import type { PageSection } from '@prenta/core/page-sections'
+import { buildPageAuditInput, metaFromRecord } from '../../lib/page-audit-input.js'
+import type { SeoContentRecord } from '../../lib/seo-service.js'
+
+/**
+ * Two callers build the audit — the page editor from the saved record (so the
+ * header chip has a number from first paint) and the SEO pane from live form
+ * state (so it moves as you type). They must produce the same score for the
+ * same data, or the editor is back to showing numbers that disagree.
+ */
+
+const sections = [
+  {
+    id: 's1',
+    sectionType: 'hero',
+    name: 'Hero',
+    visible: true,
+    content: {
+      heading: 'Headless CMS for modern teams',
+      body: 'Prenta gives developers an API-first architecture and editors a design-owned authoring surface, so content ships without layout drift.',
+      imageAlt: 'A described image',
+    },
+    settings: {},
+  },
+] as unknown as PageSection[]
+
+const record = {
+  title: 'About Us',
+  siteName: 'Prenta',
+  titleTemplate: '%page% | %site%',
+  url: '/about',
+  metaTitlePage: 'Headless CMS for teams',
+  metaDescription:
+    'Prenta gives developers an API-first architecture and editors a design-owned authoring surface for shipping content at scale.',
+  focusKeyword: 'headless cms',
+  structuredDataType: 'WebPage',
+  noindex: false,
+  llmsInclude: 'AUTO',
+  ogImage: null,
+} as unknown as SeoContentRecord
+
+describe('page audit input', () => {
+  it('produces the same score from a record as from equivalent form state', () => {
+    // The page editor's path.
+    const fromRecord = auditPage(
+      buildPageAuditInput({ sections, meta: metaFromRecord(record), slug: 'about', record }),
+    )
+
+    // The SEO pane's path, with the form holding exactly what was saved.
+    const fromForm = auditPage(
+      buildPageAuditInput({
+        sections,
+        meta: {
+          metaTitle: 'Headless CMS for teams',
+          metaDescription: record.metaDescription!,
+          focusKeyword: 'headless cms',
+          structuredDataType: 'WebPage',
+          noindex: false,
+          nosnippet: false,
+          llmsInclude: 'AUTO',
+          hasOgImage: false,
+        },
+        slug: 'about',
+        record,
+      }),
+    )
+
+    expect(fromForm.seo.score).toBe(fromRecord.seo.score)
+    expect(fromForm.geo.score).toBe(fromRecord.geo.score)
+  })
+
+  it('measures the rendered title, not the raw field', () => {
+    // The site template is applied before the length check, so the advice
+    // matches what a searcher sees. Checking the raw field would call a title
+    // "too short" that renders well over the limit once the template lands.
+    const input = buildPageAuditInput({
+      sections,
+      meta: { ...metaFromRecord(record), metaTitle: 'Short' },
+      slug: 'about',
+      record,
+    })
+    expect(input.seo.title).toContain('Prenta')
+    expect(input.seo.title.length).toBeGreaterThan('Short'.length)
+  })
+
+  it('treats a set OG image as unknown, and an absent one as failing', () => {
+    // The record stores a URL with no dimensions, and the check needs width
+    // and ratio — so "an image exists" is not the same as "it passes".
+    const withImage = buildPageAuditInput({
+      sections,
+      meta: { ...metaFromRecord(record), hasOgImage: true },
+      slug: 'about',
+      record,
+    })
+    expect(withImage.seo.ogImage).toBeUndefined()
+
+    const without = buildPageAuditInput({
+      sections,
+      meta: { ...metaFromRecord(record), hasOgImage: false },
+      slug: 'about',
+      record,
+    })
+    expect(without.seo.ogImage).toBeNull()
+  })
+
+  it('distinguishes a removed share image from an unset one', () => {
+    // The share card lets an editor clear the image. An empty string is a
+    // deliberate removal and must fail the check; `undefined` means "an image
+    // exists but its dimensions are unknown here" and must not be scored.
+    const removed = buildPageAuditInput({
+      sections,
+      meta: { ...metaFromRecord(record), hasOgImage: false },
+      slug: 'about',
+      record,
+    })
+    expect(removed.seo.ogImage).toBeNull()
+    expect(auditPage(removed).seo.checks.find((c) => c.id === 'social-image')?.outcome).toBe('fail')
+
+    const chosen = buildPageAuditInput({
+      sections,
+      meta: { ...metaFromRecord(record), hasOgImage: true },
+      slug: 'about',
+      record,
+    })
+    expect(auditPage(chosen).seo.checks.find((c) => c.id === 'social-image')?.outcome).toBe(
+      'not-applicable',
+    )
+  })
+
+  it('reflects an unsaved noindex immediately', () => {
+    // Live form state must be able to gate the score before a save round-trip.
+    const audit = auditPage(
+      buildPageAuditInput({
+        sections,
+        meta: { ...metaFromRecord(record), noindex: true },
+        slug: 'about',
+        record,
+      }),
+    )
+    expect(audit.seo.score).toBeNull()
+  })
+})

package/src/__tests__/lib/page-editor-service.test.ts

@@ -169,6 +169,8 @@ describe('section type registry', () => {
       'text',
       'feature',
       'stats',
+      'badges',
+      'faq',
       'cta',
       'form',
       'article-body',

package/src/__tests__/lib/page-redirect.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest'
+import { pendingSlugChange } from '../../lib/page-redirect.js'
+
+describe('pendingSlugChange', () => {
+  it('reports the move when a live page changes path', () => {
+    expect(pendingSlugChange('/about', '/about-us')).toEqual({ from: '/about', to: '/about-us' })
+  })
+
+  it('stays quiet for a page that has never been live', () => {
+    // Nothing out there points at the old path, so there is nothing to redirect
+    // — and a redirect for a URL that was never public is dead weight in a
+    // table consulted on every request.
+    expect(pendingSlugChange(null, '/about-us')).toBeNull()
+  })
+
+  it('stays quiet when the path has not moved', () => {
+    expect(pendingSlugChange('/about', '/about')).toBeNull()
+    // Trailing whitespace from an input is not a move.
+    expect(pendingSlugChange('/about', '  /about  ')).toBeNull()
+  })
+
+  it('refuses a redirect with an empty side', () => {
+    // A rule from or to nothing is not a redirect; posting one would put a
+    // broken entry in the table rather than fail loudly.
+    expect(pendingSlugChange('', '/about')).toBeNull()
+    expect(pendingSlugChange('/about', '')).toBeNull()
+    expect(pendingSlugChange('/about', '   ')).toBeNull()
+  })
+})