@morphemecms/cms 0.5.0 → 0.7.0

package/lib/text-sections.test.mjs

@@ -0,0 +1,78 @@
+// Tests lib/text-sections.mjs: a text's HTML cut into coloured and uncoloured runs, and the marker as the site's real
+// Markdown pipeline (rehype-raw, as in astro.mjs) writes it. Run with `node --test packages/editor/lib/text-sections.test.mjs`.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createMarkdownProcessor } from '@astrojs/markdown-remark';
+import rehypeRaw from 'rehype-raw';
+import { sectionClass, sectionsOf } from './text-sections.mjs';
+
+const M = (color) => `<div data-section="${color}"></div>`;
+
+test('html without markers passes through unchanged, in one run', () => {
+  const html = '<h1>T</h1>\n<p>a</p>\n<h2 id="x">X</h2>\n<p>b</p>';
+  assert.deepEqual(sectionsOf(html), [{ color: null, html }]);
+  assert.deepEqual(sectionsOf(''), [{ color: null, html: '' }]);
+});
+
+test('a coloured run goes from its marker to the next h2, markers removed', () => {
+  const html = `<p>Intro</p>\n${M('tint')}\n<h2 id="a">A</h2>\n<p>One</p>\n<h2 id="b">B</h2>\n<p>Two</p>`;
+  assert.deepEqual(sectionsOf(html), [
+    { color: null, html: '<p>Intro</p>\n' },
+    { color: 'tint', html: '<h2 id="a">A</h2>\n<p>One</p>\n' },
+    { color: null, html: '<h2 id="b">B</h2>\n<p>Two</p>' },
+  ]);
+});
+
+test('a run goes on to the end of the text, and over an h3 and blocks', () => {
+  const html = `${M('surface')}\n<h2>A</h2>\n<h3>s</h3>\n<div data-block="faq"></div>\n<p>x</p>`;
+  assert.deepEqual(sectionsOf(html), [{ color: 'surface', html: '<h2>A</h2>\n<h3>s</h3>\n<div data-block="faq"></div>\n<p>x</p>' }]);
+});
+
+test('a run ends at an h1', () => {
+  const html = `${M('tint')}\n<h2>A</h2>\n<p>x</p>\n<h1>Big</h1>\n<p>y</p>`;
+  assert.deepEqual(sectionsOf(html), [
+    { color: 'tint', html: '<h2>A</h2>\n<p>x</p>\n' },
+    { color: null, html: '<h1>Big</h1>\n<p>y</p>' },
+  ]);
+});
+
+test('two coloured sections after each other are two runs', () => {
+  const html = `${M('tint')}\n<h2>A</h2>\n<p>x</p>\n${M('accent')}\n<h2>B</h2>\n<p>y</p>`;
+  assert.deepEqual(sectionsOf(html), [
+    { color: 'tint', html: '<h2>A</h2>\n<p>x</p>\n' },
+    { color: 'accent', html: '<h2>B</h2>\n<p>y</p>' },
+  ]);
+});
+
+test('a label line between the marker and the h2 belongs to the section, and the next label starts the next', () => {
+  const html = `${M('tint')}\n<p class="block-eyebrow">Hours</p>\n<h2>A</h2>\n<p>x</p>\n<p class="block-eyebrow">Next</p>\n<h2>B</h2>`;
+  assert.deepEqual(sectionsOf(html), [
+    { color: 'tint', html: '<p class="block-eyebrow">Hours</p>\n<h2>A</h2>\n<p>x</p>\n' },
+    { color: null, html: '<p class="block-eyebrow">Next</p>\n<h2>B</h2>' },
+  ]);
+});
+
+test('an unknown colour is dropped, the text stays', () => {
+  assert.deepEqual(sectionsOf(`${M('pink')}\n<h2>A</h2>\n<p>x</p>`), [{ color: null, html: '<h2>A</h2>\n<p>x</p>' }]);
+});
+
+test('a marker not followed by an h2 is dropped', () => {
+  assert.deepEqual(sectionsOf(`<p>a</p>\n${M('tint')}\n<p>b</p>\n<h2>c</h2>`), [{ color: null, html: '<p>a</p>\n<p>b</p>\n<h2>c</h2>' }]);
+  assert.deepEqual(sectionsOf(`<p>a</p>\n${M('tint')}\n<h3>c</h3>`), [{ color: null, html: '<p>a</p>\n<h3>c</h3>' }]);
+});
+
+test('the class of a coloured section', () => {
+  assert.equal(sectionClass('tint'), 'text-section text-section-tint');
+});
+
+test("in Astro's pipeline the marker comes out as the matcher reads it", async () => {
+  const processor = await createMarkdownProcessor({ rehypePlugins: [rehypeRaw] });
+  const { code } = await processor.render(`Intro\n\n${M('tint')}\n\n## Opening hours\n\nMon–Fri\n\n## Contact\n\nCall`);
+  assert.ok(code.includes(M('tint')), code);
+  const runs = sectionsOf(code);
+  assert.deepEqual(
+    runs.map((r) => r.color),
+    [null, 'tint', null],
+  );
+  assert.ok(runs[1].html.startsWith('<h2') && runs[1].html.includes('Mon–Fri') && !runs[1].html.includes('Contact'), runs[1].html);
+});

package/lib/video.mjs

@@ -8,6 +8,7 @@
 // from the video, from the site itself (packages/editor/scripts/video-thumbnails.mjs), when it could be fetched.
 import fs from 'node:fs';
 import path from 'node:path';
+import { BREAKPOINTS } from './breakpoints.mjs';
 import { svgHtml } from './svg.mjs';
 import { player, stillName, videoOf, videoPage } from './video-id.mjs';
 
@@ -26,7 +27,7 @@ const unescapeHtml = (s) => s.replace(/&(amp|lt|gt|quot|#39);/g, (_, e) => ({ am
 function facade(video, title, frame, play) {
   const { href, player, title: name, still } = facadeOf(video, title, frame);
   const image = still
-    ? `<img class="video-facade-image" src="${still.src}" srcset="${still.srcset}" sizes="(min-width: 768px) 720px, 100vw" alt="" loading="lazy" decoding="async">`
+    ? `<img class="video-facade-image" src="${still.src}" srcset="${still.srcset}" sizes="(min-width: ${BREAKPOINTS.expanded}px) 720px, 100vw" alt="" loading="lazy" decoding="async">`
     : '';
   return (
     `<a class="video-facade${image ? ' video-facade-still' : ''}" href="${escapeHtml(href)}" data-video="${escapeHtml(player)}" data-title="${escapeHtml(name)}">` +

package/lib/without-h1.d.mts

@@ -0,0 +1 @@
+export function withoutH1(html: string): string;

package/lib/without-h1.mjs

@@ -0,0 +1,7 @@
+// A page's text as HTML without its H1, which the layout draws in its own place (above the picture, PageLayout.astro).
+// Exposes withoutH1 (pure); the H1 is the first one wherever it stands, as pageH1 (src/sections.mjs) reads it. No dependencies.
+
+/** The html without its first <h1>…</h1> and the white space after it.
+ * @param {string} html
+ * @returns {string} */
+export const withoutH1 = (html) => html.replace(/<h1\b[^>]*>[\s\S]*?<\/h1>\s*/, '');

package/lib/without-h1.test.mjs

@@ -0,0 +1,26 @@
+// Tests lib/without-h1.mjs: the first <h1> of a page's rendered text is taken out, wherever it is.
+// Run with `node --test packages/editor/lib/*.test.mjs` (part of npm run check).
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { withoutH1 } from './without-h1.mjs';
+
+test('an H1 at the top is taken out, with the space after it', () => {
+  assert.equal(withoutH1('<h1 id="title">Title</h1>\n<p>Text</p>'), '<p>Text</p>');
+});
+
+test('an H1 after other parts is taken out where it is', () => {
+  assert.equal(withoutH1('<p>Intro</p>\n<h1 id="t">Title</h1>\n<h2>Section</h2>'), '<p>Intro</p>\n<h2>Section</h2>');
+});
+
+test('an H1 with a coloured word is taken out whole', () => {
+  assert.equal(withoutH1('<h1>One <span class="color-accent">two</span></h1><p>x</p>'), '<p>x</p>');
+});
+
+test('only the first H1 goes', () => {
+  assert.equal(withoutH1('<h1>A</h1><p>x</p><h1>B</h1>'), '<p>x</p><h1>B</h1>');
+});
+
+test('without an H1 the html is as it was', () => {
+  assert.equal(withoutH1('<p>Text</p><h2>Section</h2>'), '<p>Text</p><h2>Section</h2>');
+  assert.equal(withoutH1('<header>x</header>'), '<header>x</header>');
+});

package/lib/word-at.d.mts

@@ -0,0 +1,6 @@
+/** The word `text` has at `offset` (a place between two characters), as offsets in `text`, or null when there is no
+ * word on either side of it. wordAt('How saving works', 6) is { from: 4, to: 10 }. */
+export function wordAt(text: any, offset: any): {
+    from: any;
+    to: any;
+} | null;

package/lib/word-at.mjs

@@ -0,0 +1,20 @@
+// The word around a place in a line of text (the menu over a text at a still cursor, src/stillCursor.mjs): letters,
+// digits, apostrophes and hyphens, without the apostrophes and hyphens at its ends. Exposes wordAt. No dependencies,
+// no browser.
+
+const IN_WORD = /[\p{L}\p{M}\p{N}_'’-]/u;
+const LETTER = /[\p{L}\p{N}]/u;
+
+/** The word `text` has at `offset` (a place between two characters), as offsets in `text`, or null when there is no
+ * word on either side of it. wordAt('How saving works', 6) is { from: 4, to: 10 }. */
+export function wordAt(text, offset) {
+  const inWord = (i) => i >= 0 && i < text.length && IN_WORD.test(text[i]);
+  if (!inWord(offset - 1) && !inWord(offset)) return null;
+  let from = offset;
+  let to = offset;
+  while (inWord(from - 1)) from--;
+  while (inWord(to)) to++;
+  while (from < to && !LETTER.test(text[from])) from++;
+  while (to > from && !LETTER.test(text[to - 1])) to--;
+  return from < to ? { from, to } : null;
+}

package/lib/word-at.test.mjs

@@ -0,0 +1,19 @@
+// Tests for lib/word-at.mjs: the word around a place in a line of text. Run: node --test packages/editor/lib/*.test.mjs packages/editor/src/*.test.mjs
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { wordAt } from './word-at.mjs';
+
+test('inside a word', () => assert.deepEqual(wordAt('How saving works', 6), { from: 4, to: 10 }));
+test('at the start of a word', () => assert.deepEqual(wordAt('How saving works', 4), { from: 4, to: 10 }));
+test('at the end of a word', () => assert.deepEqual(wordAt('How saving works', 10), { from: 4, to: 10 }));
+test('between two spaces', () => assert.equal(wordAt('How  saving', 4), null));
+test('after a full stop', () => assert.equal(wordAt('works.', 6), null));
+test('before a full stop', () => assert.deepEqual(wordAt('works.', 5), { from: 0, to: 5 }));
+test('an apostrophe and a hyphen are inside a word', () => {
+  assert.deepEqual(wordAt("don't", 2), { from: 0, to: 5 });
+  assert.deepEqual(wordAt('e-mail', 1), { from: 0, to: 6 });
+});
+test('quotes around a word are not part of it', () => assert.deepEqual(wordAt("'hi'", 2), { from: 1, to: 3 }));
+test('Danish letters', () => assert.deepEqual(wordAt('Gem ændringer', 6), { from: 4, to: 13 }));
+test('a lone hyphen is no word', () => assert.equal(wordAt('a - b', 3), null));
+test('an empty text', () => assert.equal(wordAt('', 0), null));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morphemecms/cms",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Morpheme CMS: the editor for a site built with Astro, its screens, its blocks and the rules a site gives it. See README.md.",
   "license": "MIT",
   "author": "Lars Adolfsen",
@@ -53,6 +53,7 @@
     "@astrojs/rss": "^4.0.19",
     "@astrojs/sitemap": "^3.7.4",
     "@fontsource-variable/roboto": "^5.3.0",
+    "@material-symbols/svg-400": "0.48.2",
     "@material/material-color-utilities": "^0.3.0",
     "@milkdown/kit": "^7.22.3",
     "@phosphor-icons/core": "^2.1.1",
@@ -108,6 +109,7 @@
     "@changesets/changelog-git": "^1.0.0",
     "@changesets/cli": "^3.0.3",
     "@fontsource-variable/roboto": "^5.3.0",
+    "@material-symbols/svg-400": "0.48.2",
     "@material/material-color-utilities": "^0.3.0",
     "@milkdown/kit": "^7.22.3",
     "@phosphor-icons/core": "^2.1.1",

package/pages/editor/version.json.js

@@ -3,9 +3,24 @@
 // until it is the saved commit (or a later one), and then says that the site has been updated.
 // Cloudflare's builds set WORKERS_CI_COMMIT_SHA; a build elsewhere asks git. `editor` is the
 // fingerprint of the editor's code (packages/editor/site/editor-version.mjs): an open editor with another one
-// reloads itself.
+// reloads itself. `paidBuilds` (src/data/build.json, packages/editor/lib/build-settings.mjs) is how long the editor waits for
+// a build before it says it failed: 20 minutes on the free plan, 10 on Workers Paid.
 import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
 import { editorVersion } from '@morphemecms/cms/site/editor-version.mjs';
+import { BUILD_SETTINGS_PATH, readBuildSettings } from '../../lib/build-settings.mjs';
+
+// From where the build runs, as packages/editor/site/images.mjs (this file is bundled elsewhere first).
+const SETTINGS = path.resolve(BUILD_SETTINGS_PATH);
+
+function paidBuilds() {
+  try {
+    return readBuildSettings(JSON.parse(fs.readFileSync(SETTINGS, 'utf8'))).paidBuilds;
+  } catch {
+    return readBuildSettings(undefined).paidBuilds;
+  }
+}
 
 function head() {
   try {
@@ -17,6 +32,11 @@ function head() {
 
 export function GET() {
   return new Response(
-    JSON.stringify({ commit: process.env.WORKERS_CI_COMMIT_SHA || head(), editor: editorVersion(), builtAt: new Date().toISOString() }),
+    JSON.stringify({
+      commit: process.env.WORKERS_CI_COMMIT_SHA || head(),
+      editor: editorVersion(),
+      builtAt: new Date().toISOString(),
+      paidBuilds: paidBuilds(),
+    }),
   );
 }

package/scripts/already-checked.mjs

@@ -0,0 +1,11 @@
+// Whether check:content already ran for this commit (morpheme ci-build sets MORPHEME_CONTENT_CHECKED before the build).
+// Exposes alreadyChecked. No dependencies; apart from check-content.mjs so a test can import it without running the check.
+
+/**
+ * @param {string | undefined} envValue the MORPHEME_CONTENT_CHECKED variable
+ * @param {string} head `git rev-parse HEAD`
+ * @returns {boolean} true only when the variable is the commit being built
+ */
+export function alreadyChecked(envValue, head) {
+  return typeof envValue === 'string' && envValue !== '' && envValue === head;
+}

package/scripts/already-checked.test.mjs

@@ -0,0 +1,18 @@
+// Tests for scripts/already-checked.mjs: alreadyChecked() skips check:content in the build only when ci-build has run it
+// for exactly this commit. Run: node --test packages/editor/scripts/*.test.mjs
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { alreadyChecked } from './already-checked.mjs';
+
+const head = 'a'.repeat(40);
+
+test('alreadyChecked is true for the same sha', () => {
+  assert.equal(alreadyChecked(head, head), true);
+});
+
+test('alreadyChecked is false for another sha, an empty string or undefined', () => {
+  assert.equal(alreadyChecked('b'.repeat(40), head), false);
+  assert.equal(alreadyChecked('', head), false);
+  assert.equal(alreadyChecked(undefined, head), false);
+  assert.equal(alreadyChecked('', ''), false);
+});

package/scripts/build-settings-problems.mjs

@@ -0,0 +1,27 @@
+// The check of the build settings file (src/data/build.json, Indstillinger › Avanceret): an object with only the
+// boolean keys contentLane and paidBuilds. Exposes buildSettingsProblems; used by check-content.mjs. No dependencies.
+
+const KEYS = ['contentLane', 'paidBuilds'];
+
+/**
+ * @param {string} path the file's path, for the messages
+ * @param {string | undefined} text the file's text, or undefined when it is missing (which passes)
+ * @returns {string[]} what is wrong with the file, one line each
+ */
+export function buildSettingsProblems(path, text) {
+  if (text === undefined) return [];
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch (e) {
+    return [`${path}: er ikke gyldig JSON (${e.message})`];
+  }
+  if (typeof json !== 'object' || json === null || Array.isArray(json)) return [`${path}: skal være et objekt med ${KEYS.join(' og ')}`];
+  return Object.entries(json).flatMap(([key, value]) =>
+    !KEYS.includes(key)
+      ? [`${path}: kender ikke nøglen "${key}" (kun ${KEYS.join(' og ')})`]
+      : typeof value !== 'boolean'
+        ? [`${path}: "${key}" skal være true eller false`]
+        : [],
+  );
+}

package/scripts/build-settings-problems.test.mjs

@@ -0,0 +1,35 @@
+// Tests buildSettingsProblems (build-settings-problems.mjs): the build settings file passes when it is missing or an
+// object with only boolean contentLane and paidBuilds, and is reported otherwise.
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { buildSettingsProblems } from './build-settings-problems.mjs';
+
+const PATH = 'src/data/build.json';
+
+test('a missing file passes', () => {
+  assert.deepEqual(buildSettingsProblems(PATH, undefined), []);
+});
+
+test('both keys, one key and an empty object pass', () => {
+  assert.deepEqual(buildSettingsProblems(PATH, '{ "contentLane": true, "paidBuilds": false }'), []);
+  assert.deepEqual(buildSettingsProblems(PATH, '{ "paidBuilds": true }'), []);
+  assert.deepEqual(buildSettingsProblems(PATH, '{}'), []);
+});
+
+test('an unknown key is reported', () => {
+  const problems = buildSettingsProblems(PATH, '{ "contentLane": true, "fastLane": true }');
+  assert.equal(problems.length, 1);
+  assert.match(problems[0], /fastLane/);
+  assert.match(problems[0], new RegExp(PATH));
+});
+
+test('a value that is not a boolean is reported', () => {
+  const problems = buildSettingsProblems(PATH, '{ "contentLane": "yes", "paidBuilds": 1 }');
+  assert.equal(problems.length, 2);
+  assert.match(problems[0], /contentLane/);
+  assert.match(problems[1], /paidBuilds/);
+});
+
+test('JSON that is not an object, or not JSON, is reported', () => {
+  for (const text of ['[]', 'true', 'null', '"x"', '{ nope']) assert.equal(buildSettingsProblems(PATH, text).length, 1, text);
+});

package/scripts/check-content.mjs

@@ -3,9 +3,12 @@
 // (checkSite.ts in the editor, packages/editor/). Stops with what is wrong, so a broken page never goes
 // out; the site that is out stays as it is; among it every theme (themeProblems, with the icon packs it brings) and
 // the system's icon packs and the choice of one (iconPackProblems), and so an icon the site or the editor draws that a
-// pack has none for, and the choice of motion scheme (motionProblems). Says too which of the site's texts the
+// pack has none for, and the choice of motion scheme (motionProblems), and names in a folder that differ only in case
+// (casingProblems). Says too which of the site's texts the
 // editor has no translation of (@site/texts, a block's texts.ts); that does not stop the build. The editor's
-// code is TypeScript and TSX, so it is loaded with Vite, as the site's own build does.
+// code is TypeScript and TSX, so it is loaded with Vite, as the site's own build does. Exits early, without checking, when
+// MORPHEME_CONTENT_CHECKED names the commit being built (morpheme ci-build already ran it; already-checked.mjs).
+import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -24,7 +27,26 @@ import {
 import { appFoldersPlugin, appIds, appWorkersProblems } from '@morphemecms/cms/lib/apps.mjs';
 import { caseCollisionProblems } from '@morphemecms/cms/lib/caseCollisions.mjs';
 import { codePackageProblems, declarationProblems, ownerId } from '@morphemecms/cms/lib/licenses.mjs';
+import { breakpointProblems } from '@morphemecms/cms/site/breakpoints.mjs';
+import { casingProblems } from '../site/casing.mjs';
+import { BUILD_SETTINGS_PATH } from '../lib/build-settings.mjs';
+import { buildSettingsProblems } from './build-settings-problems.mjs';
+import { textProblems } from './text-problems.mjs';
 import { notesOf, releaseProblems } from './releases.mjs';
+import { alreadyChecked } from './already-checked.mjs';
+
+// morpheme ci-build has run this check for the commit being built.
+// Git is asked only then; no repository or no commit yet means "not checked".
+if (process.env.MORPHEME_CONTENT_CHECKED) {
+  let head = '';
+  try {
+    head = execFileSync('git', ['rev-parse', 'HEAD'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+  } catch {}
+  if (alreadyChecked(process.env.MORPHEME_CONTENT_CHECKED, head)) {
+    console.log(`check:content already ran for ${head.slice(0, 7)}`);
+    process.exit(0);
+  }
+}
 
 const root = `${process.cwd()}/`;
 // This package's own code, from the site's root (packages/editor/ or node_modules/@morphemecms/cms/).
@@ -38,7 +60,7 @@ const files = ['src/content', 'src/data']
   .flatMap((dir) =>
     readdirSync(dir, { recursive: true, withFileTypes: true })
       .filter((e) => e.isFile() && /\.(md|json)$/.test(e.name))
-      .map((e) => join(e.parentPath, e.name)),
+      .map((e) => join(e.parentPath, e.name).replaceAll('\\', '/')),
   )
   .concat([config.siteRedirects.rules, config.siteRedirects.map])
   .map((path) => ({ path, text: readFileSync(path, 'utf8') }));
@@ -52,7 +74,7 @@ const server = await createServer({
   resolve: { alias: aliases() },
   server: { middlewareMode: true, hmr: false, ws: false },
 });
-let result, missing;
+let result, missing, enTexts;
 // The licences ("Licenser" under "Indstillinger", @morphemecms/cms/lib/licenses.mjs): each app's own and those of the
 // third-party work it brings (its defineApp), installed or not, as each theme's (themeProblems), with the packages they
 // declare, which they give what a package lacks for.
@@ -65,6 +87,8 @@ try {
   const { problemsOf, untranslated } = await server.ssrLoadModule('@morphemecms/cms/src/checkSite.ts');
   result = problemsOf(files);
   missing = untranslated();
+  // The editor's English texts against Material 3's rules for writing (text-problems.mjs).
+  enTexts = textProblems((await server.ssrLoadModule('@morphemecms/cms/src/i18n/en-US/index.ts')).enUS);
   if (existsSync('store/catalog.json')) catalog = JSON.parse(readFileSync('store/catalog.json', 'utf8'));
   for (const id of appIds(root)) {
     const app = (await server.ssrLoadModule(`/src/apps/${id}/index.ts`)).default;
@@ -103,11 +127,14 @@ for (const [locale, files] of Object.entries(missing)) {
   }
 }
 
+// The editor's English texts follow Material 3's rules for writing (text-problems.mjs).
+result.problems.push(...enTexts);
 // Every theme installed has what a theme must have (the standard theme all of it), so the owner can swap to any of them
 // on "Udseende".
 result.problems.push(...installedThemes().flatMap(themeProblems), ...iconPackProblems(), ...motionProblems());
 // Every block is drawn from its view, on the site and in the editor alike.
 result.problems.push(...blockProblems());
+result.problems.push(...breakpointProblems(root));
 // What each app loads from elsewhere is in its csp.json, so the pages' Content-Security-Policy lets it through.
 result.problems.push(...appCspProblems());
 // The addresses allowed in the editor after the policy stopped them are written as an app's csp.json.
@@ -141,6 +168,17 @@ for (const theme of installedThemes()) {
     );
 }
 result.problems.push(...releases);
+// No two names in a folder differ only in case, so the site builds on Windows and macOS too (casing.mjs). From git's
+// list of the files; a site that is no git repository (a fresh starter) has none to give.
+let tracked = [];
+try {
+  tracked = execFileSync('git', ['ls-files'], { cwd: root, encoding: 'utf8' }).split('\n').filter(Boolean);
+} catch {}
+result.problems.push(...casingProblems(tracked));
+// The build settings the editor writes under "Avanceret": only boolean contentLane and paidBuilds; a missing file passes.
+result.problems.push(
+  ...buildSettingsProblems(BUILD_SETTINGS_PATH, existsSync(BUILD_SETTINGS_PATH) ? readFileSync(BUILD_SETTINGS_PATH, 'utf8') : undefined),
+);
 
 if (result.problems.length) {
   console.error(`\nIndholdet følger ikke editorens regler (${result.problems.length}):\n`);

package/scripts/check-worker.mjs

@@ -4,7 +4,7 @@
 // as GitHub's GraphQL and REST APIs give it), with R2 in memory. With the cache, without it (no binding FILES) and
 // with an R2 that fails, the editor must get exactly the files git has, save, see the versions and the deleted files
 // and restore them; with the cache, an opening after a save may ask GitHub for nothing but the branch's head, and
-// everything in R2 must give its git id. Nothing goes to GitHub or Cloudflare. Run: npm run check:worker
+// everything in R2 must give its git id. /api/r2 and /api/plan must say what Cloudflare says. Nothing goes to GitHub or Cloudflare. Run: npm run check:worker
 import { execFileSync } from 'node:child_process';
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
@@ -58,7 +58,8 @@ const out = (...args) => git(args).toString().trim();
 execFileSync('git', ['init', '-q', '-b', branch, REPO], { env: ownRepoEnv() });
 const tarball = join(REPO, '.git', 'head.tar');
 execFileSync('git', ['-C', ROOT, 'archive', '-o', tarball, 'HEAD']);
-execFileSync('tar', ['-x', '-f', tarball, '-C', REPO]);
+// From inside the folder, by a relative path: GNU tar (Git's on Windows) reads C:\… as a remote host's file.
+execFileSync('tar', ['-x', '-f', join('.git', 'head.tar')], { cwd: REPO });
 rmSync(tarball);
 git(['add', '-A']);
 git(['commit', '-q', '-m', 'Start']);
@@ -213,6 +214,8 @@ const requests = [];
 let cloudflare = [500, {}];
 let cloudflareJurisdiction = null;
 let r2Env = {};
+// Cloudflare's answer about the account's subscriptions, for /api/plan ([status, body]).
+let subscriptions = [500, {}];
 async function github(url, init) {
   asked++;
   requests.push(`${url} ${init.body ?? ''}`);
@@ -228,7 +231,12 @@ async function github(url, init) {
 // ---------------------------------------------------------------------------------------------------
 // The Worker, with R2 in memory (or none, or one that fails), and the editor's github.ts in a "browser" whose
 // requests to /api/github/ go to it, signed in.
-const [{ handleGitHub }, { readFiles, commitFiles }, { handleR2 }] = await workerModules('editor-github.js', 'github.js', 'r2-status.js');
+const [{ handleGitHub }, { readFiles, commitFiles }, { handleR2 }, { handlePlan, paidFrom }] = await workerModules(
+  'editor-github.js',
+  'github.js',
+  'r2-status.js',
+  'plan-status.js',
+);
 
 function memoryBucket() {
   const objects = new Map();
@@ -280,6 +288,8 @@ globalThis.fetch = async (input, init = {}) => {
     return new Headers(init.headers).get('cf-r2-jurisdiction') === cloudflareJurisdiction
       ? Response.json(cloudflare[1], { status: cloudflare[0] })
       : Response.json({ success: false, errors: [{ code: 10006, message: 'The specified bucket does not exist.' }] }, { status: 404 });
+  if (url === 'https://api.cloudflare.com/client/v4/accounts/account/subscriptions')
+    return Response.json(subscriptions[1], { status: subscriptions[0] });
   if (!url.startsWith('/api/github/')) return new Response(null, { status: 404 });
   const request = new Request(`https://editor.example${url}`, {
     ...init,
@@ -313,7 +323,7 @@ await build({
   ],
 });
 let browsers = 0;
-const browser = () => import(`${bundle}?${browsers++}`);
+const browser = () => import(`${pathToFileURL(bundle).href}?${browsers++}`);
 
 // ---------------------------------------------------------------------------------------------------
 // What git has, as the editor had it before: each file in a folder `depth` levels down, with its text ('' for binary).
@@ -542,6 +552,44 @@ try {
     expect(other.status === 403, `/api/r2 svarede en anden side med ${other.status}, ikke 403`);
   }
 
+  // /api/plan (packages/editor/worker/plan-status.js): whether the account has Workers Paid, for "Betalt bygning".
+  {
+    const plan = (id, state) => ({ rate_plan: { id }, ...(state === undefined ? {} : { state }) });
+    expect(paidFrom([plan('WORKERS_PAID', 'Paid')]) === true, 'paidFrom: WORKERS_PAID med store bogstaver er ikke betalt');
+    expect(paidFrom([plan('workers_paid')]) === true, 'paidFrom: workers_paid uden tilstand er ikke betalt');
+    expect(paidFrom([plan('workers_paid', 'trial')]) === true, 'paidFrom: en prøveperiode er ikke betalt');
+    expect(paidFrom([plan('workers_paid', 'Cancelled')]) === false, 'paidFrom: en opsagt plan er betalt');
+    expect(paidFrom([plan('cf_free', 'Paid'), plan('zone_pro', 'Paid')]) === false, 'paidFrom: en zoneplan er Workers Paid');
+    expect(
+      paidFrom(undefined) === false && paidFrom({}) === false && paidFrom(null) === false,
+      'paidFrom: noget, der ikke er en liste, er betalt',
+    );
+    const signedIn = { cookie: 'editor_session=token', 'sec-fetch-site': 'same-origin' };
+    const askPlan = (headers = signedIn, method = 'GET') =>
+      handlePlan(new Request('https://editor.example/api/plan', { headers, method }), r2Env).then(async (r) => ({
+        status: r.status,
+        ...(await r.json()),
+      }));
+    const keyed = { CLOUDFLARE_ACCOUNT_ID: 'account', CLOUDFLARE_R2_TOKEN: 'key' };
+    r2Env = {};
+    expect((await askPlan()).paid === 'no-key', '/api/plan uden Workerens nøgle sagde ikke no-key');
+    r2Env = keyed;
+    subscriptions = [403, { success: false, errors: [{ code: 10000, message: 'Authentication error' }] }];
+    expect((await askPlan()).paid === 'refused', '/api/plan sagde ikke refused, da Cloudflare svarede 403');
+    subscriptions = [500, { success: false, errors: [] }];
+    expect((await askPlan()).paid === 'failed', '/api/plan sagde ikke failed, da Cloudflare svarede 500');
+    subscriptions = [200, { success: true, errors: [], result: [plan('WORKERS_PAID', 'Paid')] }];
+    expect((await askPlan()).paid === 'yes', '/api/plan sagde ikke yes med Workers Paid');
+    subscriptions = [200, { success: true, errors: [], result: [plan('cf_free', 'Paid')] }];
+    expect((await askPlan()).paid === 'no', '/api/plan sagde ikke no uden Workers Paid');
+    expect(
+      (await askPlan({ cookie: 'editor_session=token', 'sec-fetch-site': 'same-site' })).status === 403,
+      '/api/plan svarede en anden side ikke med 403',
+    );
+    expect((await askPlan(signedIn, 'POST')).status === 405, '/api/plan svarede en POST ikke med 405');
+    r2Env = {};
+  }
+
   // Everything in R2 is the repository's, gives its git id, and was written once.
   for (const [key, value] of bucket.objects) {
     const [o, r, kind, oid] = key.split('/');
@@ -554,6 +602,50 @@ try {
   for (const [key, n] of bucket.puts) expect(n === 1, `R2: ${key} blev skrevet ${n} gange`);
   for (const oid of truncated)
     expect(!bucket.objects.has(`${owner}/${name}/blob/${oid}`), `R2: en fil, GitHub kun gav en del af, blev gemt`);
+
+  // How long a wait for a build lasts (packages/editor/worker/push.js waitForBuilds, build-settings.mjs giveUpAfter): a wait of
+  // 15 minutes is still waiting when version.json has no paidBuilds (free plan: 20 minutes), is given up with
+  // paidBuilds: true (10 minutes), and every wait is given up after 20.
+  {
+    const [{ waitForBuilds }] = await workerModules('push.js');
+    const minute = 60_000;
+    const now = Date.now();
+    const commit = 'a'.repeat(40);
+    const kv = (waits) => {
+      const store = new Map(waits.map(([key, at]) => [key, { metadata: { commit, device: key, at: new Date(at).toISOString() } }]));
+      store.set('waiting', { value: String(now + 30 * minute) });
+      return {
+        store,
+        get: async (key) => store.get(key)?.value ?? null,
+        put: async () => {},
+        delete: async (key) => void store.delete(key),
+        list: async ({ prefix }) => ({
+          keys: [...store].filter(([key]) => key.startsWith(prefix)).map(([name, { metadata }]) => ({ name, metadata })),
+        }),
+      };
+    };
+    // A build from before the saves, so none of them is on the site.
+    const assets = (paid) => ({
+      fetch: async () =>
+        Response.json({
+          commit: 'b'.repeat(40),
+          builtAt: new Date(now - 60 * minute).toISOString(),
+          ...(paid === undefined ? {} : { paidBuilds: paid }),
+        }),
+    });
+    for (const [paid, minutes, waiting] of [
+      [undefined, 15, true],
+      [false, 15, true],
+      [true, 15, false],
+      [undefined, 25, false],
+      [true, 25, false],
+    ]) {
+      const PUSH = kv([['wait:x', now - minutes * minute]]);
+      await waitForBuilds({ PUSH, ASSETS: assets(paid) }, now);
+      const label = `et ventende gem på ${minutes} minutter, paidBuilds ${paid}`;
+      expect(PUSH.store.has('wait:x') === waiting, `${label}: ${waiting ? 'blev opgivet for tidligt' : 'blev ikke opgivet'}`);
+    }
+  }
 } finally {
   console.log = log;
   rmSync(WORK, { recursive: true, force: true });