@morphemecms/cms 0.5.0 → 0.7.0

package/scripts/ci-build.mjs

@@ -0,0 +1,85 @@
+// `morpheme ci-build`, the Cloudflare build command: takes the content lane (Prettier on the changed files, the editor's
+// checks, the build) when only content changed since the live commit, else the full lane (npm run check, the build).
+// Exposes decideLane; running the file does the build. Depends on lib/build-lane.mjs, site/live-diff.mjs, step-command.mjs.
+import { execFileSync, spawnSync } from 'node:child_process';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { BUILD_SETTINGS_PATH, readBuildSettings } from '../lib/build-settings.mjs';
+import { laneFor } from '../lib/build-lane.mjs';
+import { changedSinceLive } from '../site/live-diff.mjs';
+import { stepCommand } from './step-command.mjs';
+
+/**
+ * @param {object} o
+ * @param {string} o.cwd the site's root; must be the working directory too, as the site config is loaded from there
+ * @param {typeof globalThis.fetch} [o.fetch]
+ * @param {NodeJS.ProcessEnv} [o.env]
+ * @returns {Promise<{ lane: 'content' | 'full', reason: string, paths: string[] | null }>} any doubt gives the full lane.
+ */
+export async function decideLane({ cwd, fetch = globalThis.fetch, env = process.env }) {
+  let settings;
+  try {
+    const file = join(cwd, BUILD_SETTINGS_PATH);
+    settings = readBuildSettings(existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : undefined);
+  } catch {
+    return { ...laneFor(null, { contentLane: true }, `${BUILD_SETTINGS_PATH} unreadable`), paths: null };
+  }
+  let config;
+  try {
+    // Loaded as check-content.mjs does, from the site's root (siteConfig.mjs reads the working directory).
+    ({ config } = await import('../site/siteConfig.mjs'));
+    if (!config?.domain || !config?.repo?.branch) throw new Error('no domain or branch');
+  } catch {
+    return { ...laneFor(null, settings, 'site config unknown'), paths: null };
+  }
+  const { paths, reason } = await changedSinceLive({
+    siteUrl: 'https://' + config.domain,
+    cwd,
+    fetch,
+    branch: env.WORKERS_CI_BRANCH,
+    repoBranch: config.repo.branch,
+  });
+  return { ...laneFor(paths, settings, reason), paths };
+}
+
+/** Runs a command with the output shown and stops the build with its exit code when it fails. */
+function step(tool, args, env = process.env) {
+  console.log(`ci-build: ${[tool, ...args].join(' ')}`);
+  const [command, commandArgs] = stepCommand(tool, args, { env });
+  const { status } = spawnSync(command, commandArgs, { stdio: 'inherit', env });
+  if (status !== 0) process.exit(status ?? 1);
+}
+
+async function main() {
+  const cwd = process.cwd();
+  const { lane, reason, paths } = await decideLane({ cwd });
+  console.log(`ci-build: ${lane} lane — ${reason}`);
+  if (lane === 'full') {
+    step('npm', ['run', 'check']);
+  } else {
+    const existing = paths.filter((path) => existsSync(join(cwd, path)));
+    if (existing.length > 0) step('prettier', ['--check', '--ignore-unknown', ...existing]);
+    step('npm', ['run', 'check:content']);
+    step('npm', ['run', 'check:editor']);
+  }
+  const head = execFileSync('git', ['rev-parse', 'HEAD'], { cwd, encoding: 'utf8' }).trim();
+  step('npm', ['run', 'build'], { ...process.env, MORPHEME_CONTENT_CHECKED: head });
+}
+
+/**
+ * Whether the module at `metaUrl` is the script Node was started with. Both sides go through realpath, so symlinks, a
+ * relative argv[1] and a drive letter's case (Windows) cannot make the same file look like another.
+ * @param {string} metaUrl import.meta.url
+ * @param {string | undefined} argv1 process.argv[1]
+ */
+export function isMainModule(metaUrl, argv1) {
+  if (!argv1) return false;
+  try {
+    return realpathSync.native(fileURLToPath(metaUrl)) === realpathSync.native(argv1);
+  } catch {
+    return false;
+  }
+}
+
+if (isMainModule(import.meta.url, process.argv[1])) await main();

package/scripts/ci-build.test.mjs

@@ -0,0 +1,137 @@
+// Tests for scripts/ci-build.mjs: decideLane's lane for an unreadable build.json, the switch turned off, and a content-only
+// diff, in temporary git repositories (GIT_* variables cleared). Run: node --test packages/editor/scripts/*.test.mjs
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { clearRepoEnv } from './git-env.mjs';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { relative } from 'node:path';
+import { decideLane, isMainModule } from './ci-build.mjs';
+
+// git sets GIT_DIR and friends for hooks (the pre-push hook runs these tests), and they would point every git call here at the real repository.
+clearRepoEnv();
+
+const start = process.cwd();
+
+const git = (dir, ...args) =>
+  execFileSync('git', ['-c', 'user.name=Test', '-c', 'user.email=test@example.com', ...args], { cwd: dir, encoding: 'utf8' }).trim();
+
+function write(dir, file, text) {
+  mkdirSync(dirname(join(dir, file)), { recursive: true });
+  writeFileSync(join(dir, file), text);
+}
+
+/**
+ * A site repository whose first commit (the live one) has the config and `files`; the working directory is moved there,
+ * because the site config is loaded from it. Returns the directory and the live commit.
+ */
+function site(files = {}) {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), 'ci-build-')));
+  execFileSync('git', ['init', '-q', '-b', 'main'], { cwd: dir });
+  write(dir, 'src/site/config.ts', "export const config = { domain: 'example.com', repo: { branch: 'main' } };\n");
+  for (const [file, text] of Object.entries(files)) write(dir, file, text);
+  git(dir, 'add', '-A');
+  git(dir, 'commit', '-q', '-m', 'live');
+  process.chdir(dir);
+  return { dir, live: git(dir, 'rev-parse', 'HEAD') };
+}
+
+function commitContent(dir) {
+  write(dir, 'src/content/a.md', 'new');
+  git(dir, 'add', '-A');
+  git(dir, 'commit', '-q', '-m', 'content');
+}
+
+const serve = (commit) => async () => ({ status: 200, json: async () => ({ commit }) });
+
+function cleanup(dir) {
+  process.chdir(start);
+  rmSync(dir, { recursive: true, force: true });
+}
+
+test('an unreadable build.json gives the full lane', async () => {
+  const { dir, live } = site({ 'src/data/build.json': '{ not json' });
+  try {
+    commitContent(dir);
+    const result = await decideLane({ cwd: dir, fetch: serve(live), env: {} });
+    assert.equal(result.lane, 'full');
+    assert.match(result.reason, /build\.json unreadable/);
+    assert.equal(result.paths, null);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test('the content lane turned off gives the full lane', async () => {
+  const { dir, live } = site({ 'src/data/build.json': JSON.stringify({ contentLane: false, paidBuilds: false }) });
+  try {
+    commitContent(dir);
+    const result = await decideLane({ cwd: dir, fetch: serve(live), env: {} });
+    assert.equal(result.lane, 'full');
+    assert.equal(result.reason, 'turned off in the editor');
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test('a content-only diff gives the content lane with its paths', async () => {
+  const { dir, live } = site({ 'README.md': 'x' });
+  try {
+    commitContent(dir);
+    const result = await decideLane({ cwd: dir, fetch: serve(live), env: {} });
+    assert.equal(result.lane, 'content');
+    assert.deepEqual(result.paths, ['src/content/a.md']);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test('isMainModule matches the same file however argv[1] spells it', () => {
+  const file = fileURLToPath(import.meta.url);
+  const url = pathToFileURL(file).href;
+  assert.equal(isMainModule(url, file), true);
+  assert.equal(isMainModule(url, relative(process.cwd(), file)), true);
+  assert.equal(
+    isMainModule(
+      url,
+      file.replace(/^[A-Z]:/, (drive) => drive.toLowerCase()),
+    ),
+    true,
+  );
+  assert.equal(
+    isMainModule(
+      url,
+      file.replace(/^[a-z]:/, (drive) => drive.toUpperCase()),
+    ),
+    true,
+  );
+});
+
+test('isMainModule is false for another file, a missing path or no argument', () => {
+  const url = pathToFileURL(fileURLToPath(import.meta.url)).href;
+  assert.equal(isMainModule(url, fileURLToPath(new URL('./git-env.mjs', import.meta.url))), false);
+  assert.equal(isMainModule(url, join(tmpdir(), 'no-such-file.mjs')), false);
+  assert.equal(isMainModule(url, undefined), false);
+});
+
+test('running the file does run the build (the guard matches)', () => {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), 'ci-build-run-')));
+  try {
+    writeFileSync(join(dir, 'package.json'), '{"scripts":{}}'); // so npm finds no `check` script and stops
+    // no site config here, so main fails fast, and "ci-build:" in the output shows that it ran
+    const out = execFileSync(process.execPath, [fileURLToPath(new URL('./ci-build.mjs', import.meta.url))], {
+      cwd: dir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env,
+    }).toString();
+    assert.match(out, /ci-build: full lane/);
+  } catch (error) {
+    assert.match(String(error.stdout), /ci-build: full lane/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/scripts/editor-roundtrip.mjs

@@ -6,6 +6,7 @@
 // of text with the same heading and the same HTML. Every page is also read into sections as the front page (as the
 // site reads the page that is the front page without the editor, partsOfMarkdown in sections.mjs, packages/editor/site/home.ts):
 // they must be those the editor reads. A page with the switch "Sidekolonne" off and on again has the same front matter. Run: npm run check:editor [files...]
+// A built-in sample with section colours checks that the editor and the site give the front page's sections the same colours.
 // Milkdown needs a DOM; jsdom stands in for the browser.
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
@@ -60,6 +61,31 @@ const processor = await createMarkdownProcessor();
 const render = async (md) => (await processor.render(md)).code.replace(/\s+/g, ' ').trim();
 
 let failed = 0;
+// On a page the first heading is the H1 by itself (src/firstHeading.mjs): after a change to the text, and only then.
+const { firstHeading } = await import('@morphemecms/cms/src/firstHeading.mjs');
+const headingLevelsOf = (view) => {
+  const levels = [];
+  view.state.doc.forEach((node) => void (node.type.name === 'heading' && levels.push(node.attrs.level)));
+  return levels;
+};
+for (const [markdown, edit, expected] of [
+  ['## First\n\ntext\n\n# Second\n\n### Third', true, [1, 2, 3]],
+  ['## First\n\ntext\n\n# Second\n\n### Third', false, [2, 1, 3]],
+  ['# First\n\n# Second\n\ntext', true, [1, 2]],
+  ['text only', true, []],
+]) {
+  const editor = await makeEditor(document.createElement('div'), markdown).use(firstHeading).create();
+  const view = editor.action((ctx) => ctx.get(editorViewCtx));
+  if (edit) view.dispatch(view.state.tr.insertText('x', view.state.doc.content.size - 1));
+  const levels = headingLevelsOf(view);
+  await editor.destroy();
+  if (levels.join() === expected.join()) continue;
+  failed++;
+  console.log(
+    `\n✗ første overskrift er H1 (packages/editor/src/firstHeading.mjs)\n  tekst:  ${JSON.stringify(markdown)}${edit ? ' (ændret)' : ''}\n  vente:  ${expected}\n  fik:    ${levels}`,
+  );
+}
+
 // A fixed page's introduction and sections, as the editor reads them back.
 async function sectionsBack(sections, intro, field) {
   const leads = leadsOfField(field);
@@ -84,6 +110,35 @@ const comparable = async (intro, sections) =>
     )),
   ]);
 
+// A text with coloured sections must give the same sections (with their colours) in the editor as on the site.
+const { blockHtml } = await import('@morphemecms/cms/lib/blocks.mjs');
+const colorSample = [
+  '# Sample',
+  '<div data-section="tint"></div>',
+  '## Hours',
+  'Open daily.',
+  '<div data-section="accent"></div>',
+  '## Steps',
+  blockHtml('steps', {}),
+  '## Plain',
+  'End.',
+].join('\n\n');
+const frontSections = async (body, parts) => [
+  await comparable('', sectionsFromParts(parts, frontLeads, { colors: true })),
+  await comparable('', sectionsFromParts(partsOfMarkdown(body), frontLeads, { colors: true })),
+];
+{
+  const editor = await makeEditor(document.createElement('div'), colorSample).use(spacing).create();
+  const [editors, site] = await frontSections(colorSample, editor.action(partsOf));
+  await editor.destroy();
+  if (editors !== site || !editors.includes('"sectionColor":"tint"') || !editors.includes('"sectionColor":"accent"')) {
+    console.log(
+      `\n✗ en tekst med sektionsfarver giver ikke de samme sektioner i editoren og på sitet\n  editoren: ${editors}\n  sitet:    ${site}`,
+    );
+    process.exit(1);
+  }
+}
+
 for (const file of files) {
   if (file.endsWith('.json')) {
     const { sections, intro } = JSON.parse(readFileSync(file, 'utf8'));
@@ -116,7 +171,9 @@ for (const file of files) {
   }
   const root = document.createElement('div');
   // As in the editor: with the free lines between the blocks, written without them.
-  const editor = await makeEditor(root, body).use(spacing).create();
+  // A page also has the first-heading rule: opening and saving it must not change it.
+  const made = makeEditor(root, body).use(spacing);
+  const editor = await (file.includes('src/content/pages/') ? made.use(firstHeading) : made).create();
   editor.action((ctx) => ctx.get(editorViewCtx).dispatch(ctx.get(editorViewCtx).state.tr));
   const saved = editor.action(markdownOf);
   const parts = editor.action(partsOf);
@@ -126,9 +183,11 @@ for (const file of files) {
       await comparable('', sectionsFromParts(parts, frontLeads)),
       await comparable('', sectionsFromParts(partsOfMarkdown(body), frontLeads)),
     ];
-    if (editors !== site) {
+    const [editorColors, siteColors] = await frontSections(body, parts);
+    if (editors !== site || editorColors !== siteColors) {
       failed++;
-      console.log(`\n✗ ${file} som forside\n  editoren: ${editors.slice(0, 300)}\n  sitet:    ${site.slice(0, 300)}`);
+      const [shownEditor, shownSite] = editors !== site ? [editors, site] : [editorColors, siteColors];
+      console.log(`\n✗ ${file} som forside\n  editoren: ${shownEditor.slice(0, 300)}\n  sitet:    ${shownSite.slice(0, 300)}`);
       continue;
     }
   }

package/scripts/editor-screens.mjs

@@ -1,9 +1,10 @@
 // Opens every screen of the editor (/editor/) in a browser, on a phone and on a computer, and fails
 // when one breaks: an error on the page, something its Content-Security-Policy stopped, an empty app, or a link to an
 // address with nothing on it, or an icon that is not found (drawn as the question mark, data-icon-missing: Svg in
-// packages/editor/src/icon.tsx), there or on one of the built site's pages.
-// The screens are found as the editor's own links: from the start screen (and "Indstillinger", #indstillinger, "Dele", #udseende/dele, "Temaer",
-// #udseende/temaer, "Søgemaskineoptimering", #seo, and "Appstore", #indstillinger/appstore), and
+// packages/editor/src/icon.tsx), there or on one of the built site's pages. An icon drawn from Material Symbols instead
+// of the icon pack (data-icon-fallback) is only listed, with where it is: it does not fail.
+// The screens are found as the editor's own links: from the start screen (the drawer's links are in the page also while it is
+// closed) and "Dele", #udseende/dele, "Temaer", #udseende/temaer, "Søgemaskineoptimering", #seo, "Appstore", #indstillinger/appstore, and "Apps", #apps, which the menu no longer links to), and
 // from each screen it opens, two steps down. GitHub is answered from the files in this repository, so it needs no login
 // and changes nothing. It runs on the built site: npm run build && npm run check:screens (or on another
 // folder with a built site, its path after the command: packages/editor/scripts/check-themes.mjs).
@@ -26,14 +27,21 @@ const missingIcon = (name) =>
     ? `ikonet "${name}" findes ikke (et spørgsmålstegn i stedet): skriv det i packages/editor/src/icon.tsx`
     : 'et ikon er ikke en SVG-fil (et spørgsmålstegn i stedet)';
 
+const fallbackIcon = (name) =>
+  `ikonet "${name}" er fra Material Symbols (ikke i ikonpakken): giv det et ikon i hver pakkes kort, hvis det skal blive`;
+
 // The icons not found on the built site's pages: each one once, with the pages it is on.
 const problems = [];
 const missingOn = new Map();
+// The icons drawn from Material Symbols (named, with where they are: up to 3 places), listed, not failed on.
+const fallbackOn = new Map();
+const fallbackAt = (name, place) => fallbackOn.set(name, new Set([...(fallbackOn.get(name) ?? []), place]));
 for (const entry of readdirSync(DIST, { recursive: true, withFileTypes: true })) {
   if (!entry.isFile() || !entry.name.endsWith('.html')) continue;
   const file = join(entry.parentPath, entry.name);
   for (const [, name] of readFileSync(file, 'utf8').matchAll(/data-icon-missing="([^"]*)"/g))
     missingOn.set(name, new Set([...(missingOn.get(name) ?? []), `/${relative(DIST, file)}`]));
+  for (const [, name] of readFileSync(file, 'utf8').matchAll(/data-icon-fallback="([^"]*)"/g)) fallbackAt(name, `/${relative(DIST, file)}`);
 }
 for (const [name, pages] of missingOn) {
   const shown = [...pages].slice(0, 3).join(', ');
@@ -60,10 +68,10 @@ for (const [width, height] of [
   });
   await openEditor(page, site);
 
-  // From the start screen, and from "Indstillinger" (the gear in the top bar), "Dele", "Temaer",
-  // "Søgemaskineoptimering" and "Appstore" (the apps' pages and their developers'), whose screens are a step further
-  // down than the others.
-  const starts = ['', 'indstillinger', 'udseende/dele', 'udseende/temaer', 'seo', 'indstillinger/appstore'];
+  // From the start screen (the drawer's links), and from "Dele", "Temaer", "Søgemaskineoptimering" and "Appstore"
+  // (the apps' pages and their developers'), whose screens are a step further down than the others. "Apps" (the list of
+  // the apps installed) has no row in the menu, so it is a start of its own.
+  const starts = ['', 'udseende/dele', 'udseende/temaer', 'seo', 'indstillinger/appstore', 'apps'];
   const seen = new Set(starts);
   let next = starts;
   for (let depth = 0; depth <= 2 && next.length; depth++) {
@@ -78,7 +86,9 @@ for (const [width, height] of [
         text: document.body.innerText,
         links: [...document.querySelectorAll('a[href^="#"]')].map((a) => a.getAttribute('href').slice(1)),
         missing: [...document.querySelectorAll('[data-icon-missing]')].map((e) => e.getAttribute('data-icon-missing')),
+        fallback: [...document.querySelectorAll('[data-icon-fallback]')].map((e) => e.getAttribute('data-icon-fallback')),
       }));
+      for (const name of new Set(state.fallback)) fallbackAt(name, `${width}px #${hash}`);
       for (const name of new Set(state.missing)) problems.push(`${width}px #${hash}: ${missingIcon(name)}`);
       if (state.empty) problems.push(`${width}px #${hash}: skærmen er tom`);
       if (state.text.includes(`Der er ikke noget på adressen ${hash}.`))
@@ -120,6 +130,10 @@ for (const [state, { shows, hides }] of Object.entries(keyStates)) {
 
 await browser.close();
 server.close();
+for (const [name, places] of fallbackOn) {
+  const shown = [...places].slice(0, 3).join(', ');
+  console.log(`${shown}${places.size > 3 ? ` og ${places.size - 3} steder til` : ''}: ${fallbackIcon(name)}`);
+}
 if (problems.length) {
   console.error(`${problems.length} fejl i editoren eller på sitet:\n${[...new Set(problems)].join('\n')}`);
   process.exit(1);

package/scripts/git-env.mjs

@@ -6,4 +6,10 @@ import { execFileSync } from 'node:child_process';
 // The variables, as this git names them.
 const local = execFileSync('git', ['rev-parse', '--local-env-vars'], { encoding: 'utf8' }).split('\n').filter(Boolean);
 
+// Removes those variables from process.env itself, for a test whose code calls git with the inherited environment.
+export const clearRepoEnv = () => {
+  const own = ownRepoEnv();
+  for (const name of Object.keys(process.env)) if (!(name in own)) delete process.env[name];
+};
+
 export const ownRepoEnv = (env = process.env) => Object.fromEntries(Object.entries(env).filter(([name]) => !local.includes(name)));

package/scripts/step-command.mjs

@@ -0,0 +1,34 @@
+// How ci-build starts Prettier and npm without a shell: Node runs their JavaScript entry points itself, so a path with a
+// space or a character cmd.exe reads (& | ^ %) reaches them as one argument. Exposes stepCommand, npmCli. Depends on bin.mjs.
+import { existsSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { binOf } from './bin.mjs';
+
+/**
+ * npm's entry point: the one running this build (npm_execpath, from npm or npx), else the one installed beside Node.
+ * @param {NodeJS.ProcessEnv} env
+ * @param {string} nodePath the node executable
+ * @returns {string | null}
+ */
+export function npmCli(env = process.env, nodePath = process.execPath) {
+  const fromNpm = env.npm_execpath ? join(dirname(env.npm_execpath), basename(env.npm_execpath).replace(/^npx-cli/, 'npm-cli')) : null;
+  const beside = [
+    join(dirname(nodePath), 'node_modules', 'npm', 'bin', 'npm-cli.js'), // Windows
+    join(dirname(nodePath), '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'), // Linux and macOS
+  ];
+  return [fromNpm, ...beside].find((file) => file && /npm-cli\.c?js$/.test(file) && existsSync(file)) ?? null;
+}
+
+/**
+ * The program and arguments for a build step; never needs a shell.
+ * @param {'npm' | 'prettier'} tool
+ * @param {string[]} args
+ * @param {{ env?: NodeJS.ProcessEnv, from?: string }} [o] `from` is the site's root, where Prettier is found
+ * @returns {[string, string[]]}
+ */
+export function stepCommand(tool, args, { env = process.env, from = process.cwd() } = {}) {
+  if (tool === 'prettier') return [process.execPath, [binOf('prettier', 'prettier', from), ...args]];
+  const cli = npmCli(env);
+  // Without npm's script, plain `npm` still starts on Linux (Cloudflare); on Windows the spawn fails and the build stops.
+  return cli ? [process.execPath, [cli, ...args]] : ['npm', args];
+}

package/scripts/step-command.test.mjs

@@ -0,0 +1,50 @@
+// Tests for scripts/step-command.mjs: npm and Prettier start through Node with no shell, and a path with a space or an &
+// reaches Prettier whole. Run: node --test packages/editor/scripts/*.test.mjs
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { npmCli, stepCommand } from './step-command.mjs';
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+test('npm and Prettier run through Node', () => {
+  const [npmProgram, npmArgs] = stepCommand('npm', ['--version'], { from: here });
+  assert.equal(npmProgram, process.execPath);
+  const npm = spawnSync(npmProgram, npmArgs, { encoding: 'utf8' });
+  assert.equal(npm.status, 0, npm.stderr);
+  assert.match(npm.stdout, /^\d+\.\d+\.\d+/);
+
+  const [program, args] = stepCommand('prettier', ['--version'], { from: here });
+  assert.equal(program, process.execPath);
+  const prettier = spawnSync(program, args, { encoding: 'utf8' });
+  assert.equal(prettier.status, 0, prettier.stderr);
+  assert.match(prettier.stdout, /^\d+\.\d+\.\d+/);
+});
+
+test('Prettier gets a path with a space and an & as one argument', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'step-command-'));
+  try {
+    const name = 'a b & c.json';
+    writeFileSync(join(dir, name), '{"a":1}'); // not formatted, so --check fails by naming this very file
+    const [program, args] = stepCommand('prettier', ['--check', '--ignore-unknown', name], { from: here });
+    const result = spawnSync(program, args, { cwd: dir, encoding: 'utf8' });
+    assert.equal(result.status, 1);
+    assert.match(result.stderr + result.stdout, /a b & c\.json/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('npmCli follows npm_execpath, also from npx, and is null when there is none', () => {
+  const real = npmCli({}, process.execPath);
+  assert.ok(real === null || /npm-cli\.c?js$/.test(real));
+  if (real) {
+    assert.equal(npmCli({ npm_execpath: real.replace(/npm-cli/, 'npx-cli') }, '/nowhere/node'), real);
+    assert.equal(npmCli({ npm_execpath: real }, '/nowhere/node'), real);
+  }
+  assert.equal(npmCli({ npm_execpath: '/nowhere/yarn.js' }, '/nowhere/node'), null);
+});

package/scripts/text-problems.mjs

@@ -0,0 +1,83 @@
+// The check of the editor's English texts (packages/editor/src/i18n/en-US/) against Material 3's rules for writing: no
+// em dash, no "...", no abbreviations, no politeness, no "we", no "!", no "&", American spelling, no internal
+// names (Worker, bucket, jurisdiction, wrangler.jsonc). Exposes RULES, ALLOWED
+// (the exceptions, with reasons) and textProblems; used by check-content.mjs. No dependencies.
+
+const word = (pattern, flags = 'i') => new RegExp(`\\b(?:${pattern})\\b`, flags);
+
+/** @type {{ id: string, message: string, test: (text: string) => boolean }[]} */
+export const RULES = [
+  { id: 'em-dash', message: 'no em dash, use a comma, a colon or a new sentence', test: (s) => /—/.test(s) },
+  { id: 'ellipsis', message: 'write the ellipsis as one … with no space before it', test: (s) => /\.\.\.|\s…/.test(s) },
+  {
+    id: 'abbreviation',
+    message: 'no abbreviations (e.g., i.e., etc., vs.), write it out',
+    test: (s) => /(?:^|[^\w])(?:e\.g\.|i\.e\.|etc\b|vs\b)/i.test(s),
+  },
+  { id: 'politeness', message: 'no please, sorry or are you sure', test: (s) => word('please|sorry|are you sure').test(s) },
+  {
+    // "I" is a word only as a capital, so "i" inside words and "Id" never match.
+    id: 'we',
+    message: 'no we, our, us or I, the editor does not speak about itself',
+    test: (s) => word('we|our|us').test(s) || word('I', '').test(s),
+  },
+  { id: 'exclamation', message: 'no exclamation marks', test: (s) => /!/.test(s) },
+  { id: 'ampersand', message: 'write "and", not &', test: (s) => /&/.test(s) },
+  {
+    id: 'british',
+    message: 'American spelling (color, gray, license, favorite, check, organize, recognize, customize)',
+    test: (s) => word('colour\\w*|grey\\w*|licences?|favourite\\w*|tick(?:s|ed|ing)?|organis\\w*|recognis\\w*|customis\\w*').test(s),
+  },
+  {
+    // "Workers Paid" (a Cloudflare plan name) passes: only the singular word Worker is an internal name.
+    id: 'internal-name',
+    message: 'no internal names (Worker, bucket, jurisdiction, wrangler.jsonc), say what it is for the site owner',
+    test: (s) => word('worker|buckets?|jurisdictions?').test(s) || /(?:^|[^a-z0-9_])wrangler[.]jsonc(?![a-z0-9_])/i.test(s),
+  },
+];
+
+// Exceptions: key path -> the rule ids it may break. Every entry says why.
+export const ALLOWED = {
+  // Sample card text, written in the site owner's own voice.
+  'blocks.cards.example.0.text': ['we'],
+  'blocks.cards.example.1.text': ['we'],
+  // Sample message a visitor types into a form.
+  'parts.screens.fieldMessageValue': ['we'],
+};
+
+/**
+ * @param {object} messages the English texts (enUS)
+ * @param {Record<string, string[]>} [allowed] key path -> rule ids it may break
+ * @returns {string[]}
+ */
+export function textProblems(messages, allowed = ALLOWED) {
+  const problems = [];
+  const check = (path, text) => {
+    for (const rule of RULES) {
+      if (rule.test(text) && !allowed[path]?.includes(rule.id)) {
+        problems.push(`i18n/en-US › ${path}: ${rule.message} (${JSON.stringify(text)})`);
+      }
+    }
+  };
+  const walk = (path, value) => {
+    if (typeof value === 'string') return check(path, value);
+    if (typeof value === 'function') {
+      let result;
+      try {
+        result = value(...Array.from({ length: value.length }, () => 'x'));
+      } catch {
+        return;
+      }
+      if (typeof result === 'string') check(path, result);
+      return;
+    }
+    if (Array.isArray(value)) return value.forEach((item, i) => walk(`${path}.${i}`, item));
+    if (value && typeof value === 'object') {
+      for (const [key, item] of Object.entries(value)) {
+        if (!key.endsWith('Commit')) walk(path ? `${path}.${key}` : key, item);
+      }
+    }
+  };
+  walk('', messages);
+  return problems;
+}

package/scripts/text-problems.test.mjs

@@ -0,0 +1,74 @@
+// Tests textProblems (text-problems.mjs): each rule reports its string and passes the right one, nested and array keys
+// report their full path, functions are called, throwing functions and keys ending in Commit are skipped, and an
+// exception hides only its own key and rule.
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { textProblems } from './text-problems.mjs';
+
+const none = {};
+
+const CASES = [
+  ['em-dash', 'Save — now', 'Save now'],
+  ['ellipsis', 'Saving...', 'Saving…'],
+  ['ellipsis', 'Saving …', 'Saving…'],
+  ['abbreviation', 'E.g. a video', 'For example, a video'],
+  ['politeness', 'Please try again', 'Try again'],
+  ['we', 'We saved it', 'Status'],
+  ['we', 'Back to our page', 'Page ids'],
+  ['we', 'Then I wrote it', 'Id and i18n'],
+  ['exclamation', 'Done!', 'Done'],
+  ['ampersand', 'Text & pictures', 'Text and pictures'],
+  ['british', 'Colour', 'Color'],
+  ['british', 'Grey boxes', 'Gray boxes'],
+  ['internal-name', 'Loading the Worker’s settings', 'Loading settings…'],
+  ['internal-name', "Loading the Worker's settings", 'Workers Paid'],
+  ['internal-name', 'Open the BUCKET', 'Bucketing the photos'],
+  ['internal-name', 'Empty the buckets', 'Open the bucketlist'],
+  ['internal-name', 'Pick a jurisdiction', 'Pick a region'],
+  ['internal-name', 'Edit wrangler.jsonc', 'Edit the settings file'],
+];
+
+for (const [id, wrong, right] of CASES) {
+  test(`${id}: reports ${JSON.stringify(wrong)} and passes ${JSON.stringify(right)}`, () => {
+    const problems = textProblems({ k: wrong }, none);
+    assert.equal(problems.length, 1);
+    assert.ok(problems[0].startsWith('i18n/en-US › k: '));
+    assert.ok(problems[0].endsWith(`(${JSON.stringify(wrong)})`));
+    assert.deepEqual(textProblems({ k: right }, none), []);
+  });
+}
+
+test('a nested key reports its full path', () => {
+  const [problem] = textProblems({ media: { empty: 'Nothing here!' } }, none);
+  assert.match(problem, /^i18n\/en-US › media\.empty: /);
+});
+
+test('array items get their index in the path', () => {
+  const [problem] = textProblems({ blocks: { cards: { example: [{ text: 'fine' }, { text: 'Done!' }] } } }, none);
+  assert.match(problem, /› blocks\.cards\.example\.1\.text: /);
+});
+
+test('a function value is checked', () => {
+  const problems = textProblems({ backTo: (to) => `Back to ${to}!` }, none);
+  assert.equal(problems.length, 1);
+  assert.match(problems[0], /› backTo: /);
+});
+
+test('a function that throws is skipped', () => {
+  const throws = () => {
+    throw new Error('no');
+  };
+  assert.deepEqual(textProblems({ f: throws }, none), []);
+});
+
+test('a key ending in Commit is skipped', () => {
+  assert.deepEqual(textProblems({ saveCommit: 'Editor: we saved' }, none), []);
+});
+
+test('an exception hides its own key and rule only', () => {
+  const allowed = { 'a.b': ['we'] };
+  assert.deepEqual(textProblems({ a: { b: 'We saved it' } }, allowed), []);
+  assert.equal(textProblems({ a: { c: 'We saved it' } }, allowed).length, 1);
+  assert.equal(textProblems({ a: { b: 'We saved it!' } }, allowed).length, 1);
+  assert.equal(textProblems({ a: { b: 'We saved it' } }, { 'a.b': ['exclamation'] }).length, 1);
+});