@prenta/admin 0.92.0 → 0.94.0

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()
+  })
+})

package/src/__tests__/lib/rail-width.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from 'vitest'
+import {
+  RAIL_DEFAULT_WIDTH,
+  RAIL_MAX_WIDTH,
+  RAIL_MIN_WIDTH,
+  clampRailWidth,
+  readRailWidth,
+  writeRailWidth,
+} from '../../lib/rail-width.js'
+
+function fakeStorage(initial: Record<string, string> = {}) {
+  const map = new Map(Object.entries(initial))
+  return {
+    getItem: (k: string) => map.get(k) ?? null,
+    setItem: (k: string, v: string) => void map.set(k, v),
+    read: (k: string) => map.get(k) ?? null,
+  }
+}
+
+describe('clampRailWidth', () => {
+  it('holds the rail inside its usable range', () => {
+    expect(clampRailWidth(200)).toBe(RAIL_MIN_WIDTH)
+    expect(clampRailWidth(900)).toBe(RAIL_MAX_WIDTH)
+    expect(clampRailWidth(420)).toBe(420)
+  })
+
+  it('rounds to whole pixels', () => {
+    // Pointer deltas are fractional on scaled displays; a fractional width
+    // makes the rail's border land between device pixels and shimmer.
+    expect(clampRailWidth(420.6)).toBe(421)
+  })
+
+  it('falls back to the default on junk rather than producing NaN width', () => {
+    expect(clampRailWidth(Number.NaN)).toBe(RAIL_DEFAULT_WIDTH)
+    expect(clampRailWidth(Number.POSITIVE_INFINITY)).toBe(RAIL_DEFAULT_WIDTH)
+  })
+})
+
+describe('readRailWidth', () => {
+  it('returns the default when nothing is stored', () => {
+    expect(readRailWidth(fakeStorage())).toBe(RAIL_DEFAULT_WIDTH)
+  })
+
+  it('reads a stored width', () => {
+    expect(readRailWidth(fakeStorage({ 'pb.panelW': '480' }))).toBe(480)
+  })
+
+  it('clamps a stored width that is out of range', () => {
+    // A width persisted before the range changed, or hand-edited in devtools,
+    // must not be able to render an unusable rail.
+    expect(readRailWidth(fakeStorage({ 'pb.panelW': '5000' }))).toBe(RAIL_MAX_WIDTH)
+    expect(readRailWidth(fakeStorage({ 'pb.panelW': '10' }))).toBe(RAIL_MIN_WIDTH)
+  })
+
+  it('survives a non-numeric stored value', () => {
+    expect(readRailWidth(fakeStorage({ 'pb.panelW': 'wide' }))).toBe(RAIL_DEFAULT_WIDTH)
+  })
+
+  it('survives storage that throws', () => {
+    // Safari in private mode throws on getItem. A rail that cannot size itself
+    // must not take down the editor.
+    const hostile = {
+      getItem: () => {
+        throw new Error('SecurityError')
+      },
+    }
+    expect(readRailWidth(hostile)).toBe(RAIL_DEFAULT_WIDTH)
+  })
+})
+
+describe('writeRailWidth', () => {
+  it('persists the clamped value, not the raw one', () => {
+    const store = fakeStorage()
+    writeRailWidth(9000, store)
+    expect(store.read('pb.panelW')).toBe(String(RAIL_MAX_WIDTH))
+  })
+
+  it('swallows a storage failure', () => {
+    const hostile = {
+      setItem: () => {
+        throw new Error('QuotaExceededError')
+      },
+    }
+    expect(() => writeRailWidth(400, hostile)).not.toThrow()
+  })
+})

package/src/__tests__/lib/reflow-baseline.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest'
+import type { PageSection } from '@prenta/core/page-sections'
+import { baselineFieldText, snapshotBaseline } from '../../lib/reflow-baseline.js'
+
+const sections = [
+  {
+    id: 's1',
+    sectionType: 'hero',
+    name: 'Hero',
+    visible: true,
+    content: {
+      heading: 'Ship content without layout drift',
+      body: 'A design-owned authoring surface.',
+      stats: [{ label: 'Uptime', value: '99.9%' }],
+      count: 3,
+    },
+    settings: {},
+  },
+] as unknown as PageSection[]
+
+describe('reflow baseline', () => {
+  it('captures nothing for a page that is not live', () => {
+    // A draft has no published layout to break. An empty snapshot would be
+    // worse than none: it reads as "every field was blank", so every line of
+    // existing copy is reported as newly added.
+    expect(snapshotBaseline(sections, 'DRAFT')).toBeNull()
+    expect(snapshotBaseline(sections, 'SCHEDULED')).toBeNull()
+    expect(snapshotBaseline(sections, 'PUBLISHED')).not.toBeNull()
+  })
+
+  it('is a copy, so later edits to the draft do not move it', () => {
+    // The baseline is what is live. If it aliased the section's content object,
+    // editing the draft would silently drag the baseline along and the guard
+    // would report that nothing ever changed.
+    const baseline = snapshotBaseline(sections, 'PUBLISHED')
+    ;(sections[0]!.content as Record<string, unknown>).heading = 'Edited in the draft'
+
+    expect(baselineFieldText(baseline, 's1', 'heading')).toBe('Ship content without layout drift')
+    // Restore for the remaining cases.
+    ;(sections[0]!.content as Record<string, unknown>).heading = 'Ship content without layout drift'
+  })
+
+  it('resolves repeater paths the renderers emit', () => {
+    const baseline = snapshotBaseline(sections, 'PUBLISHED')
+    expect(baselineFieldText(baseline, 's1', 'stats.0.label')).toBe('Uptime')
+  })
+
+  it('returns undefined for anything that is not baseline text', () => {
+    const baseline = snapshotBaseline(sections, 'PUBLISHED')
+
+    // No snapshot at all.
+    expect(baselineFieldText(null, 's1', 'heading')).toBeUndefined()
+    // Section added since publish.
+    expect(baselineFieldText(baseline, 'brand-new', 'heading')).toBeUndefined()
+    // Field that did not exist.
+    expect(baselineFieldText(baseline, 's1', 'subheading')).toBeUndefined()
+    // Path that runs off the end of a scalar.
+    expect(baselineFieldText(baseline, 's1', 'heading.nope')).toBeUndefined()
+    // Present but not a string — a count has no wrapping to compare.
+    expect(baselineFieldText(baseline, 's1', 'count')).toBeUndefined()
+    // Index past the end of a repeater.
+    expect(baselineFieldText(baseline, 's1', 'stats.7.label')).toBeUndefined()
+  })
+})

package/src/__tests__/lib/reflow-probe.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it } from 'vitest'
+import {
+  linesFromMetrics,
+  reflowSeverity,
+  worstBreakpoint,
+  type FieldLineCount,
+} from '../../lib/reflow-probe.js'
+
+describe('linesFromMetrics', () => {
+  it('divides height by line height', () => {
+    expect(linesFromMetrics(72, 24, 16)).toBe(3)
+  })
+
+  it('rounds rather than floors', () => {
+    // Sub-pixel line heights accumulate; 2.97 lines is three lines on screen,
+    // and flooring would under-report exactly the overflow being guarded.
+    expect(linesFromMetrics(71.3, 24, 16)).toBe(3)
+  })
+
+  it('falls back to a ratio when line-height computes to normal', () => {
+    // `parseFloat('normal')` is NaN — every element that never set a
+    // line-height would otherwise measure as one line forever.
+    expect(linesFromMetrics(60, Number.NaN, 16)).toBe(3)
+  })
+
+  it('never reports zero lines', () => {
+    // An empty field still occupies a line's worth of intent, and zero would
+    // read as "this shrank" against any baseline.
+    expect(linesFromMetrics(0, 24, 16)).toBe(1)
+    expect(linesFromMetrics(0, 0, 0)).toBe(1)
+  })
+})
+
+describe('reflowSeverity', () => {
+  it('flags one extra line as growth and two as bad', () => {
+    expect(reflowSeverity(3, 2)).toBe('grew')
+    expect(reflowSeverity(4, 2)).toBe('grew-badly')
+  })
+
+  it('stays quiet when copy shrinks', () => {
+    // Shorter copy cannot break a layout that already held the longer version.
+    // Flagging it would put a warning on the edit the editor was asked to make.
+    expect(reflowSeverity(1, 3)).toBe('same')
+    expect(reflowSeverity(2, 2)).toBe('same')
+  })
+})
+
+describe('worstBreakpoint', () => {
+  const at = (pairs: Array<[string, number]>): FieldLineCount[] =>
+    pairs.map(([id, lines]) => ({ id, lines }) as FieldLineCount)
+
+  it('picks the biggest jump', () => {
+    const worst = worstBreakpoint(
+      at([
+        ['wide', 3],
+        ['laptop', 5],
+        ['mobile', 4],
+      ]),
+      at([
+        ['wide', 3],
+        ['laptop', 3],
+        ['mobile', 3],
+      ]),
+    )
+    expect(worst).toBe('laptop')
+  })
+
+  it('breaks a tie toward the narrowest width', () => {
+    // The same damage at several sizes is most likely to look broken where
+    // there is least room.
+    const worst = worstBreakpoint(
+      at([
+        ['4k', 4],
+        ['laptop', 4],
+        ['mobile', 4],
+      ]),
+      at([
+        ['4k', 3],
+        ['laptop', 3],
+        ['mobile', 3],
+      ]),
+    )
+    expect(worst).toBe('mobile')
+  })
+
+  it('returns nothing when no breakpoint grew', () => {
+    expect(worstBreakpoint(at([['wide', 2]]), at([['wide', 3]]))).toBeNull()
+  })
+
+  it('ignores breakpoints missing from the baseline', () => {
+    // A baseline captured before a preset existed must not make that preset
+    // look like a regression.
+    expect(worstBreakpoint(at([['4k', 9]]), at([['wide', 1]]))).toBeNull()
+  })
+})