domma-cms 1.8.10 → 1.8.12

package/server/services/seo/index.js

@@ -3,7 +3,11 @@
  *
  *  - Redirects: a global onRequest guard (GET/HEAD, never /api or /admin);
  *    rules in content/seo/redirects.json (admin/js/lib/seo-redirects.js).
- *    A renamed page gets one (content:pageRenamed), older rules re-aimed.
+ *    A renamed page gets one (content:pageRenamed), older rules re-aimed -
+ *    never one FROM "/" (the home address). A page at "/" always wins over a
+ *    rule from "/": made, saved or moved there published, the rule is removed
+ *    (as a page moved anywhere removes the rule from its new address), and at
+ *    start an automatic one an older version left is removed if one is there.
  *  - What search engines are given: the 'seo:meta', 'sitemap:entries' and
  *    'robots:lines' transforms (hooks.js section 8) - a URL's overrides,
  *    Organization / BlogPosting JSON-LD, sitemap exclusions, robots rules.
@@ -30,7 +34,7 @@ import {applySeo, robotsLines} from '../../../admin/js/lib/seo-schema.js';
 import {checkSettings, excluded, mergeDefaults} from '../../../admin/js/lib/seo-settings.js';
 import {getConfig, saveConfig} from '../../config.js';
 import {hooks as coreHooks, getSitemapSources, registerTransform} from '../hooks.js';
-import {listPages} from '../content.js';
+import {getPage, listPages} from '../content.js';
 import {invalidateTags} from '../cache/index.js';
 
 const SKIP = /^\/(api|admin)(\/|$)/;
@@ -129,8 +133,30 @@ async function seo(fastify, {enabled = true, getBaseUrl = null, rolesService = n
     const saveHits = setInterval(() => store.saveHits(), 60_000);
     saveHits.unref?.();
 
-    const onRenamed = ({from, to} = {}) => {
-        if (!cfg.redirects.onRename || !from || !to) return;
+    /**
+     * A page is at "/" now: a rule from "/" would hide it, so it goes - the page wins, as it does at any
+     * address a page is moved to (onMoved). `autoOnly`: only rules SEO added itself (the start-up tidy).
+     */
+    const clearHomeRule = (why, {autoOnly = false} = {}) => {
+        const drop = store.rules().filter(r => r.from === '/' && (!autoOnly || r.auto));
+        if (!drop.length) return;
+        const ids = new Set(drop.map(r => r.id));
+        store.setRules(store.rulesWithHits().filter(r => !ids.has(r.id)));
+        sitemapChanged();
+        log.info(`[seo] a page is at / (${why}): the redirect from / to ${drop.map(r => r.to || 'gone').join(', ')} was removed.`);
+    };
+    // Earlier versions added "/ -> its new address" when the home page was moved away, hiding any page made at "/" since.
+    // Only a page the public can see wins: a draft at "/" answers 404 to them, so a redirect from "/" stays until it is published.
+    const liveHome = (page) => Boolean(page) && page.status !== 'draft';
+    try { if (store.rules().some(r => r.from === '/' && r.auto) && liveHome(await getPage('/').catch(() => null))) clearHomeRule('found at start', {autoOnly: true}); } catch { /* left as it is */ }
+
+    const onRenamed = ({from, to, redirect} = {}) => {
+        // A page moved to "/" lives there now, whatever the settings - a rule from "/" would hide it.
+        if (to && normalisePath(to) === '/') {
+            getPage('/').then((p) => { if (liveHome(p)) clearHomeRule(`moved there from ${from}`); }).catch(() => {});
+        }
+        // redirect: false - the old address is not to lead to the new one (the home page moved aside).
+        if (!cfg.redirects.onRename || !from || !to || redirect === false) return;
         try {
             store.setRules(onMoved(store.rulesWithHits(), from, to, {id: newId()}));
             log.info(`[seo] ${from} moved to ${to}: redirect added.`);
@@ -139,6 +165,12 @@ async function seo(fastify, {enabled = true, getBaseUrl = null, rolesService = n
         }
     };
     coreHooks.on('content:pageRenamed', onRenamed);
+    // Made at "/", or saved there as published (a draft made first, then published).
+    const onSaved = ({page, urlPath} = {}) => {
+        if (urlPath && normalisePath(urlPath) === '/' && liveHome(page)) { try { clearHomeRule('published there'); } catch { /* left as it is */ } }
+    };
+    coreHooks.on('content:pageCreated', onSaved);
+    coreHooks.on('content:pageUpdated', onSaved);
 
     // ---- 2. What search engines are given ----
     registerTransform('seo:meta', (meta, ctx) => {
@@ -326,6 +358,8 @@ async function seo(fastify, {enabled = true, getBaseUrl = null, rolesService = n
     fastify.addHook('onClose', (_i, done) => {
         clearInterval(timer); clearInterval(saveHits); clearTimeout(first);
         coreHooks.off?.('content:pageRenamed', onRenamed);
+        coreHooks.off?.('content:pageCreated', onSaved);
+        coreHooks.off?.('content:pageUpdated', onSaved);
         store.close();
         done();
     });

package/server/services/wpImport/front.js

@@ -0,0 +1,82 @@
+/**
+ * WordPress's home page setting (Settings › Reading) - read from what the
+ * export does carry, since its options (show_on_front, page_on_front,
+ * page_for_posts) are not in a WXR file. PURE: no I/O.
+ *
+ *   front page  WordPress writes each item's <link> with get_permalink(), and
+ *               the static front page's permalink is the site's home address.
+ *               So: the one published page whose link IS the home address
+ *               (http/https, www and a trailing slash aside). Never by title -
+ *               a page called "Home" is just a page. Two such pages, or none,
+ *               and there is no front page. A password-protected one is not
+ *               offered: it would arrive as a draft and leave "/" empty.
+ *   posts page  Cannot be known for certain: only offered as a suggestion -
+ *               a published page with nothing in it whose slug is a usual
+ *               name for a blog (or the Blog's own address here). The person
+ *               confirms it.
+ *   no front    WordPress showed its latest posts on the home page.
+ *
+ * @module services/wpImport/front
+ */
+
+/** Slugs a WordPress posts page usually has. */
+export const POSTS_PAGE_SLUGS = ['blog', 'news', 'posts', 'articles', 'journal'];
+
+/** An address reduced to what identifies it: host without www, path without its trailing slash. Null when not a web address. */
+export function addressKey(url) {
+    let u;
+    try { u = new URL(String(url || '').trim()); } catch { return null; }
+    if (u.protocol !== 'http:' && u.protocol !== 'https:') return null;
+    let p = u.pathname;
+    try { p = decodeURI(p); } catch { /* keep */ }
+    p = `/${p}`.replace(/\/{2,}/g, '/').replace(/\/+$/, '').toLowerCase();
+    // A query or a port is part of the address: /?page_id=5 is not the home page.
+    return `${u.hostname.toLowerCase().replace(/^www\./, '')}${u.port ? `:${u.port}` : ''}${p}${u.search}`;
+}
+
+/** The home address(es) the export names: the channel link and wp:base_blog_url (both home_url()); wp:base_site_url only without them. */
+export function homeKeys(site = {}) {
+    const keys = new Set([site.link, site.baseBlogUrl].map(addressKey).filter(Boolean));
+    if (!keys.size) { const k = addressKey(site.baseSiteUrl); if (k) keys.add(k); }
+    return keys;
+}
+
+/**
+ * The page WordPress used as its home page.
+ *
+ * @param {object} wxr - from readWxr()
+ * @returns {{page: object|null, matches: number}} matches: how many published pages had the home address
+ */
+export function detectFrontPage(wxr) {
+    const homes = homeKeys(wxr?.site);
+    if (!homes.size) return {page: null, matches: 0};
+    const found = (wxr.items || []).filter(it => it.type === 'page' && it.status === 'publish' && !it.password && homes.has(addressKey(it.link)));
+    return {page: found.length === 1 ? found[0] : null, matches: found.length};
+}
+
+/** Does this WordPress content have nothing a reader would see? (Block comments, empty tags, &nbsp; and spaces only.) */
+export function isEmptyContent(html) {
+    const s = String(html || '')
+        .replace(/<!--[\s\S]*?-->/g, '')
+        .replace(/<(img|video|audio|iframe|embed|object|svg|canvas|form|input|table|hr)\b/gi, 'X')
+        .replace(/<[^>]*>/g, '')
+        .replace(/&nbsp;|&#160;|&#xa0;/gi, ' ');
+    return !/\[[a-z]/i.test(s) && !s.trim();
+}
+
+/**
+ * The page that was probably WordPress's posts page - a suggestion only.
+ *
+ * @param {object} wxr
+ * @param {{front?: object|null, blogBase?: string}} [o] - the front page (never suggested); the Blog's address here
+ * @returns {object|null} the WordPress page
+ */
+export function suggestPostsPage(wxr, {front = null, blogBase = ''} = {}) {
+    const base = String(blogBase || '').split('/').filter(Boolean).pop() || '';
+    const slugOf = (it) => String(it.slug || '').toLowerCase();
+    const candidates = (wxr?.items || []).filter(it => it.type === 'page' && it.status === 'publish' && !it.password
+        && it.id !== front?.id && isEmptyContent(it.content) && (POSTS_PAGE_SLUGS.includes(slugOf(it)) || (base && slugOf(it) === base)));
+    // The Blog's own address first, then the usual names in order.
+    const rank = (it) => (base && slugOf(it) === base ? -1 : POSTS_PAGE_SLUGS.indexOf(slugOf(it)));
+    return candidates.sort((a, b) => rank(a) - rank(b) || a.id - b.id)[0] || null;
+}

package/server/services/wpImport/index.js

@@ -42,6 +42,14 @@
  * services/renderer.js) - added once, never taken out, and not put back once
  * someone removed it here.
  *
+ * The home page (./front.js): the page WordPress showed at its home address
+ * becomes this site's home page. The page at "/" before is moved to
+ * /previous-home as a draft - never deleted, never overwritten - by the first
+ * run that does it, and never again unless the person says Yes to the preview's
+ * question (an earlier import set the home page and this export's front page is
+ * another page; a run without the answer is refused). That move leaves the
+ * menus' "/" alone and adds no redirect (renamePage's `redirect: false`).
+ *
  * The one request hook here answers WordPress's query addresses (/?p=12,
  * /?page_id=7, /?attachment_id=3) from the mapping; path redirects go into
  * SEO's redirect store.
@@ -60,14 +68,14 @@ import {convertContent} from './convert.js';
 import {currencyDecimals, mergeForUpdate, productFingerprintParts, readWooProducts, shopProductInput} from './woo.js';
 import {fetchMedia, testHostsAllowed} from './fetch.js';
 import {
-    addHistory, clearRunning, createStaging, dropStaging, fingerprint, markRunning, recordFailedRun, recoverInterrupted, followRename, forgetMapCache, mappingFor, newId, queryTarget, saveMapping,
+    addHistory, clearRunning, readMap, createStaging, dropStaging, fingerprint, markRunning, recordFailedRun, recoverInterrupted, followRename, forgetMapCache, mappingFor, newId, queryTarget, saveMapping,
     stagingMeta, stagingPath, updateStagingMeta
 } from './store.js';
-import {createPage, getPage, listMedia, listPages, resolveExistingFilePath, saveMedia, updatePage} from '../content.js';
+import {createPage, getPage, listMedia, listPages, renamePage, resolveExistingFilePath, saveMedia, updatePage} from '../content.js';
 import {createCollection, createEntry, getCollection, getEntry, listCollections, listEntries, updateCollection, updateEntry} from '../collections.js';
 import {customEntryData, customFields, customTypesOf, entryFingerprintText, listPageBody, mediaContext, mergeFields, schemaFields, stripShortcodes} from './custom.js';
 import {getPluginStates} from '../plugins.js';
-import {createMenu, getMenu, listMenus, updateMenu} from '../menus.js';
+import {createMenu, getMenu, listMenus, relinkMenus, updateMenu} from '../menus.js';
 import {createUser, getUserByEmail, getUserById, listUsers} from '../users.js';
 import {adminInvite} from '../passwordReset.js';
 import {adminRightsGiven} from '../notification-sources.js';
@@ -228,9 +236,10 @@ export function footerBlockList(site = null) {
 }
 
 /** The site's state as the planner needs it. */
-export async function siteState(mapping = {}) {
+export async function siteState(mapping = {}, source = '') {
     const pages = await listPages();
     const pagePaths = new Set(pages.map(p => String(p.urlPath || '/').toLowerCase()));
+    const homePage = pages.find(p => String(p.urlPath || '/') === '/');
     const pageHashes = {};
     for (const m of Object.values(mapping.items || {})) {
         if (m.path && pagePaths.has(m.path)) pageHashes[m.path] = await pageFingerprint(m.path);
@@ -288,9 +297,18 @@ export async function siteState(mapping = {}) {
     try { searchOn = getSearchSettings().enabled !== false; } catch { /* no search settings */ }
     const seo = seoEngine();
     // The users here - only what matching an author needs (never a password or a token).
+    // The home page set by an import of ANOTHER WordPress site (the latest, when several did): the plan asks
+    // before this export's front page takes its place.
+    let homeSetBy = null;
+    try {
+        for (const [key, src] of Object.entries((await readMap()).sources || {})) {
+            const rec = src?.items?.home;
+            if (key !== source && rec?.kind === 'home' && (!homeSetBy || String(rec.at || '') > String(homeSetBy.at || ''))) homeSetBy = {...rec, source: key};
+        }
+    } catch { /* no imports yet */ }
     const users = (await listUsers().catch(() => [])).map(u => ({id: u.id, email: String(u.email || '').toLowerCase(), name: u.name || ''}));
     return {
-        pagePaths, pageHashes, shop, collections, customEntries, users,
+        pagePaths, pageHashes, homeSetBy, homeTitle: homePage ? String(homePage.title || '') : null, shop, collections, customEntries, users,
         blockNames, blockHashes, footerBlocks: footerBlockList(), searchOn,
         shortcodes: new Set(getShortcodeProcessors().map(p => p.name)),
         mediaNames: new Set(media.map(m => String(m.name).toLowerCase())),
@@ -407,7 +425,7 @@ export async function previewImport(id, options = {}) {
     const wxr = await loadExport(id);
     const {sourceKey} = await import('./plan.js');
     const mapping = await mappingFor(sourceKey(wxr.site));
-    const state = await siteState(mapping);
+    const state = await siteState(mapping, sourceKey(wxr.site));
     const zipPaths = options.media === 'zip' ? await uploadsIndex(id) : null;
     const wie = await loadWidgets(id);
     // `people` (what the person may do with users) comes from the route, never from the request body.
@@ -435,7 +453,14 @@ export function cleanOptions(o = {}) {
         choices,
         users: cleanUserChoices(o.users),
         userRole: typeof o.userRole === 'string' && /^[a-z0-9][a-z0-9_-]{0,59}$/i.test(o.userRole) ? o.userRole : '',
-        invite: o.invite === true
+        invite: o.invite === true,
+        // The home page: WordPress's front page made this site's (on unless refused), the suggested posts page
+        // confirmed (its WordPress id - the plan accepts only the one it suggests), the latest posts instead.
+        home: o.home !== false,
+        postsPage: Number.isInteger(o.postsPage) && o.postsPage > 0 && o.postsPage < 1e12 ? o.postsPage : 0,
+        latestPosts: o.latestPosts === true,
+        // The answer to the home page question (plan.home.question): true, false, or not answered.
+        homeReplace: typeof o.homeReplace === 'boolean' ? o.homeReplace : null
     };
 }
 
@@ -489,6 +514,11 @@ export async function startRun(id, options, user, log = console) {
         if (pre.plan.options.media === 'zip' && !pre.meta.uploads) {
             throw Object.assign(new Error('Upload the wp-content/uploads zip first, or choose another media source.'), {statusCode: 400});
         }
+        // Whether this export's front page replaces the home page an earlier import set is never assumed.
+        const q = pre.plan.home?.question;
+        if (q && typeof q.answer !== 'boolean') {
+            throw Object.assign(new Error(`Answer the home page question first: make "${q.title}" the home page instead of "${q.current || 'the page at /'}"?`), {statusCode: 400});
+        }
     } catch (err) {
         running = null;
         throw err;
@@ -616,8 +646,10 @@ async function runPhases(job, {plan, wxr, oldMapping, meta, inviteOrigin, wie},
     // Address lookups for content and menus.
     // A custom item kept in a collection is reached through its type's list page.
     const addressOf = (r) => (r.kind === 'custom' && r.as === 'collection' ? r.listAt : r.target);
-    const targetOf = new Map(plan.items.filter(r => (r.kind === 'page' || r.kind === 'post' || r.kind === 'product' || r.kind === 'custom') && !r.listFor && addressOf(r) && r.action !== 'skip').map(r => [r.wpId, addressOf(r)]));
-    const oldPathTarget = new Map(plan.items.filter(r => r.oldPath && addressOf(r) && r.kind !== 'collection' && r.action !== 'skip').map(r => [r.oldPath, addressOf(r)]));
+    // A confirmed posts page is not made, but links and menu items that pointed to it lead to the Blog.
+    const reached = (r) => r.action !== 'skip' || r.postsPage;
+    const targetOf = new Map(plan.items.filter(r => (r.kind === 'page' || r.kind === 'post' || r.kind === 'product' || r.kind === 'custom') && !r.listFor && r.wpId && addressOf(r) && reached(r)).map(r => [r.wpId, addressOf(r)]));
+    const oldPathTarget = new Map(plan.items.filter(r => r.oldPath && addressOf(r) && r.kind !== 'collection' && reached(r)).map(r => [r.oldPath, addressOf(r)]));
     const listPageOf = new Map(plan.items.filter(r => r.listFor && r.action !== 'skip' && r.target).map(r => [r.listFor, r.target]));
     const {oldPathOf, basePathOf} = await import('./plan.js');
     const mediaFor = (url) => {
@@ -674,6 +706,10 @@ async function runPhases(job, {plan, wxr, oldMapping, meta, inviteOrigin, wie},
     }
 
     await checkpoint(true);
+    // ---- 2b. The home page: what is at "/" now moves aside - once, never on a re-run ----
+    const homeOutcome = await runHome({plan, mapping, oldMapping, user, results});
+    if (homeOutcome) await checkpoint(true);
+
     // ---- 3. Pages (and posts as pages) ----
     job.phase = 'Pages';
     const users = await listUsers().catch(() => []);
@@ -682,16 +718,40 @@ async function runPhases(job, {plan, wxr, oldMapping, meta, inviteOrigin, wie},
     // Pages, posts as pages, and custom items as pages; a type's list page is made with its collection.
     const docRows = plan.items.filter(r => !r.listFor && (r.kind === 'page' || (r.kind === 'post' && !blogMode) || (r.kind === 'custom' && r.as === 'pages')));
     for (const r of docRows) {
+        if (!works(r) && r.moveFrom && homeOutcome?.error) { set(r.key, {result: 'failed', error: homeOutcome.error}); continue; }
         if (!works(r)) {
-            if (r.action === 'keep') { mapping.items[r.key] = oldMapping.items[r.key]; recordQuery(mapping, r); }
+            if (r.movedAside) {
+                // The home page until now, moved aside by runHome (which followed it in the mapping) - or still at "/" if that failed.
+                set(r.key, {result: 'kept', target: mapping.items[r.key]?.path || r.target});
+                continue;
+            }
+            if (r.action === 'keep') {
+                // Moved to "/" by this run (the home page), its edits here left as they are.
+                mapping.items[r.key] = r.moveFrom && homeOutcome?.moved ? {...oldMapping.items[r.key], path: r.target} : oldMapping.items[r.key];
+                recordQuery(mapping, r);
+            }
+            if (r.postsPage) { mapping.query.page_id[r.wpId] = r.target; mapping.query.p[r.wpId] = r.target; }
             set(r.key, {result: r.action === 'keep' ? 'kept' : 'skipped', target: r.target});
             continue;
         }
         const it = byId.get(r.wpId);
         try {
-            const conv = convert(it);
-            const fm = pageFrontmatter(it, r, plan, wxr);
-            if (creditOf(it)) fm.createdBy = creditOf(it);
+            // The home page could not be made room for: nothing is put at "/" over the page there.
+            if ((r.front || r.homeLatest) && r.target === '/' && homeOutcome?.error) throw new Error(homeOutcome.error);
+            if (r.moveFrom && !homeOutcome?.moved) throw new Error('It could not be moved to the home page.');
+            let conv;
+            let fm;
+            if (r.homeLatest) {
+                // No front page in WordPress: its home page showed the latest posts - the Blog's own list does here.
+                conv = {body: `[blog-list count="10" /]\n`, notes: [], format: ''};
+                fm = {title: clip(titleText(plan.site.title), 200) || 'Home', description: '', status: 'published', sortOrder: 1,
+                    importedFrom: {source: 'wordpress', home: 'latest-posts', url: clip(plan.site.url, 500)}};
+            } else {
+                conv = convert(it);
+                if (r.postsIndex) conv = {...conv, body: postsIndexBody(conv.body, plan, byId)};
+                fm = pageFrontmatter(it, r, plan, wxr);
+            }
+            if (it && creditOf(it)) fm.createdBy = creditOf(it);
             const exists = await getPage(r.target).catch(() => null);
             if (exists && (r.action === 'update')) await updatePage(r.target, fm, conv.body, {author: user?.email || 'WordPress import'});
             else if (exists) throw new Error(`${r.target} was taken while the import ran.`);
@@ -705,6 +765,16 @@ async function runPhases(job, {plan, wxr, oldMapping, meta, inviteOrigin, wie},
         await step(r.title);
     }
 
+    // The new home page was not made: the one moved aside for it goes back.
+    if (homeOutcome?.moved && homeOutcome.previous && results.get(homeOutcome.key)?.result === 'failed') {
+        await putHomeBack(homeOutcome, mapping, user?.email || 'WordPress import');
+        if (homeOutcome.restored) {
+            (results.get(homeOutcome.key).notes ||= []).push('The home page from before was put back at /.');
+            // A page of this import's that was moved aside for it is back at "/" too.
+            for (const r of plan.items) if (r.movedAside && results.get(r.key)) results.set(r.key, {...results.get(r.key), target: mapping.items[r.key]?.path || '/'});
+        }
+    }
+
     await checkpoint(true);
     // ---- 4. Blog posts and comments ----
     let commentsMade = 0;
@@ -1043,7 +1113,7 @@ async function runPhases(job, {plan, wxr, oldMapping, meta, inviteOrigin, wie},
     job.phase = 'Finishing';
     await saveMapping(plan.source, mapping);
     forgetMapCache();
-    const report = buildReport({job, plan, results, redirectResults, meta, user, started, commentsMade, people});
+    const report = buildReport({job, plan, results, redirectResults, meta, user, started, commentsMade, people, homeOutcome});
     await addHistory(report.run, report);
     await discardStaged(job.staged);
     job.reportId = report.run.id;
@@ -1053,6 +1123,110 @@ async function runPhases(job, {plan, wxr, oldMapping, meta, inviteOrigin, wie},
     log.info?.(`[wordpress-import] ${plan.site.title || plan.source}: ${JSON.stringify(report.run.summary)}`);
 }
 
+// ---- The home page ---------------------------------------------------------------
+
+/**
+ * Make room at "/" for the page this run makes the home page - the first time
+ * only: the mapping's `home` says an earlier run did it, and then nothing here
+ * moves again. The page at "/" now goes to the plan's /previous-home (the next
+ * free -2, -3… if that was taken meanwhile), as a draft: never deleted, never
+ * overwritten. No redirect is added for it and menus keep pointing at "/" -
+ * "/" is still the home page, with the new page on it. A WordPress front page
+ * an earlier run imported at another address moves to "/" itself.
+ *
+ * @returns {Promise<{moved: boolean, previous: string, title: string, error?: string}|null>} null when nothing was claimed
+ */
+async function runHome({plan, mapping, oldMapping, user, results}) {
+    const claim = plan.items.find(r => (r.front || r.homeLatest) && r.target === '/' && r.action !== 'skip');
+    // Set by an earlier run of this import: moved again only when the person said Yes to the question.
+    if (!claim || (oldMapping.items?.home?.kind === 'home' && plan.home?.question?.answer !== true)) return null;
+    // The record of the home page before (put back if this one cannot be made).
+    const out = {moved: false, previous: '', title: '', status: '', from: claim.moveFrom || '', key: claim.key, priorHome: oldMapping.items?.home || null};
+    const author = user?.email || 'WordPress import';
+    try {
+        const move = plan.home?.move;
+        // A page put at "/" since the preview is never taken over: preview again.
+        if (!move && !claim.moveFrom && claim.action === 'create' && await getPage('/').catch(() => null)) throw new Error('a page was put at / since the preview - preview the import again.');
+        if (move) {
+            const now = await getPage('/').catch(() => null);
+            if (now) {
+                let to = move.to;
+                for (let n = 2; await getPage(to).catch(() => null); n++) to = `${move.to}-${n}`;
+                await renamePage('/', to, {redirect: false, source: 'wordpress-import'});
+                out.previous = to;
+                out.title = String(now.title || '');
+                out.status = String(now.status || 'published');
+                await followRename('/', to);
+                followInMapping(mapping, '/', to);
+                await updatePage(to, {status: 'draft', slug: to.split('/').pop()}, undefined, {author});
+            }
+        }
+        if (claim.moveFrom) {
+            // Never onto a page: whatever is at "/" must have moved first.
+            if (await getPage('/').catch(() => null)) throw new Error('There is still a page at / - it was not moved.');
+            await renamePage(claim.moveFrom, '/', {redirect: false, source: 'wordpress-import'});
+            await followRename(claim.moveFrom, '/');
+            followInMapping(mapping, claim.moveFrom, '/');
+            await relinkMenus(claim.moveFrom, '/').catch(() => {});
+            // Left as it is (edited here), it may be a draft - an earlier home page change moved it aside as one.
+            // Chosen as the home page, it is published: a draft at "/" would leave the site without one.
+            if (claim.action === 'keep' && (await getPage('/').catch(() => null))?.status === 'draft') {
+                await updatePage('/', {status: 'published'}, undefined, {author});
+            }
+        }
+        out.moved = true;
+        mapping.items.home = {kind: 'home', how: claim.homeLatest ? 'latest' : 'page', wpId: claim.wpId || 0, previous: out.previous, at: new Date().toISOString()};
+    } catch (err) {
+        out.error = `The home page was not changed: ${err.message || err}`;
+        results.set(claim.key, {result: 'failed', error: out.error});
+        await putHomeBack(out, mapping, author);
+    }
+    return out;
+}
+
+/**
+ * The new home page could not be put at "/": the page that was there goes back, as it was (published
+ * again if it was), and nothing records the home page as set - so the site is never left without one,
+ * and the next run tries again.
+ */
+async function putHomeBack(out, mapping, author) {
+    if (!out?.previous) return;
+    try {
+        if (await getPage('/').catch(() => null)) return;
+        await renamePage(out.previous, '/', {redirect: false, source: 'wordpress-import'});
+        await followRename(out.previous, '/');
+        followInMapping(mapping, out.previous, '/');
+        await updatePage('/', {status: out.status || 'published', slug: 'index'}, undefined, {author});
+        if (out.priorHome) mapping.items.home = out.priorHome;
+        else delete mapping.items.home;
+        out.restored = true;
+        out.moved = false;
+        out.previous = '';
+    } catch { /* it stays a draft where it is - the report says where */ }
+}
+
+/** The mapping this run holds, following a page it moved (store.followRename does the file; this, the copy in hand). */
+function followInMapping(mapping, from, to) {
+    // Entries are replaced, not changed: they are shared with the earlier mapping the run compares against.
+    for (const [k, it] of Object.entries(mapping.items || {})) if (it?.path === from) mapping.items[k] = {...it, path: to};
+    for (const list of Object.values(mapping.query || {})) {
+        for (const [id, t] of Object.entries(list || {})) if (t === from) list[id] = to;
+    }
+}
+
+/** WordPress's posts page, when posts become pages: its text, then a list of them, newest first. */
+export function postsIndexBody(intro, plan, byId) {
+    const esc = (s) => String(s).replace(/\[/g, '&#91;').replace(/\]/g, '&#93;');
+    const rows = plan.items.filter(r => r.kind === 'post' && r.target && r.action !== 'skip' && r.status === 'published')
+        .map(r => ({r, it: byId.get(r.wpId)}))
+        .sort((a, b) => String(b.it?.date || '').localeCompare(String(a.it?.date || '')));
+    const lines = rows.map(({r, it}) => {
+        const day = String(it?.date || '').slice(0, 10);
+        return `- [${esc(clip(titleText(it?.title || r.title), 200) || 'Untitled')}](${r.target})${/^\d{4}-\d{2}-\d{2}$/.test(day) ? ` - ${day}` : ''}`;
+    });
+    return [String(intro || '').trim(), lines.join('\n') || '_No posts yet._'].filter(Boolean).join('\n\n') + '\n';
+}
+
 // ---- People ------------------------------------------------------------------
 
 /** Between two "set your password" emails - a big export must not burst the mail server. Tests shorten it. */
@@ -1348,7 +1522,7 @@ async function importComments(it, postEntryId, mapping, oldMapping, user) {
     return made;
 }
 
-function buildReport({job, plan, results, redirectResults, meta, user, started, commentsMade, people}) {
+function buildReport({job, plan, results, redirectResults, meta, user, started, commentsMade, people, homeOutcome}) {
     const items = plan.items.map(r => {
         const res = results.get(r.key) || {result: r.action === 'skip' ? 'skipped' : r.action === 'keep' ? 'kept' : 'skipped'};
         return {
@@ -1408,7 +1582,14 @@ function buildReport({job, plan, results, redirectResults, meta, user, started,
         durationMs: Date.now() - started,
         summary
     };
-    return {run, options: plan.options, items, people: peopleRows, redirects: redirectResults, notes: [...peopleNotes, ...plan.notes, ...(plan.summary.products?.notes || []), ...commentErrors.slice(0, 50)], blogBase: plan.blogBase, shopBase: plan.shopBase};
+    const homeNotes = [];
+    if (homeOutcome?.error) homeNotes.push(homeOutcome.error);
+    if (plan.home?.changed) homeNotes.push(plan.home.changed);
+    const home = plan.home ? {
+        how: plan.home.how, page: plan.home.page, latest: plan.home.latest, postsPage: plan.home.postsPage,
+        previous: homeOutcome?.previous || '', previousTitle: clip(homeOutcome?.title, 120), moved: Boolean(homeOutcome?.moved), error: homeOutcome?.error || '', changed: plan.home.changed || ''
+    } : null;
+    return {run, options: plan.options, home, items, people: peopleRows, redirects: redirectResults, notes: [...homeNotes, ...peopleNotes, ...plan.notes, ...(plan.summary.products?.notes || []), ...commentErrors.slice(0, 50)], blogBase: plan.blogBase, shopBase: plan.shopBase};
 }
 
 // ---- The request hook: WordPress's query addresses ------------------------
@@ -1430,7 +1611,8 @@ async function wordpressQueryRedirects(fastify) {
     } catch { /* nothing to recover */ }
     // The redirects below belong to the migrated site, not to the Tool: they answer
     // whether or not the importer is switched on. Cheap: only "/" or "/index.php" with a query is looked at.
-    const onRenamed = ({from, to} = {}) => { followRename(from, to).catch(() => {}); };
+    // A move the import makes itself (the home page) it follows itself, in step with its own mapping.
+    const onRenamed = ({from, to, source} = {}) => { if (source !== 'wordpress-import') followRename(from, to).catch(() => {}); };
     coreHooks.on?.('content:pageRenamed', onRenamed);
     fastify.addHook('onClose', (_i, done) => { coreHooks.off?.('content:pageRenamed', onRenamed); done(); });
     fastify.addHook('onRequest', async (request, reply) => {