domma-cms 0.92.1 → 0.94.0

package/server/services/adapterRegistry.js

@@ -4,18 +4,31 @@
  * Resolves the correct storage adapter for a collection slug.
  *
  * Resolution order:
- *  1. Preset collections (e.g. roles) → always FileAdapter
- *  2. schema.json `storage.adapter` field:
- *     - "mongodb" → MongoAdapter (Phase 2+)
+ *  1. System presets (roles, user profiles, projects, ...) → always FileAdapter
+ *  2. User-data presets (Notes, Todo, Contacts) → MongoDB only when declared,
+ *     the connection works, and the files hold none of its rows; else files
+ *     (resolveUserDataPreset below)
+ *  3. schema.json `storage.adapter` field:
+ *     - "mongodb" → MongoAdapter
  *     - "file" or absent → FileAdapter
  *
  * Adapters are cached per slug.  Call `invalidate(slug)` after a schema update.
  */
 import fileAdapter from './adapters/FileAdapter.js';
-import {PRESET_COLLECTION_SLUGS} from './presetCollections.js';
+import {PRESET_COLLECTION_SLUGS, USER_DATA_PRESET_SLUGS} from './presetCollections.js';
+
+/** People's own data (Notes, Todo, Contacts): MongoDB when the site can have it. */
+const USER_DATA_SLUGS = new Set(USER_DATA_PRESET_SLUGS);
 
 /** Collections that must always use file-based storage (system presets). */
-const PRESET_SLUGS = new Set(['roles', 'user-profiles', ...PRESET_COLLECTION_SLUGS]);
+const PRESET_SLUGS = new Set(['roles', 'user-profiles', ...PRESET_COLLECTION_SLUGS.filter(s => !USER_DATA_SLUGS.has(s))]);
+
+/**
+ * User-data presets left on files because both stores hold rows, or the files
+ * hold rows the declared MongoDB does not: slug -> {declared, used, fileRows, mongoRows, reason}.
+ * Read by getStorageConflicts(); logged once per resolution.
+ */
+const conflicts = new Map();
 
 /** Adapter instance cache, keyed by slug. */
 const cache = new Map();
@@ -30,12 +43,23 @@ export async function getAdapter(slug) {
     if (PRESET_SLUGS.has(slug)) return fileAdapter;
     if (cache.has(slug)) return cache.get(slug);
 
-    // Read schema to check storage config (Phase 2+: may return MongoAdapter)
-    const adapter = await resolveAdapter(slug);
+    const adapter = USER_DATA_SLUGS.has(slug) ? await resolveUserDataPreset(slug) : await resolveAdapter(slug);
     cache.set(slug, adapter);
     return adapter;
 }
 
+/**
+ * Whether a collection's storage is fixed to files whatever its schema says
+ * (the system presets). A storage move is refused for these. The user-data
+ * presets are not fixed: a move is how a site settles rows left in both stores.
+ *
+ * @param {string} slug
+ * @returns {boolean}
+ */
+export function isFixedToFile(slug) {
+    return PRESET_SLUGS.has(slug);
+}
+
 /**
  * Invalidate the cached adapter for a slug.
  * Call this after updating a collection's schema (e.g. changing storage config).
@@ -44,18 +68,75 @@ export async function getAdapter(slug) {
  */
 export function invalidate(slug) {
     cache.delete(slug);
+    conflicts.delete(slug);
+}
+
+/**
+ * The user-data presets kept on files although they declare MongoDB (or the
+ * other way round), with row counts - for a status screen or a log reader.
+ *
+ * @returns {Record<string, {declared: string, used: string, fileRows: number, mongoRows: number, reason: string}>}
+ */
+export function getStorageConflicts() {
+    return Object.fromEntries(conflicts);
+}
+
+/**
+ * Where an adapter keeps its entries, as a storage block - `{adapter: 'file'}`
+ * or `{adapter: 'mongodb', connection}`. Describes the adapter actually in use,
+ * which is not always what schema.json declares (a failed connection falls
+ * back to files).
+ *
+ * @param {object} adapter
+ * @returns {{adapter: string, connection?: string}}
+ */
+export function describeAdapter(adapter) {
+    if (adapter === fileAdapter || adapter?.constructor?.name === 'FileAdapter') return {adapter: 'file'};
+    return {adapter: 'mongodb', connection: adapter?.connection || 'default'};
+}
+
+/**
+ * The adapter for a storage block, with NO fallback: a MongoDB connection that
+ * is not configured or not connected throws. For moving entries between
+ * stores, where "fell back to files" would copy them into the very place they
+ * came from.
+ *
+ * @param {{adapter?: string, connection?: string}} storage
+ * @returns {Promise<object>}
+ * @throws {Error} If the MongoDB connection is not available
+ */
+export async function adapterForStorage(storage) {
+    if ((storage?.adapter || 'file') !== 'mongodb') return fileAdapter;
+    const connection = storage.connection || 'default';
+    const {getDb} = await import('./connectionManager.js');
+    let db;
+    try {
+        db = getDb(connection);
+    } catch {
+        throw new Error(`MongoDB connection "${connection}" is not available - check Settings > Connections`);
+    }
+    return mongoAdapterFor(db, connection);
 }
 
 // ---------------------------------------------------------------------------
 // Internal
 // ---------------------------------------------------------------------------
 
+/** One MongoAdapter per Db, so its ensured-index memo is shared across slugs. */
+const mongoAdapters = new WeakMap();
+
+async function mongoAdapterFor(db, connection) {
+    if (mongoAdapters.has(db)) return mongoAdapters.get(db);
+    const {MongoAdapter} = await import('./adapters/MongoAdapter.js');
+    const adapter = new MongoAdapter(db);
+    adapter.connection = connection;
+    mongoAdapters.set(db, adapter);
+    return adapter;
+}
+
 /**
  * Determine which adapter to use based on schema storage config.
  *
- * Phase 1: always returns FileAdapter.
- * Phase 2+: conditionally returns MongoAdapter.
- *
  * @param {string} slug
  * @returns {Promise<object>}
  */
@@ -76,6 +157,83 @@ async function resolveAdapter(slug) {
     return fileAdapter;
 }
 
+/** Is a named connection in config/connections.json at all? (A free site has none.) */
+async function isConfigured(connection) {
+    try {
+        const {getConfig} = await import('../config.js');
+        return Boolean(getConfig('connections')?.[connection]);
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * The store for a user-data preset (Notes, Todo, Contacts).
+ *
+ * MongoDB is a Pro feature, so the preset's MongoDB declaration is honoured
+ * only where the site has a working connection - a free site, with no
+ * connection, keeps its files without a word. And no site may switch to an
+ * empty store under its users: where the files already hold rows, the
+ * collection stays on files, even if MongoDB is empty; where both hold rows,
+ * it stays on files and the clash is logged with the counts, for someone to
+ * move one set across (the Storage move keeps ids). Only files with no rows
+ * give way to MongoDB. A declared-file preset stays on files, and MongoDB rows
+ * it cannot see are logged the same way.
+ *
+ * @param {string} slug
+ * @returns {Promise<object>}
+ */
+async function resolveUserDataPreset(slug) {
+    let schema = null;
+    try {
+        const {getCollection} = await import('./collections.js');
+        schema = await getCollection(slug);
+    } catch { /* unreadable schema - files */ }
+
+    const declared = schema?.storage?.adapter === 'mongodb' ? 'mongodb' : 'file';
+    const connection = schema?.storage?.connection || 'default';
+
+    let mongo = null;
+    try {
+        mongo = await adapterForStorage({adapter: 'mongodb', connection});
+    } catch (err) {
+        // Declared, configured and down: say so, as for any collection. Not
+        // configured at all is a free site, and files are simply its store.
+        if (declared === 'mongodb' && await isConfigured(connection)) {
+            console.warn(`[adapterRegistry] "${slug}" declares MongoDB but connection "${connection}" is down: using files. ${err.message}`);
+            import('./notification-sources.js').then(m => m.storageDown(connection, err.message)).catch(() => {});
+        }
+        return fileAdapter;
+    }
+
+    let fileRows, mongoRows;
+    try {
+        fileRows = await fileAdapter.count(slug);
+        // Counted straight off the Db: the adapter's count() would create
+        // cms_<slug> and its index, a write, on a site that may stay on files.
+        const {getDb} = await import('./connectionManager.js');
+        mongoRows = await getDb(connection).collection(`cms_${slug}`).countDocuments({});
+    } catch (err) {
+        if (declared === 'mongodb') console.warn(`[adapterRegistry] "${slug}" declares MongoDB but it could not be read (${err.message}): using files.`);
+        return fileAdapter;
+    }
+
+    const report = (reason) => {
+        conflicts.set(slug, {declared, used: 'file', connection, fileRows, mongoRows, reason});
+        console.warn(`[adapterRegistry] "${slug}" stays on files: ${reason} (files: ${fileRows} rows, MongoDB "${connection}": ${mongoRows} rows). Move one set with the collection's Storage move to settle it.`);
+    };
+
+    if (declared === 'file') {
+        if (mongoRows > 0) report('it declares file storage but MongoDB also holds rows');
+        return fileAdapter;
+    }
+    if (fileRows > 0) {
+        report(mongoRows > 0 ? 'both stores hold rows' : 'it declares MongoDB, which is empty, but its rows are in files');
+        return fileAdapter;
+    }
+    return mongo;
+}
+
 /**
  * Resolve a MongoAdapter for a collection schema.
  * Loaded dynamically so the mongodb package is never required in the free version.
@@ -85,12 +243,7 @@ async function resolveAdapter(slug) {
  */
 async function resolveMongoAdapter(schema) {
     try {
-        const connectionName = schema.storage?.connection || 'default';
-        const { getDb } = await import('./connectionManager.js');
-        const db = getDb(connectionName);
-
-        const { MongoAdapter } = await import('./adapters/MongoAdapter.js');
-        return new MongoAdapter(db);
+        return await adapterForStorage(schema.storage);
     } catch (err) {
         console.warn(`[adapterRegistry] Failed to load MongoAdapter for "${schema.slug}": ${err.message}. Falling back to FileAdapter.`);
         import('./notification-sources.js').then(m => m.storageDown(schema.storage?.connection || 'default', err.message)).catch(() => {});

package/server/services/adapters/FileAdapter.js

@@ -16,6 +16,7 @@
  *   insertMany(slug, entries) → { imported, skipped, errors }
  *   count(slug)               → number
  *   replaceAll(slug, entries) → void   (file only - one write for a whole-collection rewrite)
+ *   archive(slug)             → string|null (set the entries aside after a storage move)
  */
 import fs from 'fs/promises';
 import path from 'path';
@@ -220,6 +221,30 @@ export class FileAdapter {
     async replaceAll(slug, entries) {
         await write(slug, entries);
     }
+
+    /**
+     * Set the entries aside after they were moved to another store: data.json
+     * is renamed to data.json.bak (or a timestamped .bak when one is already
+     * there), so nothing is deleted and the collection reads empty here.
+     *
+     * @param {string} slug
+     * @returns {Promise<string|null>} The backup's file name, or null if there was no data.json
+     */
+    async archive(slug) {
+        const from = dataPath(slug);
+        let to = `${from}.bak`;
+        try {
+            await fs.access(to);
+            to = `${from}.${new Date().toISOString().replace(/[:.]/g, '-')}.bak`;
+        } catch { /* no earlier backup - the plain name is free */ }
+        try {
+            await fs.rename(from, to);
+            return path.basename(to);
+        } catch (err) {
+            if (err.code === 'ENOENT') return null;
+            throw err;
+        }
+    }
 }
 
 export default new FileAdapter();

package/server/services/adapters/MongoAdapter.js

@@ -17,6 +17,7 @@
  *   all(slug)                 → entry[]
  *   insertMany(slug, entries) → { imported, skipped, errors }
  *   count(slug)               → number
+ *   archive(slug)             → string|null (set the entries aside after a storage move)
  */
 import { toMongoQuery } from '../filterEngine.js';
 
@@ -219,6 +220,28 @@ export class MongoAdapter {
         this._ensured.delete(slug);
     }
 
+    /**
+     * Set the entries aside after they were moved to another store: the
+     * backing `cms_<slug>` collection is renamed to
+     * `cms_<slug>__moved_<timestamp>`, so nothing is deleted, the slug reads
+     * empty here, and a later move back into MongoDB does not collide with
+     * the old copies.
+     *
+     * @param {string} slug
+     * @returns {Promise<string|null>} The archive's collection name, or null if there was nothing to archive
+     */
+    async archive(slug) {
+        const to = `${PREFIX}${slug}__moved_${new Date().toISOString().replace(/[:.]/g, '-')}`;
+        try {
+            await this._db.collection(`${PREFIX}${slug}`).rename(to);
+        } catch (err) {
+            if (err.codeName === 'NamespaceNotFound') return null;
+            throw err;
+        }
+        this._ensured.delete(slug);
+        return to;
+    }
+
     /**
      * Return all entries (used for export).
      *

package/server/services/collections.js

@@ -10,7 +10,7 @@ import fs from 'fs/promises';
 import path from 'path';
 import {v4 as uuidv4} from 'uuid';
 import {config} from '../config.js';
-import {getAdapter, invalidate} from './adapterRegistry.js';
+import {adapterForStorage, describeAdapter, getAdapter, invalidate, isFixedToFile} from './adapterRegistry.js';
 import * as cache from './cache/index.js';
 import {typedEntryData} from './entryValues.js';
 import {toCsv} from '../../public/js/collection-export.mjs';
@@ -481,6 +481,101 @@ export async function clearEntries(slug) {
     return result;
 }
 
+// ---------------------------------------------------------------------------
+// Storage migration
+// ---------------------------------------------------------------------------
+
+/** An error carrying the HTTP status the route should answer with. */
+function statusError(statusCode, message, extra = {}) {
+    return Object.assign(new Error(message), {statusCode}, extra);
+}
+
+/**
+ * Move every entry of a collection to another store (file <-> MongoDB, or
+ * between MongoDB connections) and point the schema at it.
+ *
+ * Entries are copied VERBATIM - the same id, data and meta (createdAt,
+ * updatedAt, createdBy, source, ...) - so references, links and row
+ * ownership keep working. It is a move, not a re-entry: nothing is
+ * re-validated, because an entry that no longer passes validation must not
+ * be the one that is lost.
+ *
+ * Refuses (and changes nothing) when the target already holds an entry with
+ * one of the ids being moved, or when the source holds the same id twice.
+ * The old copy is set aside with the adapter's archive() - data.json becomes
+ * data.json.bak, a Mongo collection is renamed - never deleted.
+ *
+ * @param {string} slug
+ * @param {{adapter: string, connection?: string}} storage - the target
+ * @returns {Promise<{migrated: number, total: number, archived: string|null}>}
+ * @throws {Error} with `statusCode` 400/404/409/503
+ */
+export async function migrateStorage(slug, storage) {
+    if (!storage?.adapter) throw statusError(400, 'storage.adapter is required');
+    if (!['file', 'mongodb'].includes(storage.adapter)) throw statusError(400, `Unknown storage adapter "${storage.adapter}"`);
+    const target = storage.adapter === 'mongodb'
+        ? {adapter: 'mongodb', connection: storage.connection || 'default'}
+        : {adapter: 'file'};
+
+    const schema = await getCollection(slug);
+    if (!schema) throw statusError(404, 'Collection not found');
+    if (isFixedToFile(slug)) throw statusError(400, `"${slug}" is a system collection and always uses file storage`);
+
+    // The source is the store in use, which is not always the declared one
+    // (a MongoDB connection that failed falls back to files).
+    const sourceAdapter = await getAdapter(slug);
+    const source = describeAdapter(sourceAdapter);
+    if (source.adapter === target.adapter && source.connection === target.connection) {
+        throw statusError(400, 'Source and target storage are the same');
+    }
+
+    let targetAdapter;
+    try {
+        targetAdapter = await adapterForStorage(target);
+    } catch (err) {
+        throw statusError(503, err.message);
+    }
+
+    const entries = await sourceAdapter.all(slug);
+    for (const entry of entries) {
+        if (!entry.id) entry.id = uuidv4();   // a hand-written row with no id - give it one now
+    }
+
+    const seen = new Set();
+    const repeated = new Set();
+    for (const {id} of entries) (seen.has(id) ? repeated : seen).add(id);
+    if (repeated.size) {
+        throw statusError(409, `The current storage holds ${repeated.size} id${repeated.size === 1 ? '' : 's'} more than once (${[...repeated].slice(0, 5).join(', ')}) - fix those entries before moving`, {collisions: [...repeated]});
+    }
+
+    const existing = await targetAdapter.all(slug);
+    const clashes  = existing.map(e => e.id).filter(id => seen.has(id));
+    if (clashes.length) {
+        throw statusError(409, `The target storage already holds ${clashes.length} of these entries (same id${clashes.length === 1 ? '' : 's'}: ${clashes.slice(0, 5).join(', ')}${clashes.length > 5 ? ', ...' : ''}) - probably left from an earlier move. Nothing was moved; clear or remove them there first.`, {collisions: clashes});
+    }
+
+    if (entries.length) {
+        try {
+            await targetAdapter.insertMany(slug, entries);
+        } catch (err) {
+            // Take back whatever did land, so a retry is not refused as a collision.
+            for (const {id} of entries) await targetAdapter.remove(slug, id).catch(() => {});
+            throw statusError(500, `Moving the entries failed, nothing was changed: ${err.message}`);
+        }
+    }
+
+    await updateCollection(slug, {...schema, storage: target});
+
+    let archived = null;
+    try {
+        archived = await sourceAdapter.archive?.(slug) ?? null;
+    } catch (err) {
+        console.warn(`[collections] migrateStorage("${slug}"): entries moved but the old copy was not set aside: ${err.message}`);
+    }
+
+    return {migrated: entries.length, total: entries.length, archived};
+}
+
 // ---------------------------------------------------------------------------
 // Import / Export
 // ---------------------------------------------------------------------------
@@ -542,6 +637,14 @@ export async function importEntries(slug, incoming, { createdBy = null } = {}) {
             errors.push(valErrors.join('; '));
             continue;
         }
+        // The same reference check as createEntry/updateEntry - an import must
+        // not be the one way to store a reference to an entry that is not there.
+        const refErrors = await validateReferences(schema, data);
+        if (refErrors.length) {
+            skipped++;
+            errors.push(refErrors.join('; '));
+            continue;
+        }
         valid.push({
             id:   uuidv4(),
             data,

package/server/services/connectionManager.js

@@ -101,3 +101,15 @@ export async function shutdown() {
     await Promise.allSettled(closePromises);
     clients.clear();
 }
+
+/**
+ * Tests only: register (or, with `db` null, remove) a named connection without
+ * a real MongoClient, so adapter resolution can run against an in-memory Db.
+ *
+ * @param {string} name
+ * @param {object|null} db
+ */
+export function _setDb(name, db) {
+    if (db) clients.set(name, {client: {close: async () => {}}, db});
+    else clients.delete(name);
+}

package/server/services/dates.js

@@ -0,0 +1,81 @@
+/**
+ * Dates as the server writes them for a person - emails, notifications,
+ * sidebar badge popovers, rendered pages: dd/mm/yyyy, and dd/mm/yyyy HH:mm
+ * where a time matters. The admin's twin is admin/js/lib/dates.js.
+ *
+ * Display only. Stored values, API payloads, sitemap/RSS/iCal/JSON-LD,
+ * HTTP headers, filenames, logs and sort keys stay ISO.
+ *
+ * Times are the server's local time unless `{utc: true}` is passed - then
+ * the caller says "UTC" beside it.
+ */
+
+const pad = (n) => String(n).padStart(2, '0');
+
+/** A bare calendar day. Parsed as a LOCAL day: `new Date('2026-09-21')` is UTC midnight. */
+const DAY_ONLY = /^(\d{4})-(\d{2})-(\d{2})$/;
+
+/**
+ * A Date from whatever the API sent - ISO string, bare 'YYYY-MM-DD', epoch ms
+ * or a Date. Null for empty or unparseable input.
+ *
+ * @param   {string|number|Date|null|undefined} value
+ * @returns {Date|null}
+ */
+export function toDate(value) {
+    if (value == null || value === '') return null;
+    if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value;
+    if (typeof value === 'string') {
+        const m = DAY_ONLY.exec(value.trim());
+        if (m) return new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]));
+    }
+    const d = new Date(value);
+    return Number.isNaN(d.getTime()) ? null : d;
+}
+
+const isDayOnly = (value) => typeof value === 'string' && DAY_ONLY.test(value.trim());
+
+/** Empty for nothing; the raw text for something that is not a date, so it is never silently lost. */
+const unparsed = (value) => (value == null ? '' : String(value));
+
+/**
+ * 'dd/mm/yyyy'.
+ *
+ * @param   {string|number|Date|null|undefined} value
+ * @param   {{utc?: boolean}} [opts]
+ * @returns {string}
+ */
+export function fmtDate(value, {utc = false} = {}) {
+    const d = toDate(value);
+    if (!d) return unparsed(value);
+    if (utc && !isDayOnly(value)) return `${pad(d.getUTCDate())}/${pad(d.getUTCMonth() + 1)}/${d.getUTCFullYear()}`;
+    return `${pad(d.getDate())}/${pad(d.getMonth() + 1)}/${d.getFullYear()}`;
+}
+
+/**
+ * 'HH:mm' (24-hour).
+ *
+ * @param   {string|number|Date|null|undefined} value
+ * @param   {{utc?: boolean}} [opts]
+ * @returns {string}
+ */
+export function fmtTime(value, {utc = false} = {}) {
+    const d = toDate(value);
+    if (!d) return unparsed(value);
+    if (utc) return `${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}`;
+    return `${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
+/**
+ * 'dd/mm/yyyy HH:mm'. A bare 'YYYY-MM-DD' has no time to show, so it gets the date alone.
+ *
+ * @param   {string|number|Date|null|undefined} value
+ * @param   {{utc?: boolean}} [opts]
+ * @returns {string}
+ */
+export function fmtDateTime(value, {utc = false} = {}) {
+    if (isDayOnly(value)) return fmtDate(value);
+    const d = toDate(value);
+    if (!d) return unparsed(value);
+    return `${fmtDate(d, {utc})} ${fmtTime(d, {utc})}`;
+}

package/server/services/docs.js

@@ -55,6 +55,9 @@ const MAP = [
     ['usage-views',          'usage/views',          'Views'],
     ['usage-actions',        'usage/actions',        'Actions'],
     ['usage-cta-shortcode',  'usage/cta-shortcode',  'CTA Shortcode'],
+    ['usage-editions',       'usage/editions',       'Editions & Licences'],
+    ['usage-collections',    'usage/collections',    'Collections & Forms'],
+    ['usage-tools',          'usage/tools',          'Built-in Tools'],
     ['tutorial-crud',        'tutorials/crud',       'Building a CRUD App'],
     ['tutorial-plugin',      'tutorials/plugin',     'Writing a Plugin'],
     ['tutorial-forms',       'tutorials/forms',      'Form Follow-Up'],
@@ -72,7 +75,11 @@ const MAP = [
     ['api-plugins',          'api/plugins',          'Plugins API'],
     ['api-collections',      'api/collections',      'Collections API'],
     ['api-views',            'api/views',            'Views API'],
-    ['api-actions',          'api/actions',          'Actions API']
+    ['api-actions',          'api/actions',          'Actions API'],
+    ['api-forms',            'api/forms',            'Forms API'],
+    ['api-scaffold',         'api/scaffold',         'Scaffold API'],
+    ['api-external',         'api/external',         'External API & Tokens'],
+    ['api-builder',          'api/builder',          'API Builder']
 ];
 
 // Admin-SPA hash routes and stale /resources/… paths don't resolve on the
@@ -134,6 +141,10 @@ function rewriteLinks(html) {
     for (const [from, to] of Object.entries(LINK_MAP)) {
         out = out.split(`href="${from}"`).join(`href="${to}"`);
     }
+    // Usage and API pages share their tail with the public handbook; plugin guides
+    // are admin-only (they depend on what is installed), so they open the admin.
+    out = out.replace(/href="#\/docs\/(usage|api)\/([a-z0-9-]+)"/g, 'href="/domma-docs/$1/$2"');
+    out = out.replace(/href="#\/docs\/plugins([^"]*)"/g, 'href="/admin#/docs/plugins$1"');
     // Any remaining /resources/… link has no doc equivalent - unwrap to text.
     out = out.replace(/<a\b[^>]*\shref="\/resources\/[^"]*"[^>]*>([\s\S]*?)<\/a>/gi, '$1');
     return out;
@@ -347,7 +358,7 @@ export async function renderDocPage(docPath, opts = {}) {
 }
 
 /**
- * Every valid doc path (home + 29 leaves + 3 section landings). The Components
+ * Every valid doc path (home + every leaf + 3 section landings). The Components
  * landing is the 'components' leaf, already in MAP. `renderDocPage` returning
  * null is the authoritative miss; this is an enumeration aid (e.g. sitemap).
  *