@morphemecms/cms 0.9.0-next-20261105122349 → 0.9.0

package/lib/page-template.test.mjs

@@ -0,0 +1,129 @@
+// Tests for page-template helpers.
+// Uses node:test and node:assert/strict.
+// No other dependencies.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  PAGE_TEMPLATES,
+  STANDARD_TEMPLATES,
+  templatesOf,
+  templateOf,
+  hasSidebar,
+  templateChoices,
+  templateProblems,
+  templateWritten,
+} from './page-template.mjs';
+
+test('templatesOf undefined returns standard', () => {
+  assert.deepEqual(templatesOf(undefined), ['single', 'sidebar-right', 'sidebar-left']);
+});
+
+test('templatesOf empty object returns standard', () => {
+  assert.deepEqual(templatesOf({}), ['single', 'sidebar-right', 'sidebar-left']);
+});
+
+test('templatesOf valid custom list returns that list', () => {
+  assert.deepEqual(templatesOf({ templates: ['sidebar-right', 'single'] }), ['sidebar-right', 'single']);
+});
+
+test('templatesOf empty array returns standard', () => {
+  assert.deepEqual(templatesOf({ templates: [] }), ['single', 'sidebar-right', 'sidebar-left']);
+});
+
+test('templatesOf invalid item returns standard', () => {
+  assert.deepEqual(templatesOf({ templates: ['nope'] }), ['single', 'sidebar-right', 'sidebar-left']);
+});
+
+test('templateOf no template returns first offered', () => {
+  assert.equal(templateOf({}, ['sidebar-right', 'single']), 'sidebar-right');
+});
+
+test('templateOf valid template in offered returns it', () => {
+  assert.equal(templateOf({ template: 'single' }, ['sidebar-right', 'single']), 'single');
+});
+
+test('templateOf valid template not in offered returns first offered', () => {
+  assert.equal(templateOf({ template: 'full' }, ['sidebar-right', 'single']), 'sidebar-right');
+});
+
+test('templateOf non-string template returns first offered', () => {
+  assert.equal(templateOf({ template: 3 }, ['single']), 'single');
+});
+
+test('templateOf null page returns first offered', () => {
+  assert.equal(templateOf(null, ['single']), 'single');
+});
+
+test('hasSidebar sidebar-left', () => {
+  assert.equal(hasSidebar('sidebar-left'), true);
+});
+
+test('hasSidebar sidebar-right', () => {
+  assert.equal(hasSidebar('sidebar-right'), true);
+});
+
+test('hasSidebar single', () => {
+  assert.equal(hasSidebar('single'), false);
+});
+
+test('hasSidebar full', () => {
+  assert.equal(hasSidebar('full'), false);
+});
+
+test('hasSidebar undefined', () => {
+  assert.equal(hasSidebar(undefined), false);
+});
+
+test('templateChoices false removes sidebar', () => {
+  assert.deepEqual(templateChoices(['single', 'sidebar-right'], false), ['single']);
+});
+
+test('templateChoices true keeps all', () => {
+  assert.deepEqual(templateChoices(['single', 'sidebar-right'], true), ['single', 'sidebar-right']);
+});
+
+test('templateChoices false removes sidebar-left', () => {
+  assert.deepEqual(templateChoices(['sidebar-left', 'full'], false), ['full']);
+});
+
+test('templateProblems undefined returns empty', () => {
+  assert.deepEqual(templateProblems(undefined), []);
+});
+
+test('templateProblems valid list returns empty', () => {
+  assert.deepEqual(templateProblems(['single', 'sidebar-right']), []);
+});
+
+test('templateProblems non-array', () => {
+  assert.deepEqual(templateProblems('single'), ['"templates" must be a list of template ids.']);
+});
+
+test('templateProblems empty array', () => {
+  assert.deepEqual(templateProblems([]), ['"templates" must name at least one template.']);
+});
+
+test('templateProblems unknown template', () => {
+  assert.deepEqual(templateProblems(['single', 'nope']), ['"templates" has an unknown template: nope.']);
+});
+
+test('templateProblems duplicate template', () => {
+  assert.deepEqual(templateProblems(['single', 'single']), ['"templates" names single twice.']);
+});
+
+test('templatesOf returns new array', () => {
+  const result = templatesOf(undefined);
+  assert.deepEqual(result, STANDARD_TEMPLATES);
+  result.push('extra');
+  assert.equal(STANDARD_TEMPLATES.length, 3);
+  assert.deepEqual(STANDARD_TEMPLATES, ['single', 'sidebar-right', 'sidebar-left']);
+});
+
+test('templateWritten leaves out the default and an empty value', () => {
+  const offered = ['sidebar-right', 'single'];
+  assert.equal(templateWritten('sidebar-right', offered), '');
+  assert.equal(templateWritten('', offered), '');
+  assert.equal(templateWritten(undefined, offered), '');
+  assert.equal(templateWritten('single', offered), 'single');
+  assert.equal(templateWritten('full', offered), 'full');
+});

package/lib/side-block.d.mts

@@ -1,14 +1,11 @@
 /**
  * The block type to draw beside a page's text, or null.
- * @param {{ wide?: boolean, side?: boolean }} page  the page's front matter
+ * @param {string} template  the page's template (templateOf in lib/page-template.mjs)
  * @param {{ block: string | null } | null} setting  the contents of src/data/side.json, or null when the file is missing
  * @param {(type: string) => boolean} beside  whether that type's load.ts has beside: true
  * @returns {string | null}
  */
-export function sideBlockOf(page: {
-    wide?: boolean;
-    side?: boolean;
-}, setting: {
+export function sideBlockOf(template: string, setting: {
     block: string | null;
 } | null, beside: (type: string) => boolean): string | null;
 /**
@@ -32,14 +29,3 @@ export function sideChoices(blocks: {
     type: string;
     label: string;
 }[];
-/**
- * Whether the page form shows the switch "Sidekolonne": src/data/side.json chooses a block and the page is not wide.
- * @param {{ block?: unknown } | null | undefined} setting  the contents of src/data/side.json
- * @param {{ wide?: unknown }} page  the page's values
- * @returns {boolean}
- */
-export function sideSwitchShown(setting: {
-    block?: unknown;
-} | null | undefined, page: {
-    wide?: unknown;
-}): boolean;

package/lib/side-block.mjs

@@ -1,44 +1,36 @@
 // Determines the side block type to draw beside a page's text, and what the editor offers about it.
-// Exposes sideBlockOf (the site), besideInSource, sideChoices and sideSwitchShown (the editor: Sidekolonne).
-// No dependencies.
+// Exposes sideBlockOf (the site), besideInSource and sideChoices (the editor: Sidekolonne).
+// Depends on hasSidebar in lib/page-template.mjs.
+import { hasSidebar } from './page-template.mjs';
 
 /**
  * The block type to draw beside a page's text, or null.
- * @param {{ wide?: boolean, side?: boolean }} page  the page's front matter
+ * @param {string} template  the page's template (templateOf in lib/page-template.mjs)
  * @param {{ block: string | null } | null} setting  the contents of src/data/side.json, or null when the file is missing
  * @param {(type: string) => boolean} beside  whether that type's load.ts has beside: true
  * @returns {string | null}
  */
-export function sideBlockOf(page, setting, beside) {
-  // Treat null or undefined page as empty object
-  const p = page || {};
-
-  // Rule 1: When setting is null or undefined, return null
-  if (setting === null || setting === undefined) {
+export function sideBlockOf(template, setting, beside) {
+  // Only the sidebar templates have a column
+  if (!hasSidebar(template)) {
     return null;
   }
 
-  // Rule 2: When setting.block is not a non-empty string, return null
-  if (typeof setting.block !== 'string' || setting.block.length === 0) {
-    return null;
-  }
-
-  // Rule 3: When page.wide === true, return null
-  if (p.wide === true) {
+  // When setting is null or undefined, return null
+  if (setting === null || setting === undefined) {
     return null;
   }
 
-  // Rule 4: When page.side === false, return null
-  if (p.side === false) {
+  // When setting.block is not a non-empty string, return null
+  if (typeof setting.block !== 'string' || setting.block.length === 0) {
     return null;
   }
 
-  // Rule 5: When beside(setting.block) is not true, return null
+  // When beside(setting.block) is not true, return null
   if (beside(setting.block) !== true) {
     return null;
   }
 
-  // Rule 6: Return setting.block
   return setting.block;
 }
 
@@ -63,13 +55,3 @@ export function sideChoices(blocks, sources, installed) {
     .filter((b) => (!b.app || installed.includes(b.app)) && besideInSource(sources[b.type] ?? ''))
     .map((b) => ({ type: b.type, label: b.label }));
 }
-
-/**
- * Whether the page form shows the switch "Sidekolonne": src/data/side.json chooses a block and the page is not wide.
- * @param {{ block?: unknown } | null | undefined} setting  the contents of src/data/side.json
- * @param {{ wide?: unknown }} page  the page's values
- * @returns {boolean}
- */
-export function sideSwitchShown(setting, page) {
-  return typeof setting?.block === 'string' && setting.block.length > 0 && page?.wide !== true;
-}

package/lib/side-block.test.mjs

@@ -1,54 +1,44 @@
-// Tests for sideBlockOf (the site) and besideInSource, sideChoices and sideSwitchShown (the editor's Sidekolonne).
+// Tests for sideBlockOf (the site) and besideInSource and sideChoices (the editor's Sidekolonne).
 // Validates side block selection logic.
-// Depends on lib/side-block.mjs.
+// Depends on lib/side-block.mjs and, through it, lib/page-template.mjs.
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { besideInSource, sideBlockOf, sideChoices, sideSwitchShown } from './side-block.mjs';
+import { besideInSource, sideBlockOf, sideChoices } from './side-block.mjs';
 
 const yes = () => true;
 const no = () => false;
 
 test('returns null when setting is null', () => {
-  assert.equal(sideBlockOf({}, null, yes), null);
+  assert.equal(sideBlockOf('sidebar-right', null, yes), null);
 });
 
 test('returns null when setting.block is null', () => {
-  assert.equal(sideBlockOf({}, { block: null }, yes), null);
+  assert.equal(sideBlockOf('sidebar-right', { block: null }, yes), null);
 });
 
-test('returns block type when valid', () => {
-  assert.equal(sideBlockOf({}, { block: 'side-card' }, yes), 'side-card');
+test('returns block type for both sidebar templates', () => {
+  assert.equal(sideBlockOf('sidebar-right', { block: 'side-card' }, yes), 'side-card');
+  assert.equal(sideBlockOf('sidebar-left', { block: 'side-card' }, yes), 'side-card');
 });
 
-test('returns null when page.wide is true', () => {
-  assert.equal(sideBlockOf({ wide: true }, { block: 'side-card' }, yes), null);
-});
-
-test('returns null when page.side is false', () => {
-  assert.equal(sideBlockOf({ side: false }, { block: 'side-card' }, yes), null);
-});
-
-test('returns block type when page.side is true', () => {
-  assert.equal(sideBlockOf({ side: true }, { block: 'side-card' }, yes), 'side-card');
+test('returns null for templates without a sidebar', () => {
+  assert.equal(sideBlockOf('single', { block: 'side-card' }, yes), null);
+  assert.equal(sideBlockOf('full', { block: 'side-card' }, yes), null);
 });
 
 test('returns null when beside returns false', () => {
-  assert.equal(sideBlockOf({}, { block: 'side-card' }, no), null);
+  assert.equal(sideBlockOf('sidebar-right', { block: 'side-card' }, no), null);
 });
 
 test('beside is called with the chosen type', () => {
   const seen = [];
-  sideBlockOf({}, { block: 'side-card' }, (t) => {
+  sideBlockOf('sidebar-left', { block: 'side-card' }, (t) => {
     seen.push(t);
     return true;
   });
   assert.deepEqual(seen, ['side-card']);
 });
 
-test('treats undefined page as empty object', () => {
-  assert.equal(sideBlockOf(undefined, { block: 'side-card' }, yes), 'side-card');
-});
-
 test('besideInSource reads export const beside = true', () => {
   assert.equal(besideInSource('import x from "y";\nexport const beside = true;\nexport const load = 1;'), true);
   assert.equal(besideInSource('export const beside = false;'), false);
@@ -70,10 +60,3 @@ test('sideChoices lists installed blocks with beside, by label', () => {
     { type: 'chat', label: 'Chat' },
   ]);
 });
-
-test('sideSwitchShown needs a chosen block and a page that is not wide', () => {
-  assert.equal(sideSwitchShown({ block: 'toc' }, {}), true);
-  assert.equal(sideSwitchShown({ block: 'toc' }, { wide: true }), false);
-  assert.equal(sideSwitchShown({ block: null }, {}), false);
-  assert.equal(sideSwitchShown(null, {}), false);
-});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morphemecms/cms",
-  "version": "0.9.0-next-20261105122349",
+  "version": "0.9.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",

package/scripts/check-side.mjs

@@ -1,52 +1,79 @@
 // Checks the column beside a page's text (src/data/side.json, `beside` in a block's load.ts, PageLayout.astro) with the
-// theme now in src/data/theme.json: puts a TEST-ONLY block and three pages in the site (scripts/fixtures/side/), builds it
-// in a folder of its own and looks in the HTML. Exposes checkSide(root, theme); used by check-themes.mjs. Removes what it
+// theme now in src/data/theme.json: puts a TEST-ONLY block and five pages, one for each template (scripts/fixtures/side/),
+// in the site, builds it in a folder of its own and looks in the HTML for the template and the column the theme's
+// "templates" give each, and for the width of the text (PageLayout.astro: 66ch with a column; without one the blocks span
+// the column and the first paragraph is the lead). Exposes checkSide(root), expectedFor and columnOf; used by check-themes.mjs. Removes what it
 // put in the site, and the side.json it wrote, however it ends.
 import { execFileSync } from 'node:child_process';
 import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { hasSidebar, templateOf, templatesOf } from '@morphemecms/cms/lib/page-template.mjs';
+import { activeTheme, themeFolder } from '@morphemecms/cms/site/theme.mjs';
 import { binOf } from './bin.mjs';
+import { leadProblem, textClasses, widthProblem } from './side-width.mjs';
 
 const fixtures = fileURLToPath(new URL('fixtures/side/', import.meta.url));
 const BLOCK = 'src/apps/side-fixture/blocks/side-test';
-const PAGES = ['side-plain', 'side-wide', 'side-off'];
 
-/** What the fixture's pages must show: [page, whether the column is on it]. */
-export const expected = [
-  ['side-plain', true],
-  ['side-wide', false],
-  ['side-off', false],
+/** The fixture's pages: [page, its `template` in the front matter, or undefined]. */
+const PAGES = [
+  ['side-none', undefined],
+  ['side-single', 'single'],
+  ['side-left', 'sidebar-left'],
+  ['side-right', 'sidebar-right'],
+  ['side-full', 'full'],
 ];
 
-/** Whether the built page has the block beside its text, and its text's length (data-side-length). */
-export const columnOf = (html) => ({
-  column: /<aside class="page-side">[\s\S]*?data-side-test="\/side-plain\/"[\s\S]*?<\/aside>/.test(html),
-  grid: html.includes('class="page-with-side"'),
+/** What each fixture page must show with a theme that offers `offered`: [page, its template, the side of the column or null].
+ * The template is the one the theme gives the page (templateOf); only a sidebar template has a column. */
+export const expectedFor = (offered) =>
+  PAGES.map(([page, key]) => {
+    const template = templateOf({ template: key }, offered);
+    return [page, template, hasSidebar(template) ? (template === 'sidebar-left' ? 'left' : 'right') : null];
+  });
+
+/** What the built page shows: its template, the side of the column beside its text (with the test block in it), and whether the block is anywhere. */
+export const columnOf = (html, page) => ({
+  template: html.match(/<article[^>]*\sdata-template="([\w-]+)"/)?.[1] ?? null,
+  side: html.match(/class="page-with-side" data-side="(left|right)"/)?.[1] ?? null,
+  column: new RegExp(String.raw`<aside class="page-side">[\s\S]*?data-side-test="/${page}/"[\s\S]*?</aside>`).test(html),
   anywhere: html.includes('data-side-test'),
+  text: textClasses(html),
 });
 
-/** Builds the site with the fixture and checks the three cases for the theme in use; throws with what is wrong. */
+/** The templates the theme in use offers (its theme.json "templates", else the standard theme's). */
+function offeredBy(root) {
+  const theme = activeTheme();
+  const manifest = JSON.parse(readFileSync(join(root, themeFolder(theme), 'theme.json'), 'utf8'));
+  return templatesOf(manifest);
+}
+
+/** Builds the site with the fixture and checks the cases for the theme in use; throws with what is wrong. */
 export function checkSide(root) {
-  const put = [BLOCK, 'src/data/side.json', ...PAGES.map((p) => `src/content/pages/${p}.md`)].map((f) => join(root, f));
+  const put = [BLOCK, 'src/data/side.json', ...PAGES.map(([p]) => `src/content/pages/${p}.md`)].map((f) => join(root, f));
   if (put.some(existsSync)) throw new Error('Remove the side-fixture files from src/ first (scripts/check-side.mjs puts them there).');
   const out = mkdtempSync(join(tmpdir(), 'side-'));
   try {
+    const offered = offeredBy(root);
     mkdirSync(join(root, BLOCK), { recursive: true });
     cpSync(join(fixtures, 'block'), join(root, BLOCK), { recursive: true });
     cpSync(join(fixtures, 'side.json'), join(root, 'src/data/side.json'));
-    for (const p of PAGES) cpSync(join(fixtures, `${p}.md`), join(root, `src/content/pages/${p}.md`));
+    for (const [p] of PAGES) cpSync(join(fixtures, `${p}.md`), join(root, `src/content/pages/${p}.md`));
     execFileSync(process.execPath, [binOf('astro'), 'build', '--outDir', out], { cwd: root, stdio: 'inherit' });
     const problems = [];
-    for (const [page, on] of expected) {
-      const html = readFileSync(join(out, page, 'index.html'), 'utf8');
-      const found = columnOf(html);
-      if (on && !(found.column && found.grid)) problems.push(`/${page}/ has no column beside its text`);
-      if (!on && (found.anywhere || found.grid)) problems.push(`/${page}/ has the column, and should not`);
+    let drawn = false;
+    for (const [page, template, side] of expectedFor(offered)) {
+      const found = columnOf(readFileSync(join(out, page, 'index.html'), 'utf8'), page);
+      if (found.template !== template) problems.push(`/${page}/ has the template ${found.template}, and should have ${template}`);
+      if (side && !(found.column && found.side === side)) problems.push(`/${page}/ has no column on the ${side}, beside its text`);
+      if (!side && (found.anywhere || found.side)) problems.push(`/${page}/ has the column, and should not`);
+      for (const problem of [widthProblem(found.text, side), leadProblem(found.text, side)])
+        if (problem) problems.push(`/${page}/: ${problem}`);
+      drawn ||= found.anywhere;
     }
-    const plain = columnOf(readFileSync(join(out, 'side-plain/index.html'), 'utf8'));
-    if (!plain.anywhere) problems.push('the block was not drawn at all');
+    if (offered.some(hasSidebar) && !drawn) problems.push('the block was not drawn at all');
     if (problems.length) throw new Error(problems.join('\n'));
   } finally {
     rmSync(out, { recursive: true, force: true });

package/scripts/editor-roundtrip.mjs

@@ -5,7 +5,7 @@
 // sections as blocks (packages/editor/src/sections.mjs) and read back: the sections must be the same, a section
 // 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...]
+// they must be those the editor reads. A page whose template is changed and changed back has the same front matter (the default leaves no key). 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';
@@ -46,7 +46,8 @@ const textOf = Object.fromEntries(
     .flatMap((c) => c.files)
     .map((f) => [f.file, f.fields.find((x) => x.type === 'blocks')]),
 );
-const { booleanWrite, splitFrontmatter, writeFields } = await import('@morphemecms/cms/src/frontmatter.mjs');
+const { splitFrontmatter, writeFields } = await import('@morphemecms/cms/src/frontmatter.mjs');
+const { STANDARD_TEMPLATES, templateWritten } = await import('@morphemecms/cms/lib/page-template.mjs');
 
 const walk = (dir) =>
   (existsSync(dir) ? readdirSync(dir, { withFileTypes: true }) : []).flatMap((e) =>
@@ -158,14 +159,22 @@ for (const file of files) {
     console.log(`\n✗ ${file}\n  front matter skrives ikke tilbage uændret`);
     continue;
   }
-  // The switch "Sidekolonne" (side): off writes `side: false`; on again removes the key, and the front matter is as before.
+  // The template (templateWritten): the theme's default leaves no key; another one is written; changing back gives the
+  // front matter as it was (without the key).
   if (file.includes('src/content/pages/')) {
-    const off = writeFields(yaml, { side: booleanWrite(false, true) });
-    if (!/^side: false$/m.test(off) || writeFields(off, { side: booleanWrite(true, true) }) !== writeFields(yaml, { side: '' })) {
+    const [fallback] = STANDARD_TEMPLATES;
+    const plain = writeFields(yaml, { template: '' });
+    const chosen = writeFields(plain, { template: templateWritten('sidebar-left', STANDARD_TEMPLATES) });
+    const back = writeFields(chosen, { template: templateWritten(fallback, STANDARD_TEMPLATES) });
+    if (
+      !/^template: sidebar-left$/m.test(chosen) ||
+      back !== plain ||
+      writeFields(plain, { template: templateWritten(fallback, STANDARD_TEMPLATES) }) !== plain
+    ) {
       failed++;
       console.log(`
 ✗ ${file}
-  Sidekolonne slået fra og til giver ikke det samme front matter`);
+  Skabelonen skiftet og skiftet tilbage giver ikke det samme front matter`);
       continue;
     }
   }

package/scripts/fixtures/side/side-full.md

@@ -0,0 +1,8 @@
+---
+title: "Side full"
+template: full
+---
+
+# Side full
+
+A page with full: the column follows the theme's offer.

package/scripts/fixtures/side/side-left.md

@@ -0,0 +1,8 @@
+---
+title: "Side left"
+template: sidebar-left
+---
+
+# Side left
+
+A page with sidebar-left: the column follows the theme's offer.

package/scripts/fixtures/side/side-none.md

@@ -0,0 +1,7 @@
+---
+title: "Side none"
+---
+
+# Side none
+
+A page with no template: the column follows the theme's offer.

package/scripts/fixtures/side/side-right.md

@@ -0,0 +1,8 @@
+---
+title: "Side right"
+template: sidebar-right
+---
+
+# Side right
+
+A page with sidebar-right: the column follows the theme's offer.

package/scripts/fixtures/side/side-single.md

@@ -0,0 +1,8 @@
+---
+title: "Side single"
+template: single
+---
+
+# Side single
+
+A page with single: the column follows the theme's offer.

package/scripts/side-width.mjs

@@ -0,0 +1,29 @@
+// The width and lead rules of a page's text (theme/layouts/PageLayout.astro), for check-side.mjs: textClasses reads the
+// classes of the text wrapper from built HTML; widthProblem and leadProblem say what is wrong with them. No dependencies,
+// so a unit test can run it.
+
+/** The classes of the text wrapper (data-editor="text") in a built page. */
+export const textClasses = (html) =>
+  html
+    .match(/<div data-editor="text" class="([^"]*)"/)?.[1]
+    .replaceAll('&amp;', '&')
+    .replaceAll('&gt;', '>')
+    .split(/\s+/) ?? [];
+
+/** The width rule for the text's classes: with a column the text stops at 66ch; without one the text is as wide as its
+ * container (max-w-none) and only its parts outside the blocks stop at 66ch. Returns what is wrong, or null. */
+export const LEAD = ['[&>p:first-child]:type-lead', '[&>p:first-child]:text-muted', '[&>p:first-child]:max-w-[52ch]'];
+
+/** The lead rule: without a column the text's first paragraph is the lead (type-lead, muted, 52ch); with one it is not. */
+export function leadProblem(text, side) {
+  const has = LEAD.filter((c) => text.includes(c)).length;
+  if (side) return has === 0 ? null : 'its first paragraph should not be a lead';
+  return has === LEAD.length ? null : 'its first paragraph should be a lead (type-lead, text-muted, max-w-[52ch])';
+}
+
+export function widthProblem(text, side) {
+  if (side) return text.includes('max-w-[66ch]') && !text.includes('max-w-none') ? null : 'its text should be max-w-[66ch], not max-w-none';
+  return text.includes('max-w-none') && text.includes('[&>:not(.not-prose)]:max-w-[66ch]')
+    ? null
+    : 'its text should be max-w-none, with 66ch for what is not a block';
+}

package/scripts/side-width.test.mjs

@@ -0,0 +1,30 @@
+// Tests the width rule of check-side.mjs (side-width.mjs: widthProblem) and how it reads the text's classes from built HTML.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { LEAD, leadProblem, textClasses, widthProblem } from './side-width.mjs';
+
+const WIDE = ['prose', 'max-w-none', '[&>:not(.not-prose)]:max-w-[66ch]'];
+const NARROW = ['prose', 'max-w-[66ch]'];
+
+test('a page without a column: text as wide as its container, 66ch for what is not a block', () => {
+  assert.equal(widthProblem(WIDE, null), null);
+  assert.ok(widthProblem(NARROW, null));
+});
+
+test('a page with a column: text stops at 66ch', () => {
+  assert.equal(widthProblem(NARROW, 'left'), null);
+  assert.ok(widthProblem(WIDE, 'right'));
+});
+
+test('textClasses reads the classes of the text wrapper', () => {
+  const html =
+    '<article data-template="single"><div data-editor="text" class="prose max-w-none [&amp;>:not(.not-prose)]:max-w-[66ch]"></div>';
+  assert.deepEqual(textClasses(html), WIDE);
+});
+
+test('a page without a column: the first paragraph is the lead; with a column it is not', () => {
+  assert.equal(leadProblem([...WIDE, ...LEAD], null), null);
+  assert.ok(leadProblem(WIDE, null));
+  assert.equal(leadProblem(NARROW, 'left'), null);
+  assert.ok(leadProblem([...NARROW, ...LEAD], 'left'));
+});

package/site/content.config.ts

@@ -2,6 +2,7 @@
 // Depends on astro:content.
 import { defineCollection, z } from 'astro:content';
 import { glob } from 'astro/loaders';
+import { PAGE_TEMPLATES } from '../lib/page-template.mjs';
 
 // Kladde, Skjult or Planlagt (Udgivet when left out), and for Planlagt when, in Danish time
 // ("2026-11-01T08:00"): what each one is on the site is in packages/editor/lib/status.mjs.
@@ -76,10 +77,8 @@ const pages = defineCollection({
     canonical: z.string().optional(),
     // Not for search engines: noindex (Base.astro) and not in the sitemap (packages/editor/astro.mjs).
     noindex: z.boolean().optional().default(false),
-    // Across the whole page, without the owner's card beside the text (PageLayout.astro).
-    wide: z.boolean().optional().default(false),
-    // `false`: without the block beside the text, which src/data/side.json chooses (PageLayout.astro).
-    side: z.boolean().optional(),
+    // The page's template, one the theme offers (lib/page-template.mjs; PageLayout.astro). Left out: the theme's first.
+    template: z.enum(PAGE_TEMPLATES as [string, ...string[]]).optional(),
     // A new version of a page (/ny/…): what the owner should look at or answer before it replaces the
     // current page. Shown at the top of the new version and on /ny/.
     review: z.string().optional(),

package/site/header.d.mts

@@ -0,0 +1,21 @@
+/** @typedef {import('../src/standard/buttons/fields').Button} Button */
+/** @typedef {{ button: Button | null, menuSide: 'start' | 'end' }} Header */
+/**
+ * Reads src/data/header.json's content. Missing or wrong → defaults.
+ * @param {unknown} raw
+ * @returns {Header}
+ */
+export function headerOf(raw: unknown): Header;
+export function sortedNav<T extends NavItem>(items: T[]): T[];
+export type Button = any;
+export type Header = {
+    button: Button | null;
+    menuSide: "start" | "end";
+};
+export type NavLink = {
+    label: string;
+    href: string;
+};
+export type NavItem = NavLink & {
+    children?: NavLink[];
+};