@morphemecms/cms 0.14.2 → 0.14.3-next-20261107160925

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @morphemecms/cms
 
+## 0.14.3-next-20261107160925
+
+### Patch Changes
+
+- ed6e436: The release notes on the Morpheme page and the start screen are rewritten in plainer words, in English and Danish.
+- aa478c9: After an update, the start screen shows a small card with the edition's photo and name instead of the large list of news.
+- 8b7e313: The buttons under Notifications are now Clear and Settings.
+- b1e7393: The Morpheme page names each version after its edition, with its date and photo, and a test version shows the changes merged since the last release.
+
 ## 0.14.2
 
 ### Patch Changes

package/lib/license-texts/Unsplash.txt

@@ -0,0 +1,7 @@
+Unsplash grants you an irrevocable, nonexclusive, worldwide copyright license to
+download, copy, modify, distribute, perform, and use photos from Unsplash for free,
+including for commercial purposes, without permission from or attributing the photographer
+or Unsplash. This license does not include the right to compile photos from Unsplash to
+replicate a similar or competing service.
+
+https://unsplash.com/license

package/lib/licenses.d.mts

@@ -98,6 +98,12 @@ export function declarationProblems({ license, thirdParty, folder, where, what,
  * checked with what it gives in place of what a package lacks (declarationProblems); those they depend on are not.
  * @param {string} root @param {string[]} folders @param {Set<string>} [skip] */
 export function codePackageProblems(root: string, folders: string[], skip?: Set<string>): any[];
+/** The photo of each edition the CMS carries (release-notes/editions/<line>.json and .webp, one per minor line, shown on
+ * the start screen after an update) as a work in "Licenser": a picture in the editor, its id `editions/<line>`, named after its place
+ * (en-US), by its photographer under the Unsplash License (license-texts/Unsplash.txt). An edition without a photographer
+ * gives a work without an author, which workProblems stops the build on.
+ * @param {string} cmsRoot the CMS package's folder @returns {object[]} */
+export function editionWorks(cmsRoot: string): object[];
 /** An app or a theme as licensesIntegration takes it: its kind and id, its name, version and who made it, its manifest
  * (its defineApp or its theme.json, with `license` and `thirdParty`), its folder, and whether the site is built with it
  * (an app installed; the theme in use, and the standard theme it builds on).
@@ -147,6 +153,8 @@ export const UNLICENSED: "UNLICENSED";
 export const OWN_LICENSE_FILE: "LICENSE";
 export function packageName(specifier: any): any;
 export function ownerId(kind: any, id: any): string;
+/** The licence of the editions' photos (release-notes/editions/), as "Licenser" shows it. */
+export const UNSPLASH_LICENSE: "Unsplash License";
 /**
  * An app or a theme as licensesIntegration takes it: its kind and id, its name, version and who made it, its manifest
  * (its defineApp or its theme.json, with `license` and `thirdParty`), its folder, and whether the site is built with it

package/lib/licenses.editions.test.mjs

@@ -0,0 +1,45 @@
+// Tests editionWorks in licenses.mjs: each edition's photo as a picture in the editor, under the Unsplash License.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { editionWorks, UNSPLASH_LICENSE, workProblems } from './licenses.mjs';
+
+const root = (editions) => {
+  const dir = mkdtempSync(join(tmpdir(), 'editions-'));
+  mkdirSync(join(dir, 'release-notes', 'editions'), { recursive: true });
+  for (const [version, edition] of Object.entries(editions))
+    writeFileSync(join(dir, 'release-notes', 'editions', `${version}.json`), JSON.stringify(edition));
+  return dir;
+};
+
+test("an edition's photo is a picture in the editor, by its photographer, under the Unsplash License", () => {
+  const [work] = editionWorks(
+    root({ 0.14: { name: 'Braies', place: { 'en-US': 'Lago di Braies, Italy' }, photo: { by: 'A Photographer' } } }),
+  );
+  assert.equal(work.id, 'editions/0.14');
+  assert.equal(work.name, 'Lago di Braies, Italy');
+  assert.equal(work.author, 'A Photographer');
+  assert.equal(work.license, UNSPLASH_LICENSE);
+  assert.equal(work.kind, 'image');
+  assert.deepEqual(work.where, ['editor']);
+  assert.match(work.text, /^Unsplash grants you an irrevocable/);
+  assert.deepEqual(workProblems(work, 'x'), []);
+});
+
+test('an edition without a photographer is a problem', () => {
+  const [work] = editionWorks(root({ 0.14: { name: 'Braies' } }));
+  assert.equal(work.name, 'Braies');
+  assert.equal(workProblems(work, 'x').length, 1);
+});
+
+test('no editions folder gives no works', () => {
+  assert.deepEqual(editionWorks(mkdtempSync(join(tmpdir(), 'none-'))), []);
+});
+
+test("the CMS's own editions all have a photographer", () => {
+  const works = editionWorks(new URL('..', import.meta.url).pathname);
+  assert.ok(works.length > 0);
+  for (const work of works) assert.deepEqual(workProblems(work, work.id), []);
+});

package/lib/licenses.mjs

@@ -433,6 +433,40 @@ const HELPERS = [
 ];
 const OWN_VIRTUAL = [/^\0virtual:(app-folders|all-icons|material-symbols|theme-coverage)$/, /^\0site-theme-icons?(:|$)/, /^\0app-self:/];
 
+// ---------------------------------------------------------------------------------------------------
+// The editions' photos
+
+/** The licence of the editions' photos (release-notes/editions/), as "Licenser" shows it. */
+export const UNSPLASH_LICENSE = 'Unsplash License';
+
+/** The photo of each edition the CMS carries (release-notes/editions/<line>.json and .webp, one per minor line, shown on
+ * the start screen after an update) as a work in "Licenser": a picture in the editor, its id `editions/<line>`, named after its place
+ * (en-US), by its photographer under the Unsplash License (license-texts/Unsplash.txt). An edition without a photographer
+ * gives a work without an author, which workProblems stops the build on.
+ * @param {string} cmsRoot the CMS package's folder @returns {object[]} */
+export function editionWorks(cmsRoot) {
+  const dir = join(cmsRoot, 'release-notes', 'editions');
+  if (!existsSync(dir)) return [];
+  const text = read(fileURLToPath(new URL('./license-texts/Unsplash.txt', import.meta.url)));
+  return readdirSync(dir)
+    .filter((f) => f.endsWith('.json'))
+    .sort()
+    .map((f) => {
+      const line = f.slice(0, -'.json'.length);
+      const edition = JSON.parse(readFileSync(join(dir, f), 'utf8'));
+      return {
+        id: `editions/${line}`,
+        name: edition.place?.['en-US'] ?? edition.name,
+        version: null,
+        author: edition.photo?.by ?? null,
+        license: UNSPLASH_LICENSE,
+        text,
+        kind: 'image',
+        where: ['editor'],
+      };
+    });
+}
+
 /** An app or a theme as licensesIntegration takes it: its kind and id, its name, version and who made it, its manifest
  * (its defineApp or its theme.json, with `license` and `thirdParty`), its folder, and whether the site is built with it
  * (an app installed; the theme in use, and the standard theme it builds on).
@@ -628,6 +662,12 @@ export function licensesIntegration({ root, iconPacks, owners }) {
           if (pack.theme) packWorks.set(pack.theme, [...(packWorks.get(pack.theme) ?? []), ...own.map((w) => w.id)]);
         }
 
+        // The editions' photos, which the editor shows after an update.
+        for (const work of editionWorks(fileURLToPath(new URL('..', import.meta.url)))) {
+          problems.push(...workProblems(work, `Udgaven ${work.id}`));
+          add(work);
+        }
+
         // The apps' and the themes' own licences and what they declare (checked by npm run check:content, with what they
         // give in place of what a package lacks), shipped or not; and what is shipped through them alone.
         const owned = [];

package/lib/releaseNotes.d.mts

@@ -16,9 +16,10 @@ export function problemsOf(pending: Pending): string[];
  * ids of the cards that have a screenshot. A locale without notes is left out.
  * @param {Pending} pending
  * @param {string} version
+ * @param {string} [date] the day it is released (YYYY-MM-DD)
  * @returns {Record<string, { file: ReleasedNotes, images: string[] }>}
  */
-export function released(pending: Pending, version: string): Record<string, {
+export function released(pending: Pending, version: string, date?: string): Record<string, {
     file: ReleasedNotes;
     images: string[];
 }>;
@@ -37,10 +38,18 @@ export function imagePath(version: string, locale: string, id: string): string;
  * @returns {ReleaseNote[] | undefined}
  */
 export function notesFor(notes: Record<string, ReleaseNote[]> | undefined, locale: string): ReleaseNote[] | undefined;
+/**
+ * The day a test version was made, from its snapshot id (0.14.3-next-20261107145215 → 2026-11-07); undefined for another
+ * version.
+ * @param {string} version
+ * @returns {string | undefined}
+ */
+export function testVersionDate(version: string): string | undefined;
 /**
  * The notes that are new since `from` (the version seen last), in `locale` (else English): those of the entries newer than
  * it, the newest version first, its cards before its lines. A test version (0.14.1-next.2) has not had the notes of its
- * own version yet. Nothing when `from` is not a version.
+ * own version yet. An entry of a test version (its merged, not yet released notes) counts as its version without the
+ * pre-release. Nothing when `from` is not a version.
  * @param {{ version: string, notes?: Record<string, ReleaseNote[]> }[]} entries
  * @param {string | undefined} from
  * @param {string} locale
@@ -51,21 +60,67 @@ export function notesSince(entries: {
     notes?: Record<string, ReleaseNote[]>;
 }[], from: string | undefined, locale: string): ReleaseNote[];
 /**
- * The notes of every released version in the running minor line (x.y.0 up to `version`), from the files the package carries
- * (release-notes/i18n/<locale>/<version>.json), newest first. A card gets the address of its screenshot
- * (<locale>/<version>/<id>.webp) when that file exists. Versions of another minor, newer versions and versions without notes are left out.
- * A test version (0.14.2-next.0, the npm tag next) has not had the notes of its own version yet: the line up to the one before.
+ * The changelog's versions (CHANGELOG.md, as Changesets writes it), each with its changes as lines: a bullet's text
+ * without its commit ("- 3fbb65f: The start screen …" → "The start screen …", its id the commit) and code marks, with the
+ * lines it runs on to. Newest first; a version that is not x.y.z is left out.
+ * @param {string} changelog
+ * @returns {{ version: string, lines: ReleaseNote[] }[]}
+ */
+export function changelogSections(changelog: string): {
+    version: string;
+    lines: ReleaseNote[];
+}[];
+/**
+ * The notes of every released version up to `version`, from the files the package carries
+ * (release-notes/i18n/<locale>/<version>.json), and before them from its changelog, newest first. A card gets the address
+ * of its screenshot (<locale>/<version>/<id>.webp) when that file exists. Newer versions and versions without notes are left out.
+ * A test version (0.14.2-next.0, the npm tag next) has not had the notes of its own version yet: the line up to the one before,
+ * then, first, its merged notes (`pending`). Each released version has the day it was released (its file's `date`).
  * It runs as the editor loads (bundledNotes.ts), so it never throws: nothing when `version` is not a version.
  * @param {Record<string, ReleasedNotes>} files path -> parsed notes file, e.g. '../release-notes/i18n/en-US/0.14.0.json'
  * @param {Record<string, string>} images path -> address, e.g. '../release-notes/i18n/en-US/0.14.0/<id>.webp'
  * @param {string} version the running version
- * @returns {{ version: string, text: string, notes: Record<string, ReleaseNote[]> }[]}
+ * @param {Record<string, ReleaseNote>} [pending] path -> a note not released yet, e.g. '../release-notes/i18n/en-US/pending/<id>.json':
+ *   on a test version, the notes merged since the last release, as the first entry, under the running version, dated by
+ *   its snapshot id (testVersionDate); a card's screenshot <locale>/pending/<id>.webp
+ * @param {string} [changelog] the package's CHANGELOG.md: the versions without a notes file (those before the notes),
+ *   with their changes as lines, in English (changelogSections)
+ * @returns {{ version: string, text: string, date?: string, notes: Record<string, ReleaseNote[]> }[]}
  */
-export function bundledNotes(files: Record<string, ReleasedNotes>, images: Record<string, string>, version: string): {
+export function bundledNotes(files: Record<string, ReleasedNotes>, images: Record<string, string>, version: string, pending?: Record<string, ReleaseNote>, changelog?: string): {
     version: string;
     text: string;
+    date?: string;
     notes: Record<string, ReleaseNote[]>;
 }[];
+/**
+ * The entries grouped by minor line, newest line first, each line's entries in their order (bundledNotes'): one page each.
+ * @template {{ version: string }} T
+ * @param {T[]} entries
+ * @returns {{ line: string, entries: T[] }[]}
+ */
+export function versionLines<T extends {
+    version: string;
+}>(entries: T[]): {
+    line: string;
+    entries: T[];
+}[];
+/** @typedef {{ line: string, name: string, place: Record<string, string>, by: string | null, image: string }} Edition  line: its minor line ("0.14"); name: the place its photo is from, short ("Braies"); place: in full, per locale; by: its photographer; image: the photo's address */
+/**
+ * The edition of a version's minor line: one photo per line (release-notes/editions/<line>.json with its photo
+ * <line>.webp, e.g. 0.14.json for every 0.14 version, a test version 0.14.3-next-… too).
+ * @param {Record<string, { name?: string, place?: Record<string, string>, photo?: { by?: string } }>} files path -> the edition's file
+ * @param {Record<string, string>} images path -> the photo's address
+ * @param {string} version
+ * @returns {Edition | undefined} undefined when its line has none, or it has no name or no photo
+ */
+export function editionOf(files: Record<string, {
+    name?: string;
+    place?: Record<string, string>;
+    photo?: {
+        by?: string;
+    };
+}>, images: Record<string, string>, version: string): Edition | undefined;
 /**
  * The release notes and screenshots of `version` from an unzipped npm tar. Notes: package/release-notes/i18n/<locale>/<version>.json
  * per locale. Screenshots: one per card, at imagePath(). A missing or unreadable notes file leaves its locale out; a missing
@@ -109,7 +164,7 @@ export function parseImagePath(pathname: string): {
  */
 export function withImageUrls(version: string, notes: Record<string, ReleaseNote[]> | undefined): Record<string, ReleaseNote[]> | undefined;
 /** @typedef {{ id: string, kind: 'card', title: string, text: string, image?: string } | { id: string, kind: 'line', text: string }} ReleaseNote */
-/** @typedef {{ version: string, notes: ReleaseNote[] }} ReleasedNotes */
+/** @typedef {{ version: string, date?: string, notes: ReleaseNote[] }} ReleasedNotes  date: the day it was released (YYYY-MM-DD) */
 /** @typedef {{ width: number, height: number }} ImageSize */
 /** @typedef {{ note: object, imageBytes: number | null, imageSize: ImageSize | null }} PendingEntry  imageBytes: size of <id>.webp in bytes, null when there is none; imageSize: its pixels, null when it is not a WebP */
 /** @typedef {Record<string, Record<string, PendingEntry>>} Pending  locale -> id -> entry */
@@ -118,8 +173,19 @@ export const MAX_IMAGE_BYTES: number;
 /** The width of a card's screenshot in pixels (375 CSS pixels at scale 2) and its greatest height (400 CSS pixels at scale 2). */
 export const IMAGE_WIDTH: 750;
 export const MAX_IMAGE_HEIGHT: 800;
+export function minorOf(version: string): string;
 export function staleImageDirs(dirs: string[], version: string): string[];
 export function imageKey(version: string, locale: string, id: string): string;
+/**
+ * line: its minor line ("0.14"); name: the place its photo is from, short ("Braies"); place: in full, per locale; by: its photographer; image: the photo's address
+ */
+export type Edition = {
+    line: string;
+    name: string;
+    place: Record<string, string>;
+    by: string | null;
+    image: string;
+};
 export type ReleaseNote = {
     id: string;
     kind: "card";
@@ -131,8 +197,12 @@ export type ReleaseNote = {
     kind: "line";
     text: string;
 };
+/**
+ * date: the day it was released (YYYY-MM-DD)
+ */
 export type ReleasedNotes = {
     version: string;
+    date?: string;
     notes: ReleaseNote[];
 };
 export type ImageSize = {

package/lib/releaseNotes.mjs

@@ -2,12 +2,12 @@
 // picks a locale's notes and those new since a version, builds the notes of the running minor line from the package files and reads a version's notes and screenshots from its tar.
 // Also builds the Worker's screenshot address and KV key, parses the address and adds the address to a version's cards.
 // Exposes MAX_IMAGE_BYTES, IMAGE_WIDTH, MAX_IMAGE_HEIGHT, webpSize, problemsOf, released, imagePath, notesFor, notesSince, bundledNotes, staleImageDirs, notesFromTar, imageUrl, imageKey,
-// parseImagePath and withImageUrls. Depends on ./cms-version.mjs and ./changelog.mjs; no node: imports.
+// parseImagePath, withImageUrls, editionOf, testVersionDate, changelogSections, minorOf and versionLines. Depends on ./cms-version.mjs and ./changelog.mjs; no node: imports.
 import { compareVersions } from './cms-version.mjs';
 import { bytesFromTar, fileFromTar } from './changelog.mjs';
 
 /** @typedef {{ id: string, kind: 'card', title: string, text: string, image?: string } | { id: string, kind: 'line', text: string }} ReleaseNote */
-/** @typedef {{ version: string, notes: ReleaseNote[] }} ReleasedNotes */
+/** @typedef {{ version: string, date?: string, notes: ReleaseNote[] }} ReleasedNotes  date: the day it was released (YYYY-MM-DD) */
 /** @typedef {{ width: number, height: number }} ImageSize */
 /** @typedef {{ note: object, imageBytes: number | null, imageSize: ImageSize | null }} PendingEntry  imageBytes: size of <id>.webp in bytes, null when there is none; imageSize: its pixels, null when it is not a WebP */
 /** @typedef {Record<string, Record<string, PendingEntry>>} Pending  locale -> id -> entry */
@@ -118,15 +118,16 @@ export function problemsOf(pending) {
  * ids of the cards that have a screenshot. A locale without notes is left out.
  * @param {Pending} pending
  * @param {string} version
+ * @param {string} [date] the day it is released (YYYY-MM-DD)
  * @returns {Record<string, { file: ReleasedNotes, images: string[] }>}
  */
-export function released(pending, version) {
+export function released(pending, version, date) {
   const result = {};
   for (const [locale, entries] of Object.entries(pending)) {
     const ids = Object.keys(entries).sort();
     if (ids.length === 0) continue;
     result[locale] = {
-      file: { version, notes: ids.map((id) => entries[id].note) },
+      file: { version, ...(date ? { date } : {}), notes: ids.map((id) => entries[id].note) },
       images: ids.filter((id) => entries[id].note.kind === 'card'),
     };
   }
@@ -155,11 +156,25 @@ export function notesFor(notes, locale) {
 }
 
 const PLAIN = /^\d+\.\d+\.\d+$/;
+/** A version without its pre-release (0.14.3-next-20261107145215 → 0.14.3). */
+const baseOf = (version) => String(version ?? '').split('-')[0];
+
+/**
+ * The day a test version was made, from its snapshot id (0.14.3-next-20261107145215 → 2026-11-07); undefined for another
+ * version.
+ * @param {string} version
+ * @returns {string | undefined}
+ */
+export function testVersionDate(version) {
+  const m = /-next-(\d{4})(\d{2})(\d{2})\d*$/.exec(String(version ?? ''));
+  return m ? `${m[1]}-${m[2]}-${m[3]}` : undefined;
+}
 
 /**
  * The notes that are new since `from` (the version seen last), in `locale` (else English): those of the entries newer than
  * it, the newest version first, its cards before its lines. A test version (0.14.1-next.2) has not had the notes of its
- * own version yet. Nothing when `from` is not a version.
+ * own version yet. An entry of a test version (its merged, not yet released notes) counts as its version without the
+ * pre-release. Nothing when `from` is not a version.
  * @param {{ version: string, notes?: Record<string, ReleaseNote[]> }[]} entries
  * @param {string | undefined} from
  * @param {string} locale
@@ -169,43 +184,143 @@ export function notesSince(entries, from, locale) {
   const [base, pre] = String(from ?? '').split('-');
   if (!PLAIN.test(base)) return [];
   const notes = entries
-    .filter((entry) => PLAIN.test(entry.version) && compareVersions(entry.version, base) >= (pre === undefined ? 1 : 0))
-    .sort((a, b) => compareVersions(b.version, a.version))
+    .filter((entry) => PLAIN.test(baseOf(entry.version)) && compareVersions(baseOf(entry.version), base) >= (pre === undefined ? 1 : 0))
+    .sort((a, b) => compareVersions(baseOf(b.version), baseOf(a.version)))
     .flatMap((entry) => notesFor(entry.notes, locale) ?? []);
   return [...notes.filter((note) => note.kind === 'card'), ...notes.filter((note) => note.kind === 'line')];
 }
+/**
+ * The changelog's versions (CHANGELOG.md, as Changesets writes it), each with its changes as lines: a bullet's text
+ * without its commit ("- 3fbb65f: The start screen …" → "The start screen …", its id the commit) and code marks, with the
+ * lines it runs on to. Newest first; a version that is not x.y.z is left out.
+ * @param {string} changelog
+ * @returns {{ version: string, lines: ReleaseNote[] }[]}
+ */
+export function changelogSections(changelog) {
+  // Markdown's code marks are not shown: the page writes plain text.
+  const plain = (text) => text.replace(/`([^`]*)`/g, '$1').trim();
+  const sections = [];
+  let current = null;
+  let last = null;
+  for (const raw of String(changelog ?? '').split(/\r?\n/)) {
+    if (raw.startsWith('## ')) {
+      const version = raw.slice(3).trim();
+      current = PLAIN.test(version) ? { version, lines: [] } : null;
+      if (current) sections.push(current);
+      last = null;
+    } else if (current && /^- /.test(raw)) {
+      const m = /^- (?:([0-9a-f]{7,40}): )?(.*)$/.exec(raw);
+      last = { id: `${current.version}-${m[1] ?? current.lines.length}`, kind: 'line', text: plain(m[2]) };
+      current.lines.push(last);
+    } else if (last && /^\s+\S/.test(raw)) {
+      last.text = `${last.text} ${plain(raw)}`;
+    } else if (raw.trim() === '' || raw.startsWith('#')) {
+      last = null;
+    }
+  }
+  return sections.sort((a, b) => compareVersions(b.version, a.version));
+}
+
 const sameMinor = (a, b) => a.split('.').slice(0, 2).join('.') === b.split('.').slice(0, 2).join('.');
 
 /**
- * The notes of every released version in the running minor line (x.y.0 up to `version`), from the files the package carries
- * (release-notes/i18n/<locale>/<version>.json), newest first. A card gets the address of its screenshot
- * (<locale>/<version>/<id>.webp) when that file exists. Versions of another minor, newer versions and versions without notes are left out.
- * A test version (0.14.2-next.0, the npm tag next) has not had the notes of its own version yet: the line up to the one before.
+ * The notes of every released version up to `version`, from the files the package carries
+ * (release-notes/i18n/<locale>/<version>.json), and before them from its changelog, newest first. A card gets the address
+ * of its screenshot (<locale>/<version>/<id>.webp) when that file exists. Newer versions and versions without notes are left out.
+ * A test version (0.14.2-next.0, the npm tag next) has not had the notes of its own version yet: the line up to the one before,
+ * then, first, its merged notes (`pending`). Each released version has the day it was released (its file's `date`).
  * It runs as the editor loads (bundledNotes.ts), so it never throws: nothing when `version` is not a version.
  * @param {Record<string, ReleasedNotes>} files path -> parsed notes file, e.g. '../release-notes/i18n/en-US/0.14.0.json'
  * @param {Record<string, string>} images path -> address, e.g. '../release-notes/i18n/en-US/0.14.0/<id>.webp'
  * @param {string} version the running version
- * @returns {{ version: string, text: string, notes: Record<string, ReleaseNote[]> }[]}
+ * @param {Record<string, ReleaseNote>} [pending] path -> a note not released yet, e.g. '../release-notes/i18n/en-US/pending/<id>.json':
+ *   on a test version, the notes merged since the last release, as the first entry, under the running version, dated by
+ *   its snapshot id (testVersionDate); a card's screenshot <locale>/pending/<id>.webp
+ * @param {string} [changelog] the package's CHANGELOG.md: the versions without a notes file (those before the notes),
+ *   with their changes as lines, in English (changelogSections)
+ * @returns {{ version: string, text: string, date?: string, notes: Record<string, ReleaseNote[]> }[]}
  */
-export function bundledNotes(files, images, version) {
+export function bundledNotes(files, images, version, pending = {}, changelog = '') {
   const [base, pre] = String(version ?? '').split('-');
   if (!PLAIN.test(base)) return [];
   const byVersion = {};
+  const dates = {};
+  const withImage = (note, locale, folder) => {
+    if (note?.kind !== 'card') return note;
+    const image = Object.entries(images).find(([imagePath]) => imagePath.endsWith(`/i18n/${locale}/${folder}/${note.id}.webp`));
+    return image ? { ...note, image: image[1] } : note;
+  };
   for (const [path, file] of Object.entries(files)) {
     const match = /\/i18n\/([^/]+)\/([^/]+)\.json$/.exec(path);
     if (!match || !Array.isArray(file?.notes)) continue;
     const [, locale, v] = match;
-    if (!PLAIN.test(v) || !sameMinor(v, base) || compareVersions(v, base) >= (pre === undefined ? 1 : 0)) continue;
+    if (!PLAIN.test(v) || compareVersions(v, base) >= (pre === undefined ? 1 : 0)) continue;
     byVersion[v] ??= {};
-    byVersion[v][locale] = file.notes.map((note) => {
-      if (note?.kind !== 'card') return note;
-      const image = Object.entries(images).find(([imagePath]) => imagePath.endsWith(`/i18n/${locale}/${v}/${note.id}.webp`));
-      return image ? { ...note, image: image[1] } : note;
-    });
+    byVersion[v][locale] = file.notes.map((note) => withImage(note, locale, v));
+    if (typeof file.date === 'string') dates[v] ??= file.date;
+  }
+  // The versions from before the notes files: their changelog lines, in English.
+  for (const section of changelogSections(changelog)) {
+    const v = section.version;
+    if (byVersion[v] || compareVersions(v, base) >= (pre === undefined ? 1 : 0) || !section.lines.length) continue;
+    byVersion[v] = { 'en-US': section.lines };
   }
-  return Object.keys(byVersion)
+  const entries = Object.keys(byVersion)
     .sort((a, b) => compareVersions(b, a))
-    .map((v) => ({ version: v, text: '', notes: byVersion[v] }));
+    .map((v) => ({ version: v, text: '', ...(dates[v] ? { date: dates[v] } : {}), notes: byVersion[v] }));
+  if (pre === undefined) return entries;
+  // A test version: the notes merged since the last release, by locale, sorted by id as release:version will.
+  const merged = {};
+  for (const [path, note] of Object.entries(pending).sort(([a], [b]) => a.localeCompare(b))) {
+    const locale = /\/i18n\/([^/]+)\/pending\/[^/]+\.json$/.exec(path)?.[1];
+    if (!locale || !note?.kind) continue;
+    (merged[locale] ??= []).push(withImage(note, locale, 'pending'));
+  }
+  if (!Object.keys(merged).length) return entries;
+  const date = testVersionDate(version);
+  return [{ version, text: '', ...(date ? { date } : {}), notes: merged }, ...entries];
+}
+
+/**
+ * A version's minor line, as its page names it (0.14.3-next-… → "0.14").
+ * @param {string} version
+ * @returns {string}
+ */
+export const minorOf = (version) => baseOf(version).split('.').slice(0, 2).join('.');
+
+/**
+ * The entries grouped by minor line, newest line first, each line's entries in their order (bundledNotes'): one page each.
+ * @template {{ version: string }} T
+ * @param {T[]} entries
+ * @returns {{ line: string, entries: T[] }[]}
+ */
+export function versionLines(entries) {
+  const lines = new Map();
+  for (const entry of entries) {
+    const line = minorOf(entry.version);
+    if (!lines.has(line)) lines.set(line, []);
+    lines.get(line).push(entry);
+  }
+  return [...lines].map(([line, list]) => ({ line, entries: list })).sort((a, b) => compareVersions(`${b.line}.0`, `${a.line}.0`));
+}
+
+/** @typedef {{ line: string, name: string, place: Record<string, string>, by: string | null, image: string }} Edition  line: its minor line ("0.14"); name: the place its photo is from, short ("Braies"); place: in full, per locale; by: its photographer; image: the photo's address */
+
+/**
+ * The edition of a version's minor line: one photo per line (release-notes/editions/<line>.json with its photo
+ * <line>.webp, e.g. 0.14.json for every 0.14 version, a test version 0.14.3-next-… too).
+ * @param {Record<string, { name?: string, place?: Record<string, string>, photo?: { by?: string } }>} files path -> the edition's file
+ * @param {Record<string, string>} images path -> the photo's address
+ * @param {string} version
+ * @returns {Edition | undefined} undefined when its line has none, or it has no name or no photo
+ */
+export function editionOf(files, images, version) {
+  if (!PLAIN.test(baseOf(version))) return undefined;
+  const line = minorOf(version);
+  const file = Object.entries(files).find(([path]) => path.endsWith(`/editions/${line}.json`))?.[1];
+  const image = Object.entries(images).find(([path]) => path.endsWith(`/editions/${line}.webp`))?.[1];
+  if (!file || !image || !isFilled(file.name)) return undefined;
+  return { line, name: file.name.trim(), place: file.place ?? {}, by: file.photo?.by ?? null, image };
 }
 
 /**