@morphemecms/cms 0.13.0 → 0.14.0-next-20261107093528

package/lib/releaseNotes.test.mjs

@@ -0,0 +1,267 @@
+// Tests for lib/releaseNotes.mjs: checks pending cards and lines, groups them per version, picks a locale's notes, lists
+// installed versions and reads notes and screenshots from a tar.
+// Run: node --test lib/releaseNotes.test.mjs
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  MAX_IMAGE_BYTES,
+  MAX_IMAGE_HEIGHT,
+  webpSize,
+  problemsOf,
+  released,
+  imagePath,
+  notesFor,
+  installedVersions,
+  notesFromTar,
+  imageUrl,
+  imageKey,
+  parseImagePath,
+  withImageUrls,
+} from './releaseNotes.mjs';
+
+const card = (id, overrides = {}) => ({ id, kind: 'card', title: `Title ${id}`, text: `Text ${id}`, ...overrides });
+const line = (id, overrides = {}) => ({ id, kind: 'line', text: `Text ${id}`, ...overrides });
+/** A pending entry: a card has a 1000-byte screenshot of 750×800 px by default, a line none. */
+const entry = (
+  note,
+  imageBytes = note.kind === 'card' ? 1000 : null,
+  imageSize = imageBytes === null ? null : { width: 750, height: 800 },
+) => ({
+  note,
+  imageBytes,
+  imageSize,
+});
+
+/** The first 40 bytes of a WebP: RIFF header, the chunk's name and its start. */
+const webp = (chunk, body) => {
+  const bytes = new Uint8Array(40);
+  bytes.set(Buffer.from('RIFF'), 0);
+  bytes.set(Buffer.from('WEBP'), 8);
+  bytes.set(Buffer.from(chunk), 12);
+  bytes.set(body.bytes, body.at);
+  return bytes;
+};
+
+test('problemsOf is empty when every card and line has its twin, text and screenshot', () => {
+  const pending = {
+    'en-US': { a: entry(card('a')), b: entry(line('b')) },
+    'da-DK': { a: entry(card('a', { title: 'Titel' })), b: entry(line('b')) },
+  };
+  assert.deepEqual(problemsOf(pending), []);
+});
+test('problemsOf names a note missing in a locale', () => {
+  const problems = problemsOf({ 'en-US': { a: entry(card('a')) } });
+  assert.equal(problems.length, 1);
+  assert.match(problems[0], /\ba\b/);
+  assert.match(problems[0], /da-DK/);
+});
+test('problemsOf names a kind that differs between locales', () => {
+  const problems = problemsOf({ 'en-US': { a: entry(card('a')) }, 'da-DK': { a: entry(line('a')) } });
+  assert.equal(problems.length, 1);
+  assert.match(problems[0], /kind/);
+});
+test('problemsOf names a note whose id differs from its file name', () => {
+  const problems = problemsOf({ 'en-US': { a: entry(card('b')) }, 'da-DK': { a: entry(card('a')) } });
+  assert.equal(problems.length, 1);
+  assert.match(problems[0], /\ba\b/);
+  assert.match(problems[0], /en-US/);
+});
+test('problemsOf names a note without a kind, such as the old shape', () => {
+  const old = { id: 'a', title: 'Title', why: 'Why', how: 'How', what: 'What' };
+  const problems = problemsOf({ 'en-US': { a: entry(old, null) }, 'da-DK': { a: entry(old, null) } });
+  assert.equal(problems.length, 2);
+  assert.match(problems[0], /kind/);
+});
+test('problemsOf names a card without a title', () => {
+  const problems = problemsOf({ 'en-US': { a: entry(card('a', { title: ' ' })) }, 'da-DK': { a: entry(card('a')) } });
+  assert.equal(problems.length, 1);
+  assert.match(problems[0], /title/);
+});
+test('problemsOf names a card or a line without text', () => {
+  const problems = problemsOf({ 'en-US': { a: entry(card('a', { text: '' })) }, 'da-DK': { a: entry(card('a')) } });
+  assert.match(problems[0], /text/);
+  const lineProblems = problemsOf({ 'en-US': { b: entry(line('b', { text: '' })) }, 'da-DK': { b: entry(line('b')) } });
+  assert.match(lineProblems[0], /text/);
+});
+test('problemsOf names a card without a screenshot', () => {
+  const problems = problemsOf({ 'en-US': { a: entry(card('a'), null) }, 'da-DK': { a: entry(card('a')) } });
+  assert.equal(problems.length, 1);
+  assert.match(problems[0], /screenshot/);
+});
+test('problemsOf names a screenshot above 200 KB and accepts one of exactly 200 KB', () => {
+  const big = problemsOf({ 'en-US': { a: entry(card('a'), MAX_IMAGE_BYTES + 1) }, 'da-DK': { a: entry(card('a')) } });
+  assert.equal(big.length, 1);
+  assert.match(big[0], /limit/);
+  assert.deepEqual(problemsOf({ 'en-US': { a: entry(card('a'), MAX_IMAGE_BYTES) }, 'da-DK': { a: entry(card('a')) } }), []);
+});
+test('problemsOf names a screenshot that is not 750 px wide or is higher than 800 px, with the file and the size', () => {
+  const twin = { 'da-DK': { a: entry(card('a')) } };
+  const wide = problemsOf({ 'en-US': { a: entry(card('a'), 1000, { width: 751, height: 800 }) }, ...twin });
+  assert.equal(wide.length, 1);
+  assert.match(wide[0], /en-US\/pending\/a\.webp/);
+  assert.match(wide[0], /751×800/);
+  const high = problemsOf({ 'en-US': { a: entry(card('a'), 1000, { width: 750, height: MAX_IMAGE_HEIGHT + 1 }) }, ...twin });
+  assert.match(high[0], /750×801/);
+  assert.deepEqual(problemsOf({ 'en-US': { a: entry(card('a'), 1000, { width: 750, height: 120 }) }, ...twin }), []);
+});
+test('problemsOf names a screenshot that is not a WebP', () => {
+  const problems = problemsOf({ 'en-US': { a: entry(card('a'), 1000, null) }, 'da-DK': { a: entry(card('a')) } });
+  assert.equal(problems.length, 1);
+  assert.match(problems[0], /not a WebP/);
+});
+test('webpSize reads a lossy VP8 header', () => {
+  // frame tag (3 bytes), start code 9d 01 2a, then width 750 and height 800 (14 bits each, little endian)
+  const header = webp('VP8 ', { at: 20, bytes: [0, 0, 0, 0x9d, 0x01, 0x2a, 750 & 255, 750 >> 8, 800 & 255, 800 >> 8] });
+  assert.deepEqual(webpSize(header), { width: 750, height: 800 });
+});
+test('webpSize reads a lossless VP8L header', () => {
+  // signature 2f, then 14 bits of width-1 and 14 bits of height-1
+  const w = 750 - 1;
+  const h = 700 - 1;
+  const header = webp('VP8L', { at: 20, bytes: [0x2f, w & 255, ((w >> 8) & 0x3f) | ((h & 3) << 6), (h >> 2) & 255, (h >> 10) & 15] });
+  assert.deepEqual(webpSize(header), { width: 750, height: 700 });
+});
+test('webpSize reads an extended VP8X header', () => {
+  const w = 750 - 1;
+  const h = 640 - 1;
+  const header = webp('VP8X', { at: 24, bytes: [w & 255, (w >> 8) & 255, w >> 16, h & 255, (h >> 8) & 255, h >> 16] });
+  assert.deepEqual(webpSize(header), { width: 750, height: 640 });
+});
+test('webpSize gives null for anything that is not a WebP of these kinds', () => {
+  assert.equal(webpSize(new Uint8Array(0)), null);
+  assert.equal(webpSize(new Uint8Array(40)), null);
+  assert.equal(webpSize(Buffer.from('PNG-not-a-webp'.padEnd(40, 'x'))), null);
+  assert.equal(webpSize(webp('VP8 ', { at: 20, bytes: [0, 0, 0, 1, 2, 3, 1, 0, 1, 0] })), null);
+  assert.equal(webpSize(webp('ABCD', { at: 24, bytes: [1, 2, 3] })), null);
+});
+test('problemsOf names a line with a screenshot', () => {
+  const problems = problemsOf({ 'en-US': { b: entry(line('b'), 500) }, 'da-DK': { b: entry(line('b')) } });
+  assert.equal(problems.length, 1);
+  assert.match(problems[0], /no screenshot/);
+});
+
+test('released keeps each note as it is, sorted by id, with the ids of its cards', () => {
+  const pending = { 'en-US': { b: entry(card('b')), a: entry(line('a')) } };
+  assert.deepEqual(released(pending, '0.14.0'), {
+    'en-US': { file: { version: '0.14.0', notes: [line('a'), card('b')] }, images: ['b'] },
+  });
+});
+test('released leaves out a locale without notes', () => assert.deepEqual(released({ 'da-DK': {} }, '0.14.0'), {}));
+test('released gives nothing without notes', () => assert.deepEqual(released({}, '0.14.0'), {}));
+test('imagePath gives the released screenshot path of a card', () => {
+  assert.equal(imagePath('0.14.0', 'da-DK', 'brave-cats-run'), 'release-notes/i18n/da-DK/0.14.0/brave-cats-run.webp');
+});
+
+test('notesFor gives the locale notes when there are some', () => {
+  const x = line('x');
+  const y = line('y');
+  assert.deepEqual(notesFor({ 'en-US': [x], 'da-DK': [y] }, 'da-DK'), [y]);
+});
+test('notesFor falls back to the en-US notes', () => {
+  const x = line('x');
+  assert.deepEqual(notesFor({ 'en-US': [x] }, 'da-DK'), [x]);
+});
+test('notesFor gives undefined without notes', () => assert.equal(notesFor(undefined, 'da-DK'), undefined));
+
+test('installedVersions gives the finished update range, newest first', () => {
+  const update = { from: '0.13.0', to: '0.14.1', state: 'done' };
+  assert.deepEqual(installedVersions(update, '0.14.1', ['0.14.0', '0.14.1', '0.15.0']), ['0.14.1', '0.14.0']);
+});
+test('installedVersions gives only the running version when the update went to another version', () => {
+  assert.deepEqual(installedVersions({ to: '0.14.0', state: 'done' }, '0.14.1', ['0.14.1']), ['0.14.1']);
+});
+test('installedVersions gives only the running version, and only when it is kept', () => {
+  assert.deepEqual(installedVersions(null, '0.14.1', ['0.14.0']), []);
+});
+
+/** One tar entry: a 512-byte header, then the data padded to a multiple of 512. */
+function tarEntry(name, content) {
+  const data = Buffer.from(content);
+  const header = Buffer.alloc(512);
+  header.write(name, 0, 'ascii');
+  header.write('0000644\0', 100, 'ascii');
+  header.write(data.length.toString(8).padStart(11, '0') + '\0', 124, 'ascii');
+  header.write('0', 156, 'ascii');
+  return Buffer.concat([header, data, Buffer.alloc(Math.ceil(data.length / 512) * 512 - data.length)]);
+}
+const tarball = (...entries) => new Uint8Array(Buffer.concat([...entries, Buffer.alloc(1024)]));
+const notesFile = (locale, version, notes) =>
+  tarEntry(`package/release-notes/i18n/${locale}/${version}.json`, JSON.stringify({ version, notes }));
+const imageFile = (locale, version, id, bytes) => tarEntry(`package/release-notes/i18n/${locale}/${version}/${id}.webp`, bytes);
+
+test('notesFromTar reads the notes and screenshot bytes of each locale', () => {
+  const da = card('a', { title: 'Titel' });
+  const tar = tarball(
+    notesFile('en-US', '0.14.0', [card('a')]),
+    notesFile('da-DK', '0.14.0', [da]),
+    imageFile('en-US', '0.14.0', 'a', [1, 2, 3]),
+    imageFile('da-DK', '0.14.0', 'a', [4, 5]),
+  );
+  const result = notesFromTar(tar, '0.14.0');
+  assert.deepEqual(result.notes, { 'en-US': [card('a')], 'da-DK': [da] });
+  assert.deepEqual(
+    result.images.map(({ locale, id, bytes }) => ({ locale, id, bytes: [...bytes] })),
+    [
+      { locale: 'en-US', id: 'a', bytes: [1, 2, 3] },
+      { locale: 'da-DK', id: 'a', bytes: [4, 5] },
+    ],
+  );
+});
+test('notesFromTar leaves out a locale without a file, and a line has no screenshot', () => {
+  const tar = tarball(notesFile('en-US', '0.14.0', [line('a')]));
+  assert.deepEqual(notesFromTar(tar, '0.14.0'), { notes: { 'en-US': [line('a')] }, images: [] });
+});
+test('notesFromTar leaves out a card whose screenshot is missing from the tar', () => {
+  const tar = tarball(notesFile('en-US', '0.14.0', [card('a')]));
+  assert.deepEqual(notesFromTar(tar, '0.14.0'), { notes: { 'en-US': [card('a')] }, images: [] });
+});
+test('notesFromTar gives undefined without any notes file', () => {
+  assert.equal(notesFromTar(tarball(tarEntry('package/x', 'y')), '0.14.0'), undefined);
+});
+test('notesFromTar skips a locale with bad JSON', () => {
+  const tar = tarball(tarEntry('package/release-notes/i18n/en-US/0.14.0.json', '{bad'), notesFile('da-DK', '0.14.0', [line('a')]));
+  assert.deepEqual(notesFromTar(tar, '0.14.0'), { notes: { 'da-DK': [line('a')] }, images: [] });
+});
+
+test('imageUrl and imageKey name a screenshot by version, locale and id', () => {
+  assert.equal(imageUrl('0.14.0', 'da-DK', 'quiet-lamps'), '/api/cms/note-image/0.14.0/da-DK/quiet-lamps');
+  assert.equal(imageKey('0.14.0', 'da-DK', 'quiet-lamps'), 'cms:note-image:0.14.0:da-DK:quiet-lamps');
+});
+
+test('parseImagePath reads a screenshot address', () => {
+  assert.deepEqual(parseImagePath('/api/cms/note-image/0.14.0/en-US/quiet-lamps-2'), {
+    version: '0.14.0',
+    locale: 'en-US',
+    id: 'quiet-lamps-2',
+  });
+});
+
+test('parseImagePath rejects a bad version, locale, id or shape', () => {
+  for (const path of [
+    '/api/cms/note-image/0.14/en-US/a',
+    '/api/cms/note-image/0.14.0-beta/en-US/a',
+    '/api/cms/note-image/0.14.0/fr-FR/a',
+    '/api/cms/note-image/0.14.0/en-US/A',
+    '/api/cms/note-image/0.14.0/en-US/a:b',
+    '/api/cms/note-image/0.14.0/en-US/a/b',
+    '/api/cms/note-image/0.14.0/en-US/',
+    '/api/cms/note-image/0.14.0/en-US/..%2Fx',
+    '/api/cms',
+  ])
+    assert.equal(parseImagePath(path), null, path);
+});
+
+test('withImageUrls sets the address on cards only and leaves the input alone', () => {
+  const notes = {
+    'en-US': [
+      { id: 'a', kind: 'card', title: 'T', text: 'x' },
+      { id: 'b', kind: 'line', text: 'y' },
+    ],
+  };
+  const out = withImageUrls('0.14.0', notes);
+  assert.equal(out['en-US'][0].image, '/api/cms/note-image/0.14.0/en-US/a');
+  assert.deepEqual(out['en-US'][1], { id: 'b', kind: 'line', text: 'y' });
+  assert.equal(notes['en-US'][0].image, undefined);
+});
+
+test('withImageUrls gives undefined without notes', () => assert.equal(withImageUrls('0.14.0', undefined), undefined));

package/lib/serviceFeed.d.mts

@@ -0,0 +1,2 @@
+/** The parsed JSON of a feed, or null when the fetch throws, the answer is not ok, the body is not JSON, or it takes longer than ms (aborted). */
+export function feedOf(url: any, fetcher?: typeof fetch, ms?: number): Promise<any>;

package/lib/serviceFeed.mjs

@@ -0,0 +1,13 @@
+// Fetches one Statuspage feed for the Worker's /api/status (worker/service-status.js).
+// Exposes feedOf(url, fetcher, ms). No imports; kept out of worker/ so node --test can load it.
+
+/** The parsed JSON of a feed, or null when the fetch throws, the answer is not ok, the body is not JSON, or it takes longer than ms (aborted). */
+export async function feedOf(url, fetcher = fetch, ms = 3000) {
+  try {
+    const res = await fetcher(url, { headers: { accept: 'application/json' }, cf: { cacheTtl: 60 }, signal: AbortSignal.timeout(ms) });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}

package/lib/serviceFeed.test.mjs

@@ -0,0 +1,53 @@
+// Tests for feedOf in lib/serviceFeed.mjs: a feed that fails or is slow gives null, a good one gives its JSON.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { feedOf } from './serviceFeed.mjs';
+
+test('a fetcher that throws gives null', async () => {
+  const fetcher = async () => {
+    throw new Error('down');
+  };
+  assert.equal(await feedOf('https://x.example/f', fetcher), null);
+});
+
+test('a 500 gives null', async () => {
+  assert.equal(await feedOf('https://x.example/f', async () => new Response('{}', { status: 500 })), null);
+});
+
+test('a body that is not JSON gives null', async () => {
+  assert.equal(await feedOf('https://x.example/f', async () => new Response('<html>')), null);
+});
+
+test('a good JSON body gives the parsed object, asked with the accept header and cache hint', async () => {
+  let seen;
+  const body = await feedOf('https://x.example/f', async (url, init) => {
+    seen = init;
+    return Response.json({ components: [] });
+  });
+  assert.deepEqual(body, { components: [] });
+  assert.equal(seen.headers.accept, 'application/json');
+  assert.equal(seen.cf.cacheTtl, 60);
+});
+
+// A fetcher that never answers until its request is aborted, as a hung server does.
+const hung = (url, init) =>
+  new Promise((_, reject) => {
+    init.signal.addEventListener('abort', () => reject(init.signal.reason));
+  });
+
+test('a feed slower than the timeout gives null', async () => {
+  assert.equal(await feedOf('https://x.example/f', hung, 20), null);
+});
+
+test('the request carries a signal that aborts after the timeout', async () => {
+  let seen;
+  await feedOf(
+    'https://x.example/f',
+    (url, init) => {
+      seen = init.signal;
+      return hung(url, init);
+    },
+    20,
+  );
+  assert.equal(seen.aborted, true);
+});

package/lib/serviceStatus.d.mts

@@ -0,0 +1,72 @@
+/**
+ * @param {string} status
+ * @returns {ServiceState}
+ */
+export function stateOf(status: string): ServiceState;
+/**
+ * @param {ServiceState[]} states
+ * @returns {ServiceState}
+ */
+export function worst(states: ServiceState[]): ServiceState;
+/**
+ * @param {object} provider
+ * @param {object|null} summary
+ * @returns {ServiceProvider}
+ */
+export function providerFrom(provider: object, summary: object | null): ServiceProvider;
+/**
+ * The providers with only the components a site has the bindings for.
+ * @param {Iterable<string>} bindings The names of the bindings the site has.
+ * @returns {typeof PROVIDERS}
+ */
+export function providersFor(bindings: Iterable<string>): typeof PROVIDERS;
+/**
+ * @param {{ github: object|null, cloudflare: object|null }} summaries
+ * @param {typeof PROVIDERS} [list] The providers to report on (providersFor), all by default.
+ * @returns {StatusReport}
+ */
+export function reportFrom(summaries: {
+    github: object | null;
+    cloudflare: object | null;
+}, list?: typeof PROVIDERS): StatusReport;
+/**
+ * @typedef {'ok' | 'minor' | 'major' | 'unknown'} ServiceState
+ * @typedef {'operational' | 'degraded_performance' | 'under_maintenance' | 'partial_outage' | 'major_outage' | 'unknown'} ComponentStatus
+ * @typedef {{ id: string, name: string, status: ComponentStatus, state: ServiceState }} ServiceComponent
+ * @typedef {{ id: 'github' | 'cloudflare', name: 'GitHub' | 'Cloudflare', page: string, state: ServiceState, components: ServiceComponent[] }} ServiceProvider
+ * @typedef {{ state: ServiceState, providers: ServiceProvider[] }} StatusReport
+ */
+export const PROVIDERS: {
+    id: string;
+    name: string;
+    feed: string;
+    page: string;
+    components: ({
+        id: string;
+        name: string;
+        needs?: undefined;
+    } | {
+        id: string;
+        name: string;
+        needs: string[];
+    })[];
+}[];
+export type ServiceState = "ok" | "minor" | "major" | "unknown";
+export type ComponentStatus = "operational" | "degraded_performance" | "under_maintenance" | "partial_outage" | "major_outage" | "unknown";
+export type ServiceComponent = {
+    id: string;
+    name: string;
+    status: ComponentStatus;
+    state: ServiceState;
+};
+export type ServiceProvider = {
+    id: "github" | "cloudflare";
+    name: "GitHub" | "Cloudflare";
+    page: string;
+    state: ServiceState;
+    components: ServiceComponent[];
+};
+export type StatusReport = {
+    state: ServiceState;
+    providers: ServiceProvider[];
+};

package/lib/serviceStatus.mjs

@@ -0,0 +1,143 @@
+// The status of the services a Morpheme site needs (GitHub, Cloudflare), from their Statuspage feeds.
+// Exposes PROVIDERS, providersFor, stateOf, worst, providerFrom and reportFrom. No imports: the Worker and the editor use it.
+
+/**
+ * @typedef {'ok' | 'minor' | 'major' | 'unknown'} ServiceState
+ * @typedef {'operational' | 'degraded_performance' | 'under_maintenance' | 'partial_outage' | 'major_outage' | 'unknown'} ComponentStatus
+ * @typedef {{ id: string, name: string, status: ComponentStatus, state: ServiceState }} ServiceComponent
+ * @typedef {{ id: 'github' | 'cloudflare', name: 'GitHub' | 'Cloudflare', page: string, state: ServiceState, components: ServiceComponent[] }} ServiceProvider
+ * @typedef {{ state: ServiceState, providers: ServiceProvider[] }} StatusReport
+ */
+
+// A component with `needs` counts only when the site has at least one of those bindings (a KV namespace, a D1 database or an
+// R2 bucket in its Worker's settings, starter/wrangler.jsonc); one without always counts. See providersFor.
+export const PROVIDERS = [
+  {
+    id: 'github',
+    name: 'GitHub',
+    feed: 'https://www.githubstatus.com/api/v2/summary.json',
+    page: 'https://www.githubstatus.com/',
+    components: [
+      { id: '8l4ygp009s5s', name: 'Git Operations' },
+      { id: 'brv1bkgrwx7q', name: 'API Requests' },
+      { id: '4230lsnqdsld', name: 'Webhooks' },
+    ],
+  },
+  {
+    id: 'cloudflare',
+    name: 'Cloudflare',
+    feed: 'https://www.cloudflarestatus.com/api/v2/summary.json',
+    page: 'https://www.cloudflarestatus.com/',
+    components: [
+      { id: '57srcl8zcn7c', name: 'Workers' },
+      { id: 'pg21w9xb991r', name: 'Workers Assets' },
+      { id: 'vcpsk0w6g86k', name: 'Workers Builds' },
+      { id: 'tmh50tx2nprs', name: 'Workers KV', needs: ['NOT_FOUND', 'PUSH'] },
+      { id: 'z0yd3sxqjqdm', name: 'D1', needs: ['CONSENT'] },
+      { id: 'hb7g5sq2zz0h', name: 'R2', needs: ['FILES'] },
+    ],
+  },
+];
+
+const KNOWN_STATUSES = new Set(['operational', 'degraded_performance', 'under_maintenance', 'partial_outage', 'major_outage']);
+
+const SEVERITY_ORDER = ['ok', 'unknown', 'minor', 'major'];
+
+/**
+ * @param {string} status
+ * @returns {ServiceState}
+ */
+export function stateOf(status) {
+  switch (status) {
+    case 'operational':
+      return 'ok';
+    case 'degraded_performance':
+    case 'under_maintenance':
+      return 'minor';
+    case 'partial_outage':
+    case 'major_outage':
+      return 'major';
+    default:
+      return 'unknown';
+  }
+}
+
+/**
+ * @param {ServiceState[]} states
+ * @returns {ServiceState}
+ */
+export function worst(states) {
+  if (states.length === 0) return 'ok';
+  let worstState = 'ok';
+  for (const s of states) {
+    if (SEVERITY_ORDER.indexOf(s) > SEVERITY_ORDER.indexOf(worstState)) {
+      worstState = s;
+    }
+  }
+  return worstState;
+}
+
+/**
+ * @param {object} provider
+ * @param {object|null} summary
+ * @returns {ServiceProvider}
+ */
+export function providerFrom(provider, summary) {
+  const componentsMap = new Map();
+  if (summary && Array.isArray(summary.components)) {
+    for (const c of summary.components) {
+      componentsMap.set(c.id, c);
+    }
+  }
+
+  const components = provider.components.map((c) => {
+    const feedComponent = componentsMap.get(c.id);
+    const rawStatus = feedComponent ? feedComponent.status : null;
+    const status = rawStatus && KNOWN_STATUSES.has(rawStatus) ? /** @type {ComponentStatus} */ (rawStatus) : 'unknown';
+    return {
+      id: c.id,
+      name: c.name,
+      status,
+      state: stateOf(status),
+    };
+  });
+
+  return {
+    id: provider.id,
+    name: provider.name,
+    page: provider.page,
+    state: worst(components.map((c) => c.state)),
+    components,
+  };
+}
+
+/**
+ * The providers with only the components a site has the bindings for.
+ * @param {Iterable<string>} bindings The names of the bindings the site has.
+ * @returns {typeof PROVIDERS}
+ */
+export function providersFor(bindings) {
+  const have = new Set(bindings);
+  return PROVIDERS.map((p) => ({
+    ...p,
+    components: p.components.filter((c) => !c.needs || c.needs.some((name) => have.has(name))),
+  }));
+}
+
+/**
+ * @param {{ github: object|null, cloudflare: object|null }} summaries
+ * @param {typeof PROVIDERS} [list] The providers to report on (providersFor), all by default.
+ * @returns {StatusReport}
+ */
+export function reportFrom(summaries, list = PROVIDERS) {
+  const providers = list.map((p) => {
+    const key = p.id;
+    const summary = summaries[key] || null;
+    return providerFrom(p, summary);
+  });
+
+  return {
+    state: worst(providers.map((p) => p.state)),
+    providers,
+  };
+}