@morphemecms/cms 0.1.0 → 0.2.0-next-20261104150211

package/worker/not-found.js

@@ -1,97 +1,97 @@
-// The addresses visitors came to that do not exist (the site's 404 page), for "Videresendelser" in the
-// editor (packages/editor/src/notFound.ts, Redirects.tsx), where the site's owner can send them on to a page.
-// Kept in Workers KV (the binding NOT_FOUND in wrangler.jsonc), one key per address: how many times,
-// when first and last, and where the visitor came from. No IP address, no cookie: nothing about the
-// visitor, so it needs no consent. An address not seen for 90 days drops out by itself.
-// Without the binding (a preview of a branch) nothing is kept and the editor says so.
-//   GET    /api/not-found  the addresses, most visits first
-//   DELETE /api/not-found  { paths: [...] } takes them off the list (sent on, or not worth it)
-// Only someone who can save the site (write access to the repository on GitHub) can read or change it.
-import { mayEdit } from './session.js';
-
-const PREFIX = '404:';
-const KEEP = 90 * 24 * 60 * 60;
-// A page: no file ending in the last part (not a picture, a script or /wp-login.php).
-const PAGE = /(^|\/)[^./]*$/;
-// What is not a page of the site, and what robots try on every site.
-const SKIP = /^\/(editor|oauth|api|cdn-cgi|\.well-known|wp-admin|wp-includes|wp-json)(\/|$)/i;
-const ROBOT = /bot|crawl|spider|slurp|headless|python|curl|wget|scan|http/i;
-
-/** Whether a 404 is a visitor's, worth keeping: a browser opening a page, on the public site. */
-export function isVisit(request, url) {
-  const agent = request.headers.get('user-agent') ?? '';
-  return (
-    request.method === 'GET' &&
-    url.pathname.length <= 300 &&
-    PAGE.test(url.pathname) &&
-    !SKIP.test(url.pathname) &&
-    agent.includes('Mozilla') &&
-    !ROBOT.test(agent.replace(/^Mozilla\/[\d.]+ /, '')) &&
-    (request.headers.get('accept') ?? '').includes('text/html')
-  );
-}
-
-/** Counts a visit to an address that does not exist. Never fails the request (KV may say no). */
-export async function recordNotFound(request, url, env) {
-  if (!env.NOT_FOUND) return;
-  try {
-    const key = PREFIX + addressOf(url.pathname);
-    const { metadata: was } = await env.NOT_FOUND.getWithMetadata(key);
-    const now = new Date().toISOString();
-    const metadata = { n: (was?.n ?? 0) + 1, first: was?.first ?? now, last: now, from: cameFrom(request, url) || was?.from || '' };
-    await env.NOT_FOUND.put(key, '', { metadata, expirationTtl: KEEP });
-  } catch {}
-}
-
-// The address as the editor's redirects have it: decoded (/æble/, not /%C3%A6ble/), and with the slash
-// at the end, for /kontakt is sent on by the redirect from /kontakt/ (packages/editor/worker/index.js withSlash).
-function addressOf(pathname) {
-  let path = pathname;
-  try {
-    path = decodeURIComponent(pathname);
-  } catch {}
-  return path.endsWith('/') ? path : `${path}/`;
-}
-
-// Where the visitor came from: a page of the site by its address (a link on it is broken), another
-// site by its name (google.com); browsers send no more than that for another site.
-function cameFrom(request, url) {
-  try {
-    const from = new URL(request.headers.get('referer') ?? '');
-    if (from.host === url.host) return from.pathname.slice(0, 200);
-    return from.hostname.replace(/^www\./, '').slice(0, 200);
-  } catch {
-    return '';
-  }
-}
-
-export async function handleNotFound(request, env) {
-  if (!(await mayEdit(request))) return json({ error: 'forbidden' }, 403);
-  if (!env.NOT_FOUND) return json({ error: 'unavailable' }, 503);
-  if (request.method === 'GET') return json({ entries: await entries(env.NOT_FOUND) });
-  if (request.method === 'DELETE') {
-    const body = await request.json().catch(() => ({}));
-    const paths = Array.isArray(body.paths) ? body.paths.filter((p) => typeof p === 'string').slice(0, 100) : [];
-    await Promise.all(paths.map((p) => env.NOT_FOUND.delete(PREFIX + p)));
-    return json({ deleted: paths.length });
-  }
-  return json({ error: 'method' }, 405);
-}
-
-async function entries(kv) {
-  const all = [];
-  let cursor;
-  // At most 5000 addresses; more would be robots.
-  for (let i = 0; i < 5; i++) {
-    const page = await kv.list({ prefix: PREFIX, cursor });
-    for (const { name, metadata } of page.keys)
-      if (metadata)
-        all.push({ path: name.slice(PREFIX.length), count: metadata.n, first: metadata.first, last: metadata.last, from: metadata.from });
-    if (page.list_complete) break;
-    cursor = page.cursor;
-  }
-  return all.sort((a, b) => b.count - a.count || b.last.localeCompare(a.last));
-}
-
-export const json = (data, status = 200) =>
-  new Response(JSON.stringify(data), { status, headers: { 'content-type': 'application/json', 'cache-control': 'no-store' } });
+// The addresses visitors came to that do not exist (the site's 404 page), for "Videresendelser" in the
+// editor (packages/editor/src/notFound.ts, Redirects.tsx), where the site's owner can send them on to a page.
+// Kept in Workers KV (the binding NOT_FOUND in wrangler.jsonc), one key per address: how many times,
+// when first and last, and where the visitor came from. No IP address, no cookie: nothing about the
+// visitor, so it needs no consent. An address not seen for 90 days drops out by itself.
+// Without the binding (a preview of a branch) nothing is kept and the editor says so.
+//   GET    /api/not-found  the addresses, most visits first
+//   DELETE /api/not-found  { paths: [...] } takes them off the list (sent on, or not worth it)
+// Only someone who can save the site (write access to the repository on GitHub) can read or change it.
+import { mayEdit } from './session.js';
+
+const PREFIX = '404:';
+const KEEP = 90 * 24 * 60 * 60;
+// A page: no file ending in the last part (not a picture, a script or /wp-login.php).
+const PAGE = /(^|\/)[^./]*$/;
+// What is not a page of the site, and what robots try on every site.
+const SKIP = /^\/(editor|oauth|api|cdn-cgi|\.well-known|wp-admin|wp-includes|wp-json)(\/|$)/i;
+const ROBOT = /bot|crawl|spider|slurp|headless|python|curl|wget|scan|http/i;
+
+/** Whether a 404 is a visitor's, worth keeping: a browser opening a page, on the public site. */
+export function isVisit(request, url) {
+  const agent = request.headers.get('user-agent') ?? '';
+  return (
+    request.method === 'GET' &&
+    url.pathname.length <= 300 &&
+    PAGE.test(url.pathname) &&
+    !SKIP.test(url.pathname) &&
+    agent.includes('Mozilla') &&
+    !ROBOT.test(agent.replace(/^Mozilla\/[\d.]+ /, '')) &&
+    (request.headers.get('accept') ?? '').includes('text/html')
+  );
+}
+
+/** Counts a visit to an address that does not exist. Never fails the request (KV may say no). */
+export async function recordNotFound(request, url, env) {
+  if (!env.NOT_FOUND) return;
+  try {
+    const key = PREFIX + addressOf(url.pathname);
+    const { metadata: was } = await env.NOT_FOUND.getWithMetadata(key);
+    const now = new Date().toISOString();
+    const metadata = { n: (was?.n ?? 0) + 1, first: was?.first ?? now, last: now, from: cameFrom(request, url) || was?.from || '' };
+    await env.NOT_FOUND.put(key, '', { metadata, expirationTtl: KEEP });
+  } catch {}
+}
+
+// The address as the editor's redirects have it: decoded (/æble/, not /%C3%A6ble/), and with the slash
+// at the end, for /kontakt is sent on by the redirect from /kontakt/ (packages/editor/worker/index.js withSlash).
+function addressOf(pathname) {
+  let path = pathname;
+  try {
+    path = decodeURIComponent(pathname);
+  } catch {}
+  return path.endsWith('/') ? path : `${path}/`;
+}
+
+// Where the visitor came from: a page of the site by its address (a link on it is broken), another
+// site by its name (google.com); browsers send no more than that for another site.
+function cameFrom(request, url) {
+  try {
+    const from = new URL(request.headers.get('referer') ?? '');
+    if (from.host === url.host) return from.pathname.slice(0, 200);
+    return from.hostname.replace(/^www\./, '').slice(0, 200);
+  } catch {
+    return '';
+  }
+}
+
+export async function handleNotFound(request, env) {
+  if (!(await mayEdit(request))) return json({ error: 'forbidden' }, 403);
+  if (!env.NOT_FOUND) return json({ error: 'unavailable' }, 503);
+  if (request.method === 'GET') return json({ entries: await entries(env.NOT_FOUND) });
+  if (request.method === 'DELETE') {
+    const body = await request.json().catch(() => ({}));
+    const paths = Array.isArray(body.paths) ? body.paths.filter((p) => typeof p === 'string').slice(0, 100) : [];
+    await Promise.all(paths.map((p) => env.NOT_FOUND.delete(PREFIX + p)));
+    return json({ deleted: paths.length });
+  }
+  return json({ error: 'method' }, 405);
+}
+
+async function entries(kv) {
+  const all = [];
+  let cursor;
+  // At most 5000 addresses; more would be robots.
+  for (let i = 0; i < 5; i++) {
+    const page = await kv.list({ prefix: PREFIX, cursor });
+    for (const { name, metadata } of page.keys)
+      if (metadata)
+        all.push({ path: name.slice(PREFIX.length), count: metadata.n, first: metadata.first, last: metadata.last, from: metadata.from });
+    if (page.list_complete) break;
+    cursor = page.cursor;
+  }
+  return all.sort((a, b) => b.count - a.count || b.last.localeCompare(a.last));
+}
+
+export const json = (data, status = 200) =>
+  new Response(JSON.stringify(data), { status, headers: { 'content-type': 'application/json', 'cache-control': 'no-store' } });

package/worker/oauth.js

@@ -1,95 +1,95 @@
-// GitHub sign-in for the editor at /editor/ (packages/editor/src/github.ts). See docs/editor.md.
-//   /oauth/auth      the editor goes here; we send the browser on to GitHub
-//   /oauth/callback  GitHub sends the browser back here; we swap the code for a token, keep it in a
-//                    cookie only the Worker can read (packages/editor/worker/session.js) and go back to /editor/
-// A redirect rather than a popup, so it also works in the editor installed as an app on a phone.
-// Needs the Worker secrets GITHUB_CLIENT_ID and GITHUB_CLIENT_SECRET from a GitHub App whose
-// callback URL is https://<hostname>/oauth/callback (installed on this repo only; see docs/editor.md).
-// Who may edit is decided by GitHub: only people with write access to the repository can save.
-import { sessionCookie } from './session.js';
-
-const STATE_COOKIE = 'cms_oauth_state';
-// The editor asks for "repo"; anything outside this list is dropped.
-const SCOPES = new Set(['repo', 'public_repo', 'user', 'read:user', 'user:email']);
-
-export async function handleOAuth(request, env) {
-  const url = new URL(request.url);
-  if (url.pathname === '/oauth/auth') return authorize(url, env);
-  if (url.pathname === '/oauth/callback') return callback(request, url, env);
-  return null;
-}
-
-function authorize(url, env) {
-  if (!env.GITHUB_CLIENT_ID || !env.GITHUB_CLIENT_SECRET) {
-    return finish({ error: 'GitHub-login er ikke sat op endnu (mangler GITHUB_CLIENT_ID/SECRET).' });
-  }
-  if ((url.searchParams.get('provider') ?? 'github') !== 'github') return finish({ error: 'Ukendt login.' });
-  const scope =
-    (url.searchParams.get('scope') ?? '')
-      .split(/[\s,]+/)
-      .filter((s) => SCOPES.has(s))
-      .join(',') || 'repo';
-  const state = crypto.randomUUID();
-  const github = new URL('https://github.com/login/oauth/authorize');
-  github.search = new URLSearchParams({
-    client_id: env.GITHUB_CLIENT_ID,
-    redirect_uri: `${url.origin}/oauth/callback`,
-    scope,
-    state,
-  });
-  return new Response(null, {
-    status: 302,
-    headers: {
-      location: github.href,
-      'set-cookie': `${STATE_COOKIE}=${state}; Path=/oauth/; Max-Age=600; HttpOnly; Secure; SameSite=Lax`,
-      'cache-control': 'no-store',
-    },
-  });
-}
-
-async function callback(request, url, env) {
-  const code = url.searchParams.get('code');
-  const state = url.searchParams.get('state');
-  const cookie = request.headers.get('cookie') ?? '';
-  const expected = cookie.match(new RegExp(`(?:^|;\\s*)${STATE_COOKIE}=([^;]+)`))?.[1];
-  if (!code || !state || state !== expected) {
-    return finish({ error: 'Login mislykkedes (ugyldig eller udløbet forespørgsel). Prøv igen.' });
-  }
-
-  const res = await fetch('https://github.com/login/oauth/access_token', {
-    method: 'POST',
-    headers: { accept: 'application/json', 'content-type': 'application/json', 'user-agent': 'morpheme-cms' },
-    body: JSON.stringify({
-      client_id: env.GITHUB_CLIENT_ID,
-      client_secret: env.GITHUB_CLIENT_SECRET,
-      code,
-      redirect_uri: `${url.origin}/oauth/callback`,
-    }),
-  });
-  const data = await res.json().catch(() => ({}));
-  if (!res.ok || !data.access_token) {
-    return finish({ error: `Login mislykkedes: ${data.error_description ?? data.error ?? res.status}` });
-  }
-  return finish({ token: data.access_token });
-}
-
-// The page GitHub's sign-in ends on: with a token, it keeps it for the Worker (the cookie) and opens the
-// editor (from this page, so the cookie, SameSite=Strict, goes with what the editor asks); with an error, it
-// shows it with a way back.
-function finish({ token, error }) {
-  const body = error
-    ? `<p>${escapeHtml(error)}</p><p><a href="/editor/">Tilbage til editoren</a></p>`
-    : `<p>Logger ind…</p><script>location.replace('/editor/');</script>`;
-  const html = `<!doctype html><html lang="da"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><meta name="robots" content="noindex"><title>Login</title></head>
-<body style="font-family: system-ui, sans-serif; padding: 2rem">${body}</body></html>`;
-  const headers = new Headers({
-    'content-type': 'text/html; charset=utf-8',
-    'cache-control': 'no-store',
-    'set-cookie': `${STATE_COOKIE}=; Path=/oauth/; Max-Age=0; HttpOnly; Secure; SameSite=Lax`,
-  });
-  if (token) headers.append('set-cookie', sessionCookie(token));
-  return new Response(html, { status: error ? 400 : 200, headers });
-}
-
-const escapeHtml = (s) =>
-  String(s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
+// GitHub sign-in for the editor at /editor/ (packages/editor/src/github.ts). See docs/editor.md.
+//   /oauth/auth      the editor goes here; we send the browser on to GitHub
+//   /oauth/callback  GitHub sends the browser back here; we swap the code for a token, keep it in a
+//                    cookie only the Worker can read (packages/editor/worker/session.js) and go back to /editor/
+// A redirect rather than a popup, so it also works in the editor installed as an app on a phone.
+// Needs the Worker secrets GITHUB_CLIENT_ID and GITHUB_CLIENT_SECRET from a GitHub App whose
+// callback URL is https://<hostname>/oauth/callback (installed on this repo only; see docs/editor.md).
+// Who may edit is decided by GitHub: only people with write access to the repository can save.
+import { sessionCookie } from './session.js';
+
+const STATE_COOKIE = 'cms_oauth_state';
+// The editor asks for "repo"; anything outside this list is dropped.
+const SCOPES = new Set(['repo', 'public_repo', 'user', 'read:user', 'user:email']);
+
+export async function handleOAuth(request, env) {
+  const url = new URL(request.url);
+  if (url.pathname === '/oauth/auth') return authorize(url, env);
+  if (url.pathname === '/oauth/callback') return callback(request, url, env);
+  return null;
+}
+
+function authorize(url, env) {
+  if (!env.GITHUB_CLIENT_ID || !env.GITHUB_CLIENT_SECRET) {
+    return finish({ error: 'GitHub-login er ikke sat op endnu (mangler GITHUB_CLIENT_ID/SECRET).' });
+  }
+  if ((url.searchParams.get('provider') ?? 'github') !== 'github') return finish({ error: 'Ukendt login.' });
+  const scope =
+    (url.searchParams.get('scope') ?? '')
+      .split(/[\s,]+/)
+      .filter((s) => SCOPES.has(s))
+      .join(',') || 'repo';
+  const state = crypto.randomUUID();
+  const github = new URL('https://github.com/login/oauth/authorize');
+  github.search = new URLSearchParams({
+    client_id: env.GITHUB_CLIENT_ID,
+    redirect_uri: `${url.origin}/oauth/callback`,
+    scope,
+    state,
+  });
+  return new Response(null, {
+    status: 302,
+    headers: {
+      location: github.href,
+      'set-cookie': `${STATE_COOKIE}=${state}; Path=/oauth/; Max-Age=600; HttpOnly; Secure; SameSite=Lax`,
+      'cache-control': 'no-store',
+    },
+  });
+}
+
+async function callback(request, url, env) {
+  const code = url.searchParams.get('code');
+  const state = url.searchParams.get('state');
+  const cookie = request.headers.get('cookie') ?? '';
+  const expected = cookie.match(new RegExp(`(?:^|;\\s*)${STATE_COOKIE}=([^;]+)`))?.[1];
+  if (!code || !state || state !== expected) {
+    return finish({ error: 'Login mislykkedes (ugyldig eller udløbet forespørgsel). Prøv igen.' });
+  }
+
+  const res = await fetch('https://github.com/login/oauth/access_token', {
+    method: 'POST',
+    headers: { accept: 'application/json', 'content-type': 'application/json', 'user-agent': 'morpheme-cms' },
+    body: JSON.stringify({
+      client_id: env.GITHUB_CLIENT_ID,
+      client_secret: env.GITHUB_CLIENT_SECRET,
+      code,
+      redirect_uri: `${url.origin}/oauth/callback`,
+    }),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok || !data.access_token) {
+    return finish({ error: `Login mislykkedes: ${data.error_description ?? data.error ?? res.status}` });
+  }
+  return finish({ token: data.access_token });
+}
+
+// The page GitHub's sign-in ends on: with a token, it keeps it for the Worker (the cookie) and opens the
+// editor (from this page, so the cookie, SameSite=Strict, goes with what the editor asks); with an error, it
+// shows it with a way back.
+function finish({ token, error }) {
+  const body = error
+    ? `<p>${escapeHtml(error)}</p><p><a href="/editor/">Tilbage til editoren</a></p>`
+    : `<p>Logger ind…</p><script>location.replace('/editor/');</script>`;
+  const html = `<!doctype html><html lang="da"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><meta name="robots" content="noindex"><title>Login</title></head>
+<body style="font-family: system-ui, sans-serif; padding: 2rem">${body}</body></html>`;
+  const headers = new Headers({
+    'content-type': 'text/html; charset=utf-8',
+    'cache-control': 'no-store',
+    'set-cookie': `${STATE_COOKIE}=; Path=/oauth/; Max-Age=0; HttpOnly; Secure; SameSite=Lax`,
+  });
+  if (token) headers.append('set-cookie', sessionCookie(token));
+  return new Response(html, { status: error ? 400 : 200, headers });
+}
+
+const escapeHtml = (s) =>
+  String(s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);

package/worker/publish.js

@@ -1,52 +1,52 @@
-// Publishes the pages and blog posts that are Planlagt once their time has come (packages/editor/lib/status.mjs): each hour (the
-// cron in wrangler.jsonc, minute 7) the Worker reads the list the build made of them (/_scheduled.json,
-// packages/editor/scripts/scheduled-list.mjs), and if a time has come, it makes those files Udgivet (their `status` and `publishAt`
-// lines go) in one commit on main (*Udgiv planlagt: blogindlæg "…"*), which builds the site. Nothing is asked of
-// GitHub in an hour with nothing to publish. Needs the Worker secret GITHUB_PUBLISH_TOKEN: a GitHub token with
-// Contents: Read and write on the repository (docs/editor.md, Opsætning; packages/editor/worker/github.js).
-import { commitFiles, readFiles } from './github.js';
-import { isDue, nameOf, published, scheduleOf } from '../lib/scheduled.mjs';
-
-/** The address of the build's list; on the site it gives nothing (packages/editor/worker/index.js). */
-export const SCHEDULED_LIST = '/_scheduled.json';
-
-export async function publishScheduled(env, now = Date.now()) {
-  const due = (await listOf(env)).filter((e) => isDue(e.publishAt, now));
-  if (!due.length) return [];
-  if (!env.GITHUB_PUBLISH_TOKEN) {
-    console.error('Planlagte sider og indlæg kan ikke udgives: Workeren mangler hemmeligheden GITHUB_PUBLISH_TOKEN.');
-    return [];
-  }
-  // The files as they are now (one may have been published or changed since the build).
-  const { head, texts } = await readFiles(
-    env,
-    due.map((e) => e.path),
-  );
-  const changes = due
-    .map((e, i) => ({ path: e.path, text: texts[i] }))
-    .filter(({ text }) => {
-      const file = scheduleOf(text ?? '');
-      return file.status === 'scheduled' && isDue(file.publishAt, now);
-    });
-  if (!changes.length) return [];
-  const names = changes.map((c) => nameOf(c.path));
-  await commitFiles(
-    env,
-    head,
-    `Udgiv planlagt: ${names.join(', ')}`,
-    changes.map((c) => ({ path: c.path, text: published(c.text) })),
-  );
-  console.log(`Udgivet: ${names.join(', ')}`);
-  return names;
-}
-
-// The build's list; none (a build before the list, or a preview) is nothing to publish.
-async function listOf(env) {
-  try {
-    const res = await env.ASSETS.fetch(new Request(`https://assets.local${SCHEDULED_LIST}`));
-    const list = res.ok ? await res.json() : [];
-    return Array.isArray(list) ? list : [];
-  } catch {
-    return [];
-  }
-}
+// Publishes the pages and blog posts that are Planlagt once their time has come (packages/editor/lib/status.mjs): each hour (the
+// cron in wrangler.jsonc, minute 7) the Worker reads the list the build made of them (/_scheduled.json,
+// packages/editor/scripts/scheduled-list.mjs), and if a time has come, it makes those files Udgivet (their `status` and `publishAt`
+// lines go) in one commit on main (*Udgiv planlagt: blogindlæg "…"*), which builds the site. Nothing is asked of
+// GitHub in an hour with nothing to publish. Needs the Worker secret GITHUB_PUBLISH_TOKEN: a GitHub token with
+// Contents: Read and write on the repository (docs/editor.md, Opsætning; packages/editor/worker/github.js).
+import { commitFiles, readFiles } from './github.js';
+import { isDue, nameOf, published, scheduleOf } from '../lib/scheduled.mjs';
+
+/** The address of the build's list; on the site it gives nothing (packages/editor/worker/index.js). */
+export const SCHEDULED_LIST = '/_scheduled.json';
+
+export async function publishScheduled(env, now = Date.now()) {
+  const due = (await listOf(env)).filter((e) => isDue(e.publishAt, now));
+  if (!due.length) return [];
+  if (!env.GITHUB_PUBLISH_TOKEN) {
+    console.error('Planlagte sider og indlæg kan ikke udgives: Workeren mangler hemmeligheden GITHUB_PUBLISH_TOKEN.');
+    return [];
+  }
+  // The files as they are now (one may have been published or changed since the build).
+  const { head, texts } = await readFiles(
+    env,
+    due.map((e) => e.path),
+  );
+  const changes = due
+    .map((e, i) => ({ path: e.path, text: texts[i] }))
+    .filter(({ text }) => {
+      const file = scheduleOf(text ?? '');
+      return file.status === 'scheduled' && isDue(file.publishAt, now);
+    });
+  if (!changes.length) return [];
+  const names = changes.map((c) => nameOf(c.path));
+  await commitFiles(
+    env,
+    head,
+    `Udgiv planlagt: ${names.join(', ')}`,
+    changes.map((c) => ({ path: c.path, text: published(c.text) })),
+  );
+  console.log(`Udgivet: ${names.join(', ')}`);
+  return names;
+}
+
+// The build's list; none (a build before the list, or a preview) is nothing to publish.
+async function listOf(env) {
+  try {
+    const res = await env.ASSETS.fetch(new Request(`https://assets.local${SCHEDULED_LIST}`));
+    const list = res.ok ? await res.json() : [];
+    return Array.isArray(list) ? list : [];
+  } catch {
+    return [];
+  }
+}