domma-cms 1.8.9 → 1.8.11

package/server/services/content.js

@@ -282,9 +282,13 @@ export async function setPageFrontmatter(urlPath, patch) {
  *
  * @param {string} oldUrlPath
  * @param {string} newUrlPath
+ * @param {object} [opts]
+ * @param {boolean} [opts.redirect=true] - false: the old address is not to lead to the new one (the home
+ *   page moved aside - "/" stays the home page), so the SEO Tool adds no redirect and re-aims none
+ * @param {string} [opts.source] - who moved it, passed on to listeners
  * @returns {Promise<void>}
  */
-export async function renamePage(oldUrlPath, newUrlPath) {
+export async function renamePage(oldUrlPath, newUrlPath, {redirect = true, source = ''} = {}) {
     const oldFile = await resolveExistingFilePath(oldUrlPath);
     const newFile = urlPathToFilePath(newUrlPath);
     await fs.mkdir(path.dirname(newFile), { recursive: true });
@@ -296,7 +300,7 @@ export async function renamePage(oldUrlPath, newUrlPath) {
         // Version directory move failure is non-fatal
     }
     // The old URL may be linked from anywhere - the SEO plugin offers a redirect.
-    hooks.emit('content:pageRenamed', {from: oldUrlPath, to: newUrlPath});
+    hooks.emit('content:pageRenamed', {from: oldUrlPath, to: newUrlPath, ...(redirect === false && {redirect: false}), ...(source && {source})});
 }
 
 /**

package/server/services/docs.js

@@ -25,6 +25,7 @@ import {parseMarkdown} from './markdown.js';
 import {footerBlockCacheTags, renderPage} from './renderer.js';
 import {getConfig} from '../config.js';
 import * as cache from './cache/index.js';
+import {viewerRoleKey} from './userRoles.js';
 
 // import.meta.url-relative (NOT cwd-relative): the templates live beside the
 // engine's admin dir in both the npm-package layout and each child site's
@@ -321,8 +322,11 @@ async function buildDocBody(docPath) {
 
 /**
  * Render a Domma Docs page to full HTML, or return null for an unknown path
- * (the route turns that into a 404). Cached per path+origin under the static
- * 'docs' tag - invalidated on boot so a version bump never serves stale HTML.
+ * (the route turns that into a 404). Cached per path + viewer role set + origin
+ * under the 'docs' tag. Nothing flushes that tag; a version bump never serves
+ * stale HTML only because the in-memory cache starts empty on every restart.
+ * The role set is in the key because the shell's menus and footer blocks
+ * filter by role, exactly as a normal page's do.
  *
  * @param {string} docPath  url tail after /domma-docs (e.g. 'usage/pages', '' for home)
  * @param {{user?: object|null, baseUrl?: string}} [opts]
@@ -335,7 +339,7 @@ export async function renderDocPage(docPath, opts = {}) {
 
     const {user = null, baseUrl} = opts;
     return cache.wrap(
-        `docs:${path}:o${baseUrl || ''}`,
+        `docs:${path}:role${viewerRoleKey(user)}:o${baseUrl || ''}`,
         async () => {
             const parsed = await parseMarkdown(built.body, {user});
             const css = [DOCS_BODY_CSS, ...built.styles].filter(Boolean).join('\n\n');

package/server/services/seo/index.js

@@ -129,8 +129,9 @@ 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;
+    const onRenamed = ({from, to, redirect} = {}) => {
+        // 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.`);

package/server/services/userRoles.js

@@ -39,6 +39,21 @@ export function getEffectiveRoles(user) {
     return out;
 }
 
+/**
+ * The viewer's role set as it appears in a response-cache key: every role the
+ * user holds (primary plus additional), sorted and joined with `+`, or `anon`
+ * for no viewer. Every cached render whose output depends on the viewer (menu
+ * visibility, role-gated shortcodes) keys on this, so two viewers share an
+ * entry exactly when they hold the same roles - never per user.
+ *
+ * @param {object|null} user
+ * @returns {string} e.g. 'anon', 'admin', 'blog-editor+user'
+ */
+export function viewerRoleKey(user) {
+    const roles = getEffectiveRoles(user);
+    return roles.length ? [...roles].sort().join('+') : 'anon';
+}
+
 /**
  * Return the effective role level for a user - the LOWEST level number
  * across all roles. Lower number = higher privilege, so the user's most

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,12 @@
  * 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 (mapping `home`). 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 +66,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 +234,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 +295,16 @@ 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: once per site, not once per export.
+    let homeSetBy = null;
+    try {
+        for (const [key, src] of Object.entries((await readMap()).sources || {})) {
+            if (key !== source && src?.items?.home?.kind === 'home') { homeSetBy = {...src.items.home, source: key}; break; }
+        }
+    } 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 +421,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 +449,12 @@ 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
     };
 }
 
@@ -616,8 +635,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 +695,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 +707,35 @@ 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.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 +749,12 @@ 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 /.');
+    }
+
     await checkpoint(true);
     // ---- 4. Blog posts and comments ----
     let commentsMade = 0;
@@ -1043,7 +1093,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 +1103,102 @@ 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');
+    if (!claim || oldMapping.items?.home?.kind === 'home') return null;
+    const out = {moved: false, previous: '', title: '', status: '', from: claim.moveFrom || '', key: claim.key};
+    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(() => {});
+        }
+        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});
+        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 +1494,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 +1554,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 +1583,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) => {