domma-cms 1.8.34 → 1.8.36

package/server/routes/api/collections.js

@@ -703,6 +703,8 @@ export async function collectionsRoutes(fastify) {
      *                  client-side hydration (e.g. "My Applications").
      */
     async function publicListEntries(request, reply) {
+        // Allowed in robots.txt so Google can render pages that read it; the JSON itself is never a search result.
+        reply.header('x-robots-tag', 'noindex');
         const schema = await getCollection(request.params.slug);
         if (!schema) return reply.status(404).send({ error: 'Collection not found' });
 

package/server/routes/api/effects.js

@@ -92,7 +92,11 @@ export async function effectsRoutes(fastify, opts = {}) {
     const authenticate = opts.authenticate || defaultAuthenticate;
     const requireAdmin = opts.requireAdmin || defaultRequireAdmin;
 
-    fastify.get('/effects/settings', async () => loadSettings());
+    // Allowed in robots.txt so Google can render pages that read it; the JSON itself is never a search result.
+    fastify.get('/effects/settings', async (request, reply) => {
+        reply.header('x-robots-tag', 'noindex');
+        return loadSettings();
+    });
 
     fastify.get('/effects/_count', {preHandler: [authenticate]}, async () => {
         const {effectsByCategory} = await import('../../../admin/js/lib/effect-defs.js');

package/server/routes/api/forms.js

@@ -505,6 +505,8 @@ export async function formsRoutes(fastify) {
     // GET /forms/:slug/public - get form for public rendering (no actions)
     // -----------------------------------------------------------------------
     fastify.get('/forms/:slug/public', async (request, reply) => {
+        // Allowed in robots.txt so Google can render pages that read it; the JSON itself is never a search result.
+        reply.header('x-robots-tag', 'noindex');
         try {
             const form = await readForm(request.params.slug);
             const { actions: _actions, ...safe } = form;

package/server/routes/api/views.js

@@ -192,6 +192,8 @@ export async function viewsRoutes(fastify) {
     // -------------------------------------------------------------------------
 
     fastify.get('/views/:slug/public', async (request, reply) => {
+        // Allowed in robots.txt so Google can render pages that read it; the JSON itself is never a search result.
+        reply.header('x-robots-tag', 'noindex');
         let view;
         try {
             view = await getView(request.params.slug);

package/server/routes/public.js

@@ -10,7 +10,8 @@ import {getPage, getPageMtime} from '../services/content.js';
 import {getProjectForPage, isProjectEnabled} from '../services/projects.js';
 import {footerBlockCacheTags, renderPage} from '../services/renderer.js';
 import {resolvePublishedPage} from '../services/pagePublishing.js';
-import {buildRobotsTxt, generate as generateSitemap} from '../services/sitemap.js';
+import {buildLlmsTxt, buildRobotsTxt, generate as generateSitemap, llmsTxtAllowed} from '../services/sitemap.js';
+import {seoEngine} from '../services/seo/index.js';
 import {resolveViewer} from '../services/viewerSession.js';
 import {validSessionCookie, newSessionCookie} from '../services/shortcodeExpiry.js';
 import {touchPreviewLink, verifyPreviewToken} from '../services/previewLinks.js';
@@ -44,6 +45,22 @@ export function getBaseUrl(request) {
 import {sendHtml} from '../services/htmlResponse.js';
 export {sendHtml};
 
+/**
+ * Escape user-controlled strings before interpolating into HTML.
+ * Prevents reflected XSS in the built-in 403 and 404 pages.
+ *
+ * @param {string} str
+ * @returns {string}
+ */
+function escapeHtml(str) {
+    return String(str)
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+
 export async function publicRoutes(fastify) {
     // Admin panel: serve index.html for all /admin/* paths (SPA fallback)
     fastify.get('/admin', async (request, reply) => {
@@ -67,6 +84,24 @@ export async function publicRoutes(fastify) {
         return reply.type('application/xml').send(xml);
     });
 
+    // SEO: llms.txt (llmstxt.org) - the sitemap's pages as a Markdown list for
+    // AI assistants. Cached and invalidated with the sitemap and site settings. Off when the SEO
+    // settings switch it off or ask every crawler to stay away; with SEO
+    // switched off there are no settings, and like the sitemap it is served.
+    fastify.get('/llms.txt', async (request, reply) => {
+        if (!llmsTxtAllowed(seoEngine()?.settings?.() || null)) {
+            return reply.status(404).type('text/plain; charset=utf-8').send('Not found\n');
+        }
+        const baseUrl = getBaseUrl(request);
+        const txt = await cache.wrap(
+            `llms:txt:${baseUrl}`,
+            () => buildLlmsTxt(baseUrl, {log: fastify.log}),
+            // `site` too: the header is the site's title and description.
+            {tags: ['sitemap', 'site'], ttlSeconds: 600}
+        );
+        return reply.type('text/plain; charset=utf-8').send(txt);
+    });
+
     // SEO: robots.txt - cheap to build, no cache wrap needed.
     fastify.get('/robots.txt', async (request, reply) => {
         return reply.type('text/plain').send(buildRobotsTxt(getBaseUrl(request)));

package/server/server.js

@@ -705,6 +705,7 @@ registerSidebarItem({folder: 'Usage', item: {source: 'Built in', text: 'Collecti
 registerSidebarItem({folder: 'Usage', item: {source: 'Built in', text: 'Blocks', url: '#/docs/usage/blocks', icon: 'box'}});
 registerSidebarItem({folder: 'Usage', item: {source: 'Built in', text: 'Built-in Tools', url: '#/docs/usage/tools', icon: 'tool'}});
 registerSidebarItem({folder: 'Usage', item: {source: 'Built in', text: 'Dashboard', url: '#/docs/usage/dashboard', icon: 'home'}});
+registerSidebarItem({folder: 'Usage', item: {source: 'Built in', text: 'Search Engines & AI', url: '#/docs/usage/search-engines', icon: 'search'}});
 registerSidebarItem({folder: 'Usage', item: {source: 'Built in', text: 'Editions & Licences', url: '#/docs/usage/editions', icon: 'key'}});
 registerSidebarItem({folder: 'API Reference', item: {source: 'Built in', text: 'Forms', url: '#/docs/api/forms', icon: 'layout'}});
 registerSidebarItem({folder: 'API Reference', item: {source: 'Built in', text: 'Scaffold', url: '#/docs/api/scaffold', icon: 'package'}});

package/server/services/docs.js

@@ -62,6 +62,7 @@ const MAP = [
     ['usage-blocks',         'usage/blocks',         'Blocks'],
     ['usage-tools',          'usage/tools',          'Built-in Tools'],
     ['usage-dashboard',      'usage/dashboard',      'Dashboard'],
+    ['usage-search-engines', 'usage/search-engines', 'Search Engines & AI'],
     ['tutorial-crud',        'tutorials/crud',       'Building a CRUD App'],
     ['tutorial-editor',      'tutorials/editor',     'The Editor'],
     ['tutorial-plugin',      'tutorials/plugin',     'Writing a Tool'],

package/server/services/hooks.js

@@ -465,8 +465,9 @@ export async function sendDirectMessage({fromUserId, toUserId, text} = {}) {
 //
 // Core lists its own pages. Anything a plugin serves (blog posts, job listings)
 // is invisible to it, so the plugin registers a source. `list({baseUrl})`
-// resolves to `[{urlPath, title?, lastmod?, changefreq?, priority?, image?}]`,
-// public items only - the sitemap is for anonymous visitors. A source that
+// resolves to `[{urlPath, title?, lastmod?, changefreq?, priority?, image?, description?}]`,
+// public items only - the sitemap is for anonymous visitors. The same list feeds
+// /llms.txt, where `description` follows each link. A source that
 // throws is skipped (and logged) rather than taking the sitemap down.
 //
 // Transforms beside it (registerTransform):

package/server/services/markdown.js

@@ -989,6 +989,138 @@ function renderCollectionListgroup(entries, opts, ctxOpts = {}) {
     return `${styleTag}<div class="${wrapperClasses.join(' ')}"${ctx}>\n${items}\n</div>`;
 }
 
+/**
+ * Draw a saved view's rows in the shortcode's display (table, cards, list,
+ * accordion, timeline, carousel, listgroup or block). Shared by the static
+ * `[view]` render and the no-JS fallback inside the interactive `[view]`
+ * shell, so a robot that runs no JavaScript reads the same rows the browser
+ * shows. The caller has already checked `canReadView` and run the pipeline.
+ *
+ * @param {string} slug
+ * @param {Record<string, string>} attrs
+ * @param {object} viewConfig
+ * @param {Array<{id: string, data: object}>} entries
+ * @returns {Promise<string>}
+ */
+async function renderViewEntries(slug, attrs, viewConfig, entries) {
+    const displayAttr = attrs.display || '';
+    const emptyMsg   = attrs.empty      || 'No results found';
+    const titleField = attrs['title-field'] || '';
+    const columns    = attrs.columns    || '3';
+    const fieldFilter = attrs.fields ? attrs.fields.split(',').map(f => f.trim()).filter(Boolean) : null;
+
+    const ctaOpts = attrs.action ? {
+        action: attrs.action,
+        label: attrs['cta-label'] || 'Run',
+        style: attrs['cta-style'] || 'primary',
+        icon: attrs['cta-icon'] || '',
+        confirm: attrs['cta-confirm'] || ''
+    } : null;
+
+    let replacement = `<div class="dm-collection-display dm-collection-empty"><p>${escapeHtmlText(emptyMsg)}</p></div>`;
+
+    // Resolve the view's underlying collection schema to compute export
+    // permission. Views don't own a schema themselves - [dis]allowing
+    // export must fall back CLOSED if the source collection can't be
+    // resolved, since an open fallback would be a permission bypass.
+    const sourceSlug = viewConfig.pipeline?.source || '';
+    const sourceSchema = sourceSlug ? await getCollection(sourceSlug) : null;
+    const ctxOpts = sourceSchema
+        ? {
+            slug: sourceSlug,
+            export: resolveExportConfig(sourceSchema.export, attrs, getRoleHierarchy().at(-1)),
+            itemClass: attrs['item-class']
+        }
+        : {slug: sourceSlug || undefined, export: {allowed: false, access: null, formats: []}, itemClass: attrs['item-class']};
+
+    // Derive visible fields from attr filter or first entry's data keys
+    let fields;
+    if (fieldFilter?.length) {
+        fields = fieldFilter.map(name => ({ name, label: name }));
+    } else if (entries.length) {
+        fields = Object.keys(entries[0].data || {})
+            .filter(k => !['_id', 'id', 'meta'].includes(k))
+            .map(k => ({name: k, label: k}));
+    } else {
+        fields = [];
+    }
+
+    const display = displayAttr || viewConfig?.display?.mode || 'table';
+
+    if (display === 'cards') {
+        replacement = renderCollectionCards(entries, fields, titleField, columns, emptyMsg, ctaOpts, ctxOpts);
+    } else if (display === 'list') {
+        replacement = renderCollectionList(entries, fields, titleField, emptyMsg, ctaOpts, ctxOpts);
+    } else if (display === 'accordion') {
+        const accordionTitleField = attrs['title-field'] || 'title';
+        const bodyField           = attrs['body-field']  || 'description';
+        const multiple            = attrs.multiple === 'true';
+        replacement = renderCollectionAccordion(entries, accordionTitleField, bodyField, multiple, emptyMsg, ctxOpts);
+    } else if (display === 'timeline') {
+        const timelineLayout = ['vertical', 'centred', 'horizontal'].includes(attrs.layout) ? attrs.layout : 'vertical';
+        const timelineTheme  = ['minimal', 'corporate', 'modern'].includes(attrs.theme)   ? attrs.theme  : 'minimal';
+        const timelineMode   = ['timeline', 'roadmap'].includes(attrs.mode)                ? attrs.mode   : 'timeline';
+        replacement = renderCollectionTimeline(entries, {
+            titleField:  attrs['title-field']  || 'title',
+            dateField:   attrs['date-field']   || '',
+            statusField: attrs['status-field'] || '',
+            iconField:   attrs['icon-field']   || '',
+            bodyField:   attrs['body-field']   || '',
+            layout: timelineLayout,
+            theme:  timelineTheme,
+            mode:   timelineMode,
+            emptyMsg,
+        }, ctxOpts);
+    } else if (display === 'carousel') {
+        const {tpl, css, missing} = await loadOptionalBlockAssets(attrs.block);
+        replacement = missing
+            ? blockNotFoundHtml(attrs.block)
+            : renderCollectionCarousel(entries, {
+                imageField: attrs['image-field'] || '',
+                titleField: attrs['title-field'] || 'title',
+                bodyField:  attrs['body-field']  || '',
+                blockTemplate: tpl,
+                blockName: attrs.block || '',
+                blockCss: css,
+                dataAttrs: attrs,
+                emptyMsg,
+            }, ctxOpts);
+    } else if (display === 'listgroup') {
+        const {tpl, css, missing} = await loadOptionalBlockAssets(attrs.block);
+        replacement = missing
+            ? blockNotFoundHtml(attrs.block)
+            : renderCollectionListgroup(entries, {
+                titleField: attrs['title-field'] || 'title',
+                bodyField:  attrs['body-field']  || '',
+                variant:     attrs.variant || '',
+                size:        attrs.size || '',
+                itemVariant: attrs.itemvariant || '',
+                action:      attrs.action === 'true',
+                blockTemplate: tpl,
+                blockName: attrs.block || '',
+                blockCss: css,
+                emptyMsg,
+            }, ctxOpts);
+    } else if (display === 'block') {
+        const blockName = attrs.block || viewConfig?.display?.block || '';
+        if (blockName) {
+            try {
+                const [tpl, css] = await Promise.all([
+                    loadBlockTemplate(blockName),
+                    loadBlockCss(blockName),
+                ]);
+                replacement = renderCollectionBlocks(entries, tpl, emptyMsg, ctaOpts, '', blockName, css, ctxOpts);
+            } catch {
+                replacement = blockNotFoundHtml(blockName);
+            }
+        }
+    } else {
+        replacement = renderCollectionTable(`view:${slug}`, entries, fields, attrs, ctaOpts, ctxOpts);
+    }
+
+    return replacement;
+}
+
 /**
  * Process [view slug="..." display="table|cards|list" /] shortcodes.
  * Executes the View's aggregation pipeline and renders results using the
@@ -1042,20 +1174,8 @@ async function processViewBlocks(markdown, tagSet, user = null, flags = {}) {
             continue;
         }
 
-        const displayAttr = attrs.display || '';
-        const emptyMsg   = attrs.empty      || 'No results found';
-        const titleField = attrs['title-field'] || '';
-        const columns    = attrs.columns    || '3';
-        const limitAttr  = parseInt(attrs.limit, 10) || 25;
-        const fieldFilter = attrs.fields ? attrs.fields.split(',').map(f => f.trim()).filter(Boolean) : null;
-
-        const ctaOpts = attrs.action ? {
-            action: attrs.action,
-            label: attrs['cta-label'] || 'Run',
-            style: attrs['cta-style'] || 'primary',
-            icon: attrs['cta-icon'] || '',
-            confirm: attrs['cta-confirm'] || ''
-        } : null;
+        const emptyMsg  = attrs.empty || 'No results found';
+        const limitAttr = parseInt(attrs.limit, 10) || 25;
 
         let replacement = `<div class="dm-collection-display dm-collection-empty"><p>${escapeHtmlText(emptyMsg)}</p></div>`;
 
@@ -1072,105 +1192,7 @@ async function processViewBlocks(markdown, tagSet, user = null, flags = {}) {
 
             // Map MongoDB docs to { id, data } shape. MongoAdapter docs have a top-level id field.
             const entries = results.map(doc => ({id: doc.id || '', data: doc.data || doc}));
-
-            // Resolve the view's underlying collection schema to compute export
-            // permission. Views don't own a schema themselves - [dis]allowing
-            // export must fall back CLOSED if the source collection can't be
-            // resolved, since an open fallback would be a permission bypass.
-            const sourceSlug = viewConfig.pipeline?.source || '';
-            const sourceSchema = sourceSlug ? await getCollection(sourceSlug) : null;
-            const ctxOpts = sourceSchema
-                ? {
-                    slug: sourceSlug,
-                    export: resolveExportConfig(sourceSchema.export, attrs, getRoleHierarchy().at(-1)),
-                    itemClass: attrs['item-class']
-                }
-                : {slug: sourceSlug || undefined, export: {allowed: false, access: null, formats: []}, itemClass: attrs['item-class']};
-
-            // Derive visible fields from attr filter or first entry's data keys
-            let fields;
-            if (fieldFilter?.length) {
-                fields = fieldFilter.map(name => ({ name, label: name }));
-            } else if (entries.length) {
-                fields = Object.keys(entries[0].data || {})
-                    .filter(k => !['_id', 'id', 'meta'].includes(k))
-                    .map(k => ({name: k, label: k}));
-            } else {
-                fields = [];
-            }
-
-            const display = displayAttr || viewConfig?.display?.mode || 'table';
-
-            if (display === 'cards') {
-                replacement = renderCollectionCards(entries, fields, titleField, columns, emptyMsg, ctaOpts, ctxOpts);
-            } else if (display === 'list') {
-                replacement = renderCollectionList(entries, fields, titleField, emptyMsg, ctaOpts, ctxOpts);
-            } else if (display === 'accordion') {
-                const accordionTitleField = attrs['title-field'] || 'title';
-                const bodyField           = attrs['body-field']  || 'description';
-                const multiple            = attrs.multiple === 'true';
-                replacement = renderCollectionAccordion(entries, accordionTitleField, bodyField, multiple, emptyMsg, ctxOpts);
-            } else if (display === 'timeline') {
-                const timelineLayout = ['vertical', 'centred', 'horizontal'].includes(attrs.layout) ? attrs.layout : 'vertical';
-                const timelineTheme  = ['minimal', 'corporate', 'modern'].includes(attrs.theme)   ? attrs.theme  : 'minimal';
-                const timelineMode   = ['timeline', 'roadmap'].includes(attrs.mode)                ? attrs.mode   : 'timeline';
-                replacement = renderCollectionTimeline(entries, {
-                    titleField:  attrs['title-field']  || 'title',
-                    dateField:   attrs['date-field']   || '',
-                    statusField: attrs['status-field'] || '',
-                    iconField:   attrs['icon-field']   || '',
-                    bodyField:   attrs['body-field']   || '',
-                    layout: timelineLayout,
-                    theme:  timelineTheme,
-                    mode:   timelineMode,
-                    emptyMsg,
-                }, ctxOpts);
-            } else if (display === 'carousel') {
-                const {tpl, css, missing} = await loadOptionalBlockAssets(attrs.block);
-                replacement = missing
-                    ? blockNotFoundHtml(attrs.block)
-                    : renderCollectionCarousel(entries, {
-                        imageField: attrs['image-field'] || '',
-                        titleField: attrs['title-field'] || 'title',
-                        bodyField:  attrs['body-field']  || '',
-                        blockTemplate: tpl,
-                        blockName: attrs.block || '',
-                        blockCss: css,
-                        dataAttrs: attrs,
-                        emptyMsg,
-                    }, ctxOpts);
-            } else if (display === 'listgroup') {
-                const {tpl, css, missing} = await loadOptionalBlockAssets(attrs.block);
-                replacement = missing
-                    ? blockNotFoundHtml(attrs.block)
-                    : renderCollectionListgroup(entries, {
-                        titleField: attrs['title-field'] || 'title',
-                        bodyField:  attrs['body-field']  || '',
-                        variant:     attrs.variant || '',
-                        size:        attrs.size || '',
-                        itemVariant: attrs.itemvariant || '',
-                        action:      attrs.action === 'true',
-                        blockTemplate: tpl,
-                        blockName: attrs.block || '',
-                        blockCss: css,
-                        emptyMsg,
-                    }, ctxOpts);
-            } else if (display === 'block') {
-                const blockName = attrs.block || viewConfig?.display?.block || '';
-                if (blockName) {
-                    try {
-                        const [tpl, css] = await Promise.all([
-                            loadBlockTemplate(blockName),
-                            loadBlockCss(blockName),
-                        ]);
-                        replacement = renderCollectionBlocks(entries, tpl, emptyMsg, ctaOpts, '', blockName, css, ctxOpts);
-                    } catch {
-                        replacement = blockNotFoundHtml(blockName);
-                    }
-                }
-            } else {
-                replacement = renderCollectionTable(`view:${slug}`, entries, fields, attrs, ctaOpts, ctxOpts);
-            }
+            replacement = await renderViewEntries(slug, attrs, viewConfig, entries);
         } catch {
             // View not found or pipeline error - show empty state
         }
@@ -1429,9 +1451,16 @@ async function renderCollectionBrowserShell(attrs, {extraFilter = null, scope =
         syncUrl: !isTruthyAttr(attrs['no-url-sync'])               // default ON
     };
 
-    // No-JS fallback - render the same first-page state with the static renderer.
-    const fallbackAttrs = {...attrs, limit: String(pageSize)};
-    const fallback      = await renderCollectionFragment(fallbackAttrs, {extraFilter, scope});
+    // No-JS fallback, drawn by the static renderer in the browser's display
+    // from the entries already fetched for the payload (no second query).
+    // Client mode ships every entry in data-cb-data, so the fallback lists
+    // them too, up to the author's `limit` and FALLBACK_MAX - a robot that
+    // runs no JavaScript reads the collection, not just page one, and a huge
+    // one does not double the page. Server mode ships one page: that page.
+    const fallback = await renderCollectionFragment({...attrs, display: config.display}, {
+        extraFilter, scope,
+        entries: entries.slice(0, fallbackLimit(attrs, entries.length))
+    });
 
     // Encode payloads. Schema can be modest; data can be large in client mode,
     // so we base64 once each and let the browser decode.
@@ -1541,6 +1570,19 @@ async function renderViewBrowserShell(attrs, {viewConfig = null, allowed = false
         sourceKind: 'view'       // hint for client-side: server-mode would need a different fetch endpoint
     };
 
+    // No-JS fallback: the rows the browser was handed (all of them in client
+    // mode, the first page in server mode), drawn by the static [view]
+    // renderer. A refused viewer has no rows and gets the empty state.
+    let fallback = '';
+    try {
+        fallback = viewConfig && allowed
+            ? await renderViewEntries(slug, {...attrs, display: config.display},
+                viewConfig, entries.slice(0, fallbackLimit(attrs, entries.length)))
+            : `<div class="dm-collection-display dm-collection-empty"><p>${escapeHtmlText(config.emptyMsg)}</p></div>`;
+    } catch {
+        // A fallback that cannot be drawn must not take the browser with it.
+    }
+
     const enc = (obj) => Buffer.from(JSON.stringify(obj), 'utf8').toString('base64');
     const wrapperCls = attrs.class ? ` ${escapeAttr(attrs.class)}` : '';
     const wrapperId  = attrs.id ? ` id="${escapeAttr(attrs.id)}"` : ` id="${escapeAttr(config.id)}"`;
@@ -1549,10 +1591,27 @@ async function renderViewBrowserShell(attrs, {viewConfig = null, allowed = false
         `data-cb-config="${enc(config)}" ` +
         `data-cb-schema="${enc({fields: schemaFields, title: viewConfig?.title || slug})}" ` +
         `data-cb-data="${enc({entries, total, page: 1, pageSize})}">` +
-        `<div class="dm-cb-fallback"></div>` +
+        `<div class="dm-cb-fallback">${fallback}</div>` +
         `</div>`;
 }
 
+/**
+ * How many entries an interactive browser's no-JS fallback draws: the
+ * author's `limit` when set, never more than the browser itself holds, and
+ * never more than FALLBACK_MAX.
+ *
+ * @param {Record<string, string>} attrs
+ * @param {number} held - entries the browser ships (all of them in client mode, one page in server mode)
+ * @returns {number}
+ */
+function fallbackLimit(attrs, held) {
+    const limit = parseInt(attrs.limit, 10);
+    return Math.min(limit > 0 ? limit : held, held, FALLBACK_MAX);
+}
+
+/** The most entries a browser's no-JS fallback draws; the rest stay in the payload for the browser. */
+export const FALLBACK_MAX = 200;
+
 /**
  * Render a `[collection]` block's HTML fragment from parsed attributes.
  *
@@ -1574,9 +1633,10 @@ async function renderViewBrowserShell(attrs, {viewConfig = null, allowed = false
  * @param {object}                 [opts]
  * @param {Record<string, unknown>} [opts.extraFilter]  - Additional filter conditions to AND in
  * @param {string}                 [opts.scope]        - 'mine': CTA buttons carry data-scope
+ * @param {Array<object>}          [opts.entries]      - Entries already fetched (a browser shell's), drawn instead of querying
  * @returns {Promise<string>} HTML fragment ready to inject into a page
  */
-export async function renderCollectionFragment(attrs, { extraFilter = null, scope = '' } = {}) {
+export async function renderCollectionFragment(attrs, { extraFilter = null, scope = '', entries: given = null } = {}) {
     const slug = attrs.slug || '';
     if (!slug) return '';
 
@@ -1625,7 +1685,8 @@ export async function renderCollectionFragment(attrs, { extraFilter = null, scop
         };
         if (Object.keys(filter).length) listOpts.filter = filter;
 
-        const {entries} = await listEntries(slug, listOpts);
+        // A browser shell hands over the entries it already fetched (refs resolved).
+        const {entries} = Array.isArray(given) ? {entries: given} : await listEntries(slug, listOpts);
 
         let fields = schema.fields || [];
         if (fieldFilter?.length) {
@@ -4191,6 +4252,25 @@ async function expandReferenceFields(form) {
     }
 }
 
+/**
+ * What a form is for, as text inside its embed: the title and description,
+ * visually hidden (the drawn form does not show them either), so a robot that
+ * runs no JavaScript still reads what the form is. site.js removes it when it
+ * draws the form. Values are inert: a form's text is not a shortcode.
+ *
+ * @param {{title?: string, description?: string}} form
+ * @returns {string} '' when the form has neither
+ */
+export function formSummaryHtml(form) {
+    const title = String(form?.title ?? '').trim();
+    const description = String(form?.description ?? '').trim();
+    if (!title && !description) return '';
+    return inertShortcodes(`<div class="sr-only cms-form-embed-summary">`
+        + (title ? `<p><strong>${escapeHtmlText(title)}</strong></p>` : '')
+        + (description ? `<p>${escapeHtmlText(description)}</p>` : '')
+        + `</div>`);
+}
+
 async function processFormBlocks(markdown, tagSet) {
   const {scrubbed, restore} = scrubCodeRegions(markdown);
   const regex = /\[form([^\]]*?)\/\]/gi;
@@ -4230,7 +4310,7 @@ async function processFormBlocks(markdown, tagSet) {
       const encoded = Buffer.from(JSON.stringify(publicForm)).toString('base64');
         const extraClass = attrs.class ? ` ${escapeAttr(attrs.class)}` : '';
         const idAttr = attrs.id ? ` id="${escapeAttr(attrs.id)}"` : '';
-        replacement = `<div class="cms-form-embed${extraClass}" data-form-inline="${escapeAttr(encoded)}"${idAttr}></div>`;
+        replacement = `<div class="cms-form-embed${extraClass}" data-form-inline="${escapeAttr(encoded)}"${idAttr}>${formSummaryHtml(form)}</div>`;
     } catch {
         const extraClass = attrs.class ? ` ${escapeAttr(attrs.class)}` : '';
         const idAttr = attrs.id ? ` id="${escapeAttr(attrs.id)}"` : '';

package/server/services/nojsLinks.js

@@ -0,0 +1,130 @@
+/**
+ * No-JS navbar and footer
+ *
+ * The public navbar and footer are drawn in the browser by site.js from
+ * window.__CMS_NAV__ / __CMS_FOOTER__ / __CMS_SITE__. A robot that runs no
+ * JavaScript (GPTBot, ClaudeBot) saw an empty <nav> and <footer>, so the
+ * renderer also writes the same links as plain HTML inside them, built from
+ * the SAME per-viewer data it serialises (visibility already filtered).
+ *
+ * The block is visually hidden (Domma's `.sr-only` - clipped, not
+ * display:none, so it is still in the document), so it can neither flash nor
+ * shift the layout before site.js runs; site.js removes it (`.cms-nojs-links`)
+ * once it has drawn the real navbar and footer.
+ *
+ * Pure: no I/O, so both render paths in renderer.js call it the same way.
+ */
+
+/** Structural menu items carry no text or link (see the domma-menus skill). */
+const STRUCTURAL = new Set(['separator', 'spacer', 'theme-switcher']);
+
+/** The social networks site.js draws in the footer, in its order, with its labels. */
+const SOCIAL = [
+    ['twitter', 'X / Twitter'],
+    ['facebook', 'Facebook'],
+    ['instagram', 'Instagram'],
+    ['linkedin', 'LinkedIn'],
+    ['github', 'GitHub'],
+    ['youtube', 'YouTube']
+];
+
+/** Text for an element body or a double-quoted attribute. */
+function esc(v) {
+    return String(v ?? '')
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+
+/**
+ * A link target worth writing: a non-empty string that is not a script or
+ * data address (the browser's sanitiser would drop those on the drawn
+ * navbar, so the fallback does not carry them either).
+ *
+ * @param {unknown} url
+ * @returns {string} the trimmed url, '' when it is not one
+ */
+export function safeHref(url) {
+    const u = typeof url === 'string' ? url.trim() : '';
+    if (!u || u === '#') return '';
+    // Control characters and spaces inside a scheme are ignored by browsers.
+    const scheme = u.replace(/[\u0000- ]/g, '').toLowerCase();
+    if (/^(javascript|vbscript|data):/.test(scheme)) return '';
+    return u;
+}
+
+/**
+ * Menu items as nested <ul> lists. Structural and hidden items are skipped,
+ * and so is an item with no usable url - unless it has children with links,
+ * when its label stays as plain text above them (a dropdown heading).
+ *
+ * @param {Array<object>} items
+ * @returns {string} '' when nothing is left to list
+ */
+export function linkList(items) {
+    const lis = (Array.isArray(items) ? items : []).map((it) => {
+        if (!it || typeof it !== 'object' || it.hidden || STRUCTURAL.has(it.type)) return '';
+        const kids = linkList(it.items);
+        const href = safeHref(it.url);
+        const text = String(it.text ?? '').trim() || (href ? href : '');
+        if (!href && !kids) return '';
+        const label = href ? `<a href="${esc(href)}">${esc(text)}</a>` : (text ? `<span>${esc(text)}</span>` : '');
+        return `<li>${label}${kids}</li>`;
+    }).filter(Boolean);
+    return lis.length ? `<ul>${lis.join('')}</ul>` : '';
+}
+
+/**
+ * The navbar's links as plain HTML, for inside <nav id="site-navbar">.
+ *
+ * @param {{brand?: object, items?: Array<object>}} navigation - the object __CMS_NAV__ carries
+ * @param {{title?: string}} [site]
+ * @returns {string} '' when there is nothing to link
+ */
+export function buildNavFallback(navigation = {}, site = {}) {
+    const brand = navigation?.brand || {};
+    const brandText = String(brand.text || site?.title || '').trim();
+    const brandHref = safeHref(brand.url) || '/';
+    const list = linkList(navigation?.items);
+    if (!brandText && !list) return '';
+    const home = brandText ? `<a href="${esc(brandHref)}">${esc(brandText)}</a>` : '';
+    return `<div class="sr-only cms-nojs-links cms-nojs-nav">${home}${list}</div>`;
+}
+
+/**
+ * The footer's text and links as plain HTML, for inside <footer id="site-footer">:
+ * the blurb (when the footer is drawn in columns, where site.js shows it), the
+ * footer and legal menus, the social links and the copyright line.
+ *
+ * @param {{primary?: Array<object>, legal?: Array<object>, copyright?: string}} footer - __CMS_FOOTER__
+ * @param {{footer?: object, social?: object}} [site]
+ * @returns {string} '' when there is nothing to say
+ */
+export function buildFooterFallback(footer = {}, site = {}) {
+    const primary = Array.isArray(footer?.primary) ? footer.primary : [];
+    const layout = site?.footer?.layout;
+    // The same choice site.js makes: columns when asked for, or (auto) when the footer menu has groups.
+    const columns = layout === 'columns'
+        || (!['columns', 'row'].includes(layout) && primary.some(it => Array.isArray(it?.items) && it.items.length));
+    const blurb = columns ? String(site?.footer?.blurb || '').trim() : '';
+    const primaryList = linkList(primary);
+    const legalList = linkList(footer?.legal);
+    // site.js draws the social links only when the site has footer settings at all.
+    const social = site?.footer && site?.social ? SOCIAL
+        .map(([key, label]) => [safeHref(site.social[key]), label])
+        .filter(([href]) => href)
+        .map(([href, label]) => `<li><a href="${esc(href)}" rel="noopener noreferrer">${esc(label)}</a></li>`)
+        : [];
+    const copyright = String(footer?.copyright || '').trim();
+
+    const parts = [
+        blurb ? `<p>${esc(blurb)}</p>` : '',
+        primaryList ? `<nav aria-label="Footer">${primaryList}</nav>` : '',
+        legalList ? `<nav aria-label="Legal">${legalList}</nav>` : '',
+        social.length ? `<ul>${social.join('')}</ul>` : '',
+        copyright ? `<p>${esc(copyright)}</p>` : ''
+    ].filter(Boolean);
+    return parts.length ? `<div class="sr-only cms-nojs-links cms-nojs-footer">${parts.join('')}</div>` : '';
+}