@materializecms/server 0.4.0 → 0.6.0

package/src/app.js

@@ -9,11 +9,12 @@ import { getConnInfo } from '@hono/node-server/conninfo';
 import { describeCollection, prepare, SLUG_PATTERN, slugify, titleOf, validate, } from '@materializecms/core';
 import { documentSlots, isLocaleCode, mergeTranslation, nodeSlots, untranslatedIds, withLocales, } from '@materializecms/core/i18n';
 import { senderDomain } from '@materializecms/core/mail';
-import { normalizeTheme, sameDesign } from '@materializecms/core/page';
+import { expandComponents, expandGlobals, formDefinition, normalizeTheme, sameDesign, walk, } from '@materializecms/core/page';
 import { addMove, normalizePath } from '@materializecms/core/seo';
 import { TRACKING_PATTERNS, trackingBlocks } from '@materializecms/core/tracking';
 import { DEFAULT_UPDATES, isPatch, } from '@materializecms/core/updates';
-import { createActivityStore, createAuthStore, createCommentStore, createContentStore, createMediaStore, createSettingsStore, createSubmissionStore, EmailTakenError, SlugTakenError, } from '@materializecms/db';
+import { VOICE_TONES, voicePrompt } from '@materializecms/core/voice';
+import { createActivityStore, createAuthStore, createCommentStore, createContentStore, createMediaStore, createPreviewLinkStore, createReleaseStore, createScheduleStore, createSettingsStore, createSubmissionStore, EmailTakenError, SlugTakenError, } from '@materializecms/db';
 import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
 import { Hono } from 'hono';
 import { bodyLimit } from 'hono/body-limit';
@@ -24,10 +25,12 @@ import { secureHeaders } from 'hono/secure-headers';
 import { streamSSE } from 'hono/streaming';
 import { z } from 'zod';
 import { serveAdmin } from './admin.js';
-import { AiError, complete, EMPTY_AI, isReady, publicAi, runTurn, translateTexts, } from './ai.js';
+import { AiError, complete, EMPTY_AI, isReady, languageName, publicAi, runTurn, translateTexts, } from './ai.js';
 import { folderEntries, tarGz } from './archive.js';
 import { createBackups, DEFAULT_BACKUPS } from './backups.js';
+import { briefSystem, briefTools, plain } from './brief.js';
 import { createFonts, FONT_FILE, FONT_ID } from './fonts.js';
+import { fingerprintOf, readSubmission, removeFiles, saveFiles, sendWebhook, spamReason, } from './forms.js';
 import { checkSenderDomain, explainMailError, isConfigured, publicMail, sendMail, submissionText, } from './mail.js';
 import { createMcpServer } from './mcp.js';
 import { createMediaFiles, fileBody, MAX_UPLOAD, MediaError, mediaUrl } from './media.js';
@@ -35,10 +38,11 @@ import { DEFAULT_OFFSITE, newRecoveryKey, runOffsite, testOffsite, } from './off
 import { hashPassword, verifyPassword } from './password.js';
 import { fetchPublicFile, RemoteError, remoteFetch } from './remote.js';
 import { statusPage } from './status-page.js';
-import { apiCaller, assistantTools } from './tools.js';
+import { studioSystem, studioTools } from './studio.js';
+import { apiCaller, assistantTools, contentTools, pageTools } from './tools.js';
 import { newSecret, otpauthUri, recoveryCodes, verifyCode } from './totp.js';
 import { readRest, readWxr, WordPressError } from './wordpress.js';
-import { fold, optionsOf, runImport, sourcesFor, suggest, } from './wpimport.js';
+import { fold, optionsOf, relayoutProblem, restoreAlts, runImport, sourcesFor, suggest, } from './wpimport.js';
 /** The installed version, from this package's package.json (same place in the sources and in the release). */
 export const VERSION = createRequire(import.meta.url)('../package.json').version;
 const SESSION_COOKIE = 'mz_session';
@@ -61,7 +65,10 @@ const FORGOT_THRESHOLD = 3;
 const FORGOT_IP_THRESHOLD = 10;
 /** Where people open their one-time link: the admin's welcome screen. */
 const linkPath = (token) => `/admin/_invite/${token}`;
-/** The custom code blocks in a document: it runs on the public site, so only admins may change it. */
+/**
+ * The custom code blocks in a document (it runs on the public site) and where its forms send
+ * their messages: only admins may change them.
+ */
 function embedsOf(value, out = []) {
     if (Array.isArray(value))
         for (const v of value)
@@ -70,6 +77,10 @@ function embedsOf(value, out = []) {
         const node = value;
         if (node.type === 'embed' && typeof node.id === 'string')
             out.push(`${node.id}:${String(node.html ?? '')}`);
+        // Where a form's messages go: someone who only edits pages must not divert them.
+        const form = node.form;
+        if (form && typeof node.id === 'string' && (form.to || form.webhook))
+            out.push(`form:${node.id}:${form.to ?? ''}:${form.webhook ?? ''}`);
         for (const v of Object.values(node))
             if (v && typeof v === 'object')
                 embedsOf(v, out);
@@ -132,6 +143,8 @@ const siteSeoSchema = z.object({
     })
         .optional(),
     blockAi: z.boolean().optional(),
+    llms: z.boolean().optional(),
+    feed: z.array(z.string().max(80)).max(50).optional(),
     disallow: z.array(z.string().trim().max(300)).max(100).optional(),
     google: short,
     bing: short,
@@ -179,6 +192,9 @@ export function createApp(base) {
     const submissions = createSubmissionStore(ctx.database.db);
     const comments = createCommentStore(ctx.database.db);
     const activityLog = createActivityStore(ctx.database.db);
+    const schedules = createScheduleStore(ctx.database.db);
+    const releases = createReleaseStore(ctx.database.db);
+    const previewLinks = createPreviewLinkStore(ctx.database.db);
     const backups = createBackups(ctx.database, () => ctx.config().media.dir);
     const backupSettings = async () => ({
         ...DEFAULT_BACKUPS,
@@ -308,12 +324,20 @@ export function createApp(base) {
     const files = createMediaFiles(ctx.config().media.dir);
     // Fonts are cached next to the media library (.materialize/fonts by default).
     const fonts = createFonts(join(dirname(resolve(ctx.config().media.dir)), 'fonts'));
+    // Files sent with the site's forms: next to the database, never served by the public site.
+    const uploadsDir = join(dirname(resolve(ctx.config().media.dir)), 'uploads');
+    let formCache = null;
+    /** The live site changed: rebuild it, and read its forms again. */
+    const sitePublished = () => {
+        formCache = null;
+        ctx.onPublish?.();
+    };
     const app = new Hono();
     const guardEmbeds = (user, before, after) => {
         if (user.role === 'admin')
             return;
         if (JSON.stringify(embedsOf(before).sort()) !== JSON.stringify(embedsOf(after).sort()))
-            throw new ApiError(403, 'embed_admin_only', 'Solo un amministratore può aggiungere o modificare il codice personalizzato');
+            throw new ApiError(403, 'embed_admin_only', 'Solo un amministratore può modificare il codice personalizzato e dove arrivano i messaggi dei moduli');
     };
     /** Editors who may only change contents (Persone → Redattori): words, links and images, not the layout. */
     const contentOnly = async (user) => user.role !== 'admin' && !!(await settings.get('editorial'))?.editorsContentOnly;
@@ -432,13 +456,21 @@ export function createApp(base) {
         return `/${locale}${path === '/' ? '' : path}`;
     };
     /** A document as the admin sees it, with what still needs fixing before it can be published. */
-    const toJson = (doc) => {
+    const toJson = async (doc) => {
         const def = ctx.config().collections.find((x) => x.name === doc.collection);
         const check = def ? validate(def, prepare(def, doc.data)) : null;
         return {
             ...doc,
             url: def?.url ? def.url(doc.data) : null,
             issues: check && !check.ok ? check.issues : [],
+            /** When it goes on or off the site by itself, and the last scheduled action that failed. */
+            schedule: await schedules.forDocument(doc.id),
+            /** The release it goes out with, if any. */
+            release: await releases
+                .forDocument(doc.id)
+                .then((r) => r
+                ? { id: r.id, name: r.name, runAt: r.runAt, action: r.items.find((i) => i.documentId === doc.id)?.action }
+                : null),
         };
     };
     /**
@@ -628,7 +660,7 @@ export function createApp(base) {
             : await content.create({ collection: def.name, locale: lang, ...draft });
         if (doc)
             await content.publish(doc.id);
-        ctx.onPublish?.();
+        sitePublished();
     };
     /** The site's name as set in the panel (the settings singleton, published), else the config's. */
     const siteName = async () => {
@@ -866,7 +898,7 @@ export function createApp(base) {
     const ACTIVITY_GROUPS = {
         access: ['login.', 'logout', 'session.', 'twofactor.', 'token.', 'security.', 'password.'],
         people: ['user.'],
-        content: ['document.', 'media.', 'message.'],
+        content: ['document.', 'release.', 'site.', 'media.', 'message.'],
         settings: ['settings.', 'backup.', 'update.'],
     };
     app.get('/api/activity', requireUser, requireAdmin, async (c) => {
@@ -1102,6 +1134,7 @@ export function createApp(base) {
         const mediaDir = resolve(ctx.config().media.dir);
         entries.push(...(await folderEntries(mediaDir, 'media')));
         entries.push(...(await folderEntries(join(dirname(mediaDir), 'fonts'), 'fonts')));
+        entries.push(...(await folderEntries(uploadsDir, 'uploads')));
         const manifest = join(work, 'materialize.json');
         await writeFile(manifest, JSON.stringify({
             site: ctx.config().site.name,
@@ -1528,7 +1561,7 @@ export function createApp(base) {
         const input = await body(c, z.object({ theme: z.record(z.string(), z.unknown()) }));
         const theme = normalizeTheme(input.theme);
         await settings.set('theme', theme, c.get('user').id);
-        ctx.onPublish?.();
+        sitePublished();
         await record(c, 'settings.theme');
         return c.json({ theme });
     });
@@ -1588,7 +1621,7 @@ export function createApp(base) {
                 .filter(([id]) => main[id])
                 .map(([id, n]) => [id, n]));
             await settings.set(`globals:${lang}`, words, c.get('user').id);
-            ctx.onPublish?.();
+            sitePublished();
             return c.json({ globals: await globalsIn(lang) });
         }
         const before = (await settings.get('globals')) ?? {};
@@ -1603,7 +1636,7 @@ export function createApp(base) {
         const ids = [...new Set([...Object.keys(before), ...Object.keys(input.globals)])].sort();
         await guardDesign(c.get('user'), ids.map((id) => before[id] ?? { id, type: 'frame' }), ids.map((id) => input.globals[id] ?? { id, type: 'frame' }));
         await settings.set('globals', input.globals, c.get('user').id);
-        ctx.onPublish?.();
+        sitePublished();
         return c.json({ globals: input.globals });
     });
     // ---------- comments and presence ----------
@@ -1803,6 +1836,203 @@ export function createApp(base) {
         await complete(ai, { ...probe, fast: true }).catch(aiFailed);
         return c.json({ ok: true, reply });
     });
+    // ---------- brand voice ----------
+    /** `style` when the AI changes a text someone wrote, `full` when it writes one (see voicePrompt). */
+    const voiceText = async (use = 'full') => voicePrompt(await settings.get('voice'), use);
+    const voiceSchema = z.object({
+        about: z.string().trim().max(1000).optional(),
+        tones: z.array(z.enum(VOICE_TONES)).max(3).optional(),
+        address: z.enum(['tu', 'voi', 'lei']).nullable().optional(),
+        prefer: z.string().trim().max(1000).optional(),
+        avoid: z.string().trim().max(1000).optional(),
+        rules: z.string().trim().max(1500).optional(),
+        example: z.string().trim().max(3000).optional(),
+    });
+    app.get('/api/voice', requireUser, async (c) => c.json({ voice: (await settings.get('voice')) ?? {} }));
+    app.put('/api/voice', requireUser, requireAdmin, async (c) => {
+        const input = await body(c, z.object({ voice: voiceSchema }));
+        await settings.set('voice', input.voice, c.get('user').id);
+        await record(c, 'settings.voice');
+        return c.json({ voice: input.voice });
+    });
+    /**
+     * A brand voice read from the texts already on the site, to start from: nothing is saved, the
+     * panel puts it in the form to check.
+     */
+    app.post('/api/voice/suggest', requireUser, requireAdmin, async (c) => {
+        if (!allowAi(c.get('user').id))
+            throw new ApiError(429, 'too_many_requests', 'Troppe richieste: aspetta un minuto');
+        const ai = await readyAi();
+        const config = ctx.config();
+        const texts = [];
+        let size = 0;
+        for (const def of config.collections) {
+            for (const doc of await content.published(def.name, config.locales.default)) {
+                for (const slot of documentSlots(def.fields, doc.publishedData ?? {})) {
+                    const t = slot.text.replace(/<[^>]+>/g, '').trim();
+                    if (t.length < 20 || size > 14_000)
+                        continue;
+                    texts.push(t);
+                    size += t.length;
+                }
+            }
+        }
+        if (size < 300)
+            throw new ApiError(400, 'too_little_text', 'Il sito ha ancora pochi testi pubblicati: scrivi la voce a mano');
+        const reply = await complete(ai, {
+            system: 'You describe the voice of a brand from the texts of its website, for a style guide the brand will reuse. Reply with JSON only, no code fences.',
+            prompt: `Read these texts of the website "${config.site.name}" and describe how it speaks, writing in the language of the texts.
+Reply with this JSON object:
+{"about": "who the brand is and who it writes for, one or two sentences",
+ "tones": [up to three of ${JSON.stringify(VOICE_TONES)}],
+ "address": "tu" | "voi" | "lei" | null (how readers are addressed),
+ "prefer": "words and phrases typical of these texts, comma separated",
+ "avoid": "words that would sound wrong for this brand, comma separated",
+ "rules": "two or three rules of style seen in the texts, as short sentences",
+ "example": "a short paragraph of new text in this voice, about the brand"}
+
+<texts>
+${texts.join('\n---\n')}
+</texts>`,
+        }).catch(aiFailed);
+        let raw = null;
+        try {
+            raw = JSON.parse(reply.replace(/^\s*```(?:json)?|```\s*$/g, '').trim());
+        }
+        catch { }
+        const parsed = voiceSchema.safeParse(raw && {
+            ...raw,
+            tones: Array.isArray(raw.tones)
+                ? raw.tones.filter((t) => VOICE_TONES.includes(t)).slice(0, 3)
+                : [],
+            address: ['tu', 'voi', 'lei'].includes(raw.address) ? raw.address : null,
+        });
+        if (!parsed.success)
+            throw new ApiError(422, 'ai_failed', 'L’AI non ha risposto come doveva: riprova');
+        return c.json({ voice: parsed.data, texts: texts.length });
+    });
+    // ---------- AI review before publishing ----------
+    const REVIEW_KINDS = ['spelling', 'grammar', 'voice', 'consistency', 'link', 'clarity'];
+    /** The site's pages by address, with their titles: what a link on the page points to. */
+    const pageTitles = async () => {
+        const out = new Map();
+        const config = ctx.config();
+        for (const def of config.collections) {
+            if (!def.url)
+                continue;
+            for (const doc of await content.published(def.name)) {
+                const url = publicUrl(def, doc.locale, doc.publishedData ?? {});
+                if (url && out.size < 200)
+                    out.set(url, doc.title);
+            }
+        }
+        return out;
+    };
+    /**
+     * The AI reads the draft as it is now (saved or not) and lists what to fix before publishing:
+     * typos, grammar, sentences out of the brand voice, facts that contradict each other, links whose
+     * words promise something else than where they go, unclear sentences. Each with the exact words
+     * and a replacement. Nothing is changed.
+     */
+    app.post('/api/documents/:id/review', requireUser, async (c) => {
+        const existing = await loadDocument(c.req.param('id'));
+        const input = await body(c, z.object({ data: z.record(z.string(), z.unknown()).optional() }));
+        if (!allowAi(c.get('user').id))
+            throw new ApiError(429, 'too_many_requests', 'Troppe richieste: aspetta un minuto');
+        const ai = await readyAi();
+        const def = collection(existing.collection);
+        const slots = documentSlots(def.fields, structuredClone(input.data ?? existing.data));
+        if (!slots.length)
+            throw new ApiError(400, 'empty_text', 'Non c’è testo da rivedere');
+        const titles = await pageTitles();
+        const linkTo = (href) => {
+            const path = href.split('#')[0] || href;
+            const title = titles.get(path.replace(/\/+$/, '') || '/');
+            return title ? `${href} (page "${title}")` : href;
+        };
+        let size = 0;
+        const listed = slots.flatMap((s, i) => {
+            if (size > 30_000)
+                return [];
+            size += s.text.length;
+            const links = s.links?.length ? `\n  links: ${s.links.map((l, n) => `${n + 1} → ${linkTo(l)}`).join('; ')}` : '';
+            return [`[${i}] ${s.text}${links}`];
+        });
+        const voice = await voiceText('full');
+        const reply = await complete(ai, {
+            system: `${voice ? `${voice}\n\n` : ''}You review a web page before it is published, as a careful editor. Reply with JSON only, no code fences.`,
+            prompt: `These are the texts of the page "${existing.title}", numbered. Tags like <b>, <i> and <a1>…</a1> mark formatting and links; "links" says where each numbered link goes.
+
+Find what really needs fixing before publishing, and nothing else:
+- spelling: typos and misspelled words
+- grammar: grammar, agreement, punctuation
+- voice: sentences clearly out of the brand voice above (skip if there is none)
+- consistency: facts on the page that contradict each other (prices, dates, names, numbers)
+- link: link words that promise something different from the page they go to
+- clarity: a sentence a reader would not understand
+
+Reply with {"issues": [{"slot": number, "kind": one of ${JSON.stringify(REVIEW_KINDS)}, "find": "the exact words to change, copied from that text with its tags", "replace": "the corrected words, or \\"\\" when only a person can fix it", "note": "why, in one short sentence, in the language of the page"}]}.
+At most 25 issues, the most important first. An empty list is a fine answer when the page is good. Do not report style preferences, the length of texts, or things that are fine.
+
+<texts>
+${listed.join('\n')}
+</texts>`,
+        }).catch(aiFailed);
+        let raw;
+        try {
+            raw = JSON.parse(reply.replace(/^\s*```(?:json)?|```\s*$/g, '').trim());
+        }
+        catch {
+            throw new ApiError(422, 'ai_failed', 'L’AI non ha risposto come doveva: riprova');
+        }
+        const issue = z.object({
+            slot: z.number().int().min(0),
+            kind: z.enum(REVIEW_KINDS),
+            find: z.string().min(1).max(2000),
+            replace: z.string().max(4000),
+            note: z.string().max(500),
+        });
+        const items = Array.isArray(raw?.issues) ? raw.issues : [];
+        const issues = items.flatMap((it) => {
+            const parsed = issue.safeParse(it);
+            if (!parsed.success)
+                return [];
+            const slot = slots[parsed.data.slot];
+            // Only what is really in the text: a quote the model made up cannot be applied.
+            if (!slot?.text.includes(parsed.data.find))
+                return [];
+            return [{ ...parsed.data, node: slot.node ?? null, context: slot.text.replace(/<[^>]+>/g, '').slice(0, 160) }];
+        });
+        await record(c, 'document.reviewed', existing.title, {
+            collection: existing.collection,
+            id: existing.id,
+            issues: issues.length,
+        });
+        return c.json({ issues: issues.slice(0, 25) });
+    });
+    /**
+     * Applies one suggestion of the review to the draft as the editor holds it, and gives it back:
+     * the editor takes it as one change, which ⌘Z undoes. Nothing is saved here.
+     */
+    app.post('/api/documents/:id/review/apply', requireUser, async (c) => {
+        const existing = await loadDocument(c.req.param('id'));
+        const input = await body(c, z.object({
+            data: z.record(z.string(), z.unknown()),
+            slot: z.number().int().min(0),
+            find: z.string().min(1).max(2000),
+            replace: z.string().max(4000),
+        }));
+        const data = structuredClone(input.data);
+        const slots = documentSlots(collection(existing.collection).fields, data);
+        // The same text, or the first one that still has those words (the page may have changed since).
+        const slot = slots[input.slot]?.text.includes(input.find)
+            ? slots[input.slot]
+            : slots.find((s) => s.text.includes(input.find));
+        if (!slot)
+            throw new ApiError(409, 'changed', 'Quel testo è cambiato: rifai la revisione');
+        slot.set(slot.text.replace(input.find, input.replace));
+        return c.json({ data });
+    });
     const TEXT_ACTIONS = {
         rewrite: 'Rewrite it so it reads better: same meaning, similar length.',
         shorten: 'Make it shorter, keeping what matters most.',
@@ -1831,8 +2061,12 @@ export function createApp(base) {
         if (!allowAi(c.get('user').id))
             throw new ApiError(429, 'too_many_requests', 'Troppe richieste: aspetta un minuto');
         const ai = await readyAi();
+        // Writing from scratch takes the whole voice; changing a text, only its style.
+        const voice = await voiceText(['seo_title', 'seo_description', 'custom'].includes(input.action) ? 'full' : 'style');
         const lang = input.locale ?? ctx.config().locales.default;
-        const system = `You edit texts for a website. Reply with the resulting text only: no quotes, no preamble, no notes. Keep the language of the text${input.action === 'translate' ? ' unless asked to translate' : ''}; when writing from scratch, write in the language with code "${lang}". Keep line breaks where they make sense; never add Markdown.`;
+        const system = `You edit texts for a website. Reply with the resulting text only: no quotes, no preamble, no notes. Keep the language of the text${input.action === 'translate' ? ' unless asked to translate' : ''}; when writing from scratch, write in the language with code "${lang}". Keep line breaks where they make sense; never add Markdown.${
+        // Spelling fixes and alternative texts describe: they do not speak with the brand's voice.
+        input.action === 'fix' || input.action === 'alt' || !voice ? '' : `\n\n${voice}`}`;
         if (input.action === 'alt') {
             const key = /^\/media\/([^/?#@]+)/.exec(input.src ?? '')?.[1];
             const file = key ? await files.open(decodeURIComponent(key), { width: 1024, format: 'jpg' }) : null;
@@ -1925,8 +2159,12 @@ export function createApp(base) {
         const chatId = input.chatId ?? crypto.randomUUID();
         const key = `${user.id}:${chatId}`;
         const entry = chats.get(key);
-        const conv = entry && entry.conv.provider === ai.provider ? entry.conv : { provider: ai.provider, messages: [] };
-        chats.set(key, { conv, at: now });
+        const same = !!entry && entry.conv.provider === ai.provider;
+        const conv = same && entry ? entry.conv : { provider: ai.provider, messages: [] };
+        // Fixed when the conversation starts (its instructions may not change): a voice changed
+        // meanwhile applies to the next conversation.
+        const voice = same && entry?.voice !== undefined ? entry.voice : await voiceText();
+        chats.set(key, { conv, at: now, voice });
         const before = input.nodes;
         const page = { nodes: before };
         const auth = {};
@@ -1941,7 +2179,7 @@ export function createApp(base) {
         // The instructions stay the same for the whole conversation: the model's earlier reasoning is
         // tied to them (a change is refused) and they are read from the prompt cache. What changes
         // from turn to turn, the page and what is selected, goes with each message instead.
-        const system = `You are the assistant inside Materialize, the visual editor of the website "${ctx.config().site.name}". The person (${user.name}) is editing a page; each of their messages starts with a <context> note on the page and on what is selected on the canvas.
+        const system = `${voice ? `${voice}\n\n` : ''}You are the assistant inside Materialize, the visual editor of the website "${ctx.config().site.name}". The person (${user.name}) is editing a page; each of their messages starts with a <context> note on the page and on what is selected on the canvas.
 Use the tools to look at the page (get_page, get_node) and change it (edit_page). Your changes go into the editor, where the person sees them at once and can undo them; they are not published.
 Read the page before changing it. Make the changes asked, consistent with the design already there (theme colors and text styles, spacing, the look of nearby sections); prefer the section library for new sections. Keep ids of existing nodes.
 ${limited ? 'This person may change only contents (texts, links, images, alt texts), not the layout or the design: do not add, remove or move nodes, and do not change styles.\n' : ''}Pictures the person attaches are references (a site they like, a mockup, a sketch): take their layout, hierarchy and mood, and build it with this site's sections, theme and texts; never copy their brand, logos or texts, and do not put the pictures on the page.
@@ -1959,7 +2197,7 @@ When done, say in one or two short sentences what you changed. Reply in the pers
                     tools,
                     onEvent: (e) => void send(e),
                 });
-                chats.set(key, { conv, at: Date.now() });
+                chats.set(key, { conv, at: Date.now(), voice });
                 if (page.nodes !== before) {
                     if (limited && !sameDesign(before, page.nodes))
                         await send({
@@ -1982,59 +2220,427 @@ When done, say in one or two short sentences what you changed. Reply in the pers
             }
         });
     });
-    app.post('/api/forms/:form', async (c) => {
+    // A first version of the site from a few lines about the business: new drafts only, theme and
+    // voice proposed. Admins, since the proposal touches the design of the whole site.
+    /** Runs of the site builder, per person, kept two hours: the person may answer the AI and go on. */
+    const briefRuns = new Map();
+    app.post('/api/ai/site', requireUser, requireSession, requireAdmin, async (c) => {
+        const input = await body(c, z
+            .object({
+            brief: z.string().trim().min(20, 'Scrivi qualche riga in più sull’attività').max(6000).optional(),
+            /** A reply in a run already started, with its id. */
+            runId: z.string().max(64).optional(),
+            message: z.string().trim().min(1).max(4000).optional(),
+            theme: z.boolean().default(true),
+            images: z
+                .array(z.object({
+                mime: z.enum(['image/png', 'image/jpeg', 'image/webp']),
+                data: z.base64().max(4_000_000),
+            }))
+                .max(2)
+                .default([]),
+        })
+            .refine((v) => (v.runId ? !!v.message : !!v.brief), { message: 'Scrivi il brief' }));
+        const user = c.get('user');
+        if (!allowAi(user.id))
+            throw new ApiError(429, 'too_many_requests', 'Troppe richieste: aspetta un minuto');
+        const ai = await readyAi();
+        const now = Date.now();
+        for (const [k, v] of briefRuns)
+            if (now - v.at > 2 * 60 * 60 * 1000)
+                briefRuns.delete(k);
+        const runId = input.runId ?? crypto.randomUUID();
+        const key = `${user.id}:${runId}`;
+        let run = input.runId ? briefRuns.get(key) : undefined;
+        if (input.runId && (!run || run.conv.provider !== ai.provider))
+            throw new ApiError(409, 'run_expired', 'Questa conversazione non c’è più: parti da un nuovo brief');
+        if (!run) {
+            const config = ctx.config();
+            const pageCollections = config.collections.filter((d) => !d.singleton && Object.values(d.fields).some((f) => f.kind === 'page'));
+            if (!pageCollections.length)
+                throw new ApiError(400, 'no_pages', 'Il sito non ha una raccolta di pagine costruite sulla tela');
+            const locale = config.locales.default;
+            const existing = [];
+            for (const d of config.collections.filter((x) => !x.singleton)) {
+                const { items } = await content.list(d.name, { locale, limit: 100 });
+                for (const i of items)
+                    existing.push(`${d.name}: "${i.title}"${i.slug ? ` (slug ${i.slug})` : ''}`);
+            }
+            // Fixed for the whole run, like the assistant's: the model's reasoning is tied to them.
+            const voice = await voiceText();
+            const askVoice = !voice;
+            run = {
+                conv: { provider: ai.provider, messages: [] },
+                system: briefSystem({
+                    site: config.site.name,
+                    language: languageName(locale),
+                    collections: pageCollections.map((d) => `${d.name} (${d.label ?? d.name})`).join(', '),
+                    existing: existing.length ? existing.join('; ') : 'none: the site is empty',
+                    voice,
+                    askVoice,
+                    theme: input.theme,
+                }),
+                result: { created: [], theme: null, voice: null },
+                askVoice,
+                theme: input.theme,
+                at: now,
+            };
+        }
+        const current = run;
+        current.at = now;
+        briefRuns.set(key, current);
+        const auth = {};
+        const authorization = c.req.header('authorization');
+        const cookie = c.req.header('cookie');
+        if (authorization)
+            auth.authorization = authorization;
+        else if (cookie)
+            auth.cookie = cookie;
+        return streamSSE(c, async (stream) => {
+            const send = (data) => stream.writeSSE({ data: JSON.stringify(data) });
+            const stop = new AbortController();
+            stream.onAbort(() => stop.abort());
+            const { tools, result } = briefTools(apiCaller(app.fetch, auth), {
+                askVoice: current.askVoice,
+                result: current.result,
+                onCreated: (doc) => void send({ type: 'created', doc }),
+            });
+            const before = result.created.length;
+            try {
+                const reply = await runTurn(ai, current.conv, {
+                    system: current.system,
+                    text: input.runId ? (input.message ?? '') : `<brief>\n${input.brief}\n</brief>`,
+                    images: input.images,
+                    tools: current.theme ? tools : tools.filter((t) => t.name !== 'propose_theme'),
+                    onEvent: (e) => void send(e),
+                    maxSteps: 80,
+                    signal: stop.signal,
+                });
+                if (result.created.length > before)
+                    await record(c, 'site.generated', '', { pages: result.created.length - before });
+                await send({ type: 'result', ...result });
+                await send({ type: 'text', text: reply });
+                await send({ type: 'done', runId });
+            }
+            catch (error) {
+                if (!(error instanceof AiError))
+                    console.error(error);
+                // What was made before the failure stays, as drafts: the panel lists it. The run ends.
+                briefRuns.delete(key);
+                await send({ type: 'result', ...result });
+                await send({ type: 'error', message: error instanceof Error ? error.message : 'Errore' });
+                await send({ type: 'done' });
+            }
+        });
+    });
+    /** Requests from the dashboard, per person, kept two hours so the person can answer and go on. */
+    const studioRuns = new Map();
+    app.post('/api/ai/studio', requireUser, async (c) => {
+        const input = await body(c, z.object({
+            runId: z.string().max(64).optional(),
+            message: z.string().trim().min(1).max(6000),
+            images: z
+                .array(z.object({
+                mime: z.enum(['image/png', 'image/jpeg', 'image/webp']),
+                data: z.base64().max(4_000_000),
+            }))
+                .max(4)
+                .default([]),
+        }));
+        const user = c.get('user');
+        if (!allowAi(user.id))
+            throw new ApiError(429, 'too_many_requests', 'Troppe richieste: aspetta un minuto');
+        const ai = await readyAi();
+        const now = Date.now();
+        for (const [k, v] of studioRuns)
+            if (now - v.at > 2 * 60 * 60 * 1000)
+                studioRuns.delete(k);
+        const runId = input.runId ?? crypto.randomUUID();
+        const key = `${user.id}:${runId}`;
+        const found = input.runId ? studioRuns.get(key) : undefined;
+        const run = found && found.conv.provider === ai.provider
+            ? found
+            : {
+                conv: { provider: ai.provider, messages: [] },
+                // Fixed for the whole conversation: the model's reasoning is tied to it.
+                system: studioSystem({
+                    site: ctx.config().site.name,
+                    user: user.name,
+                    voice: await voiceText(),
+                    limited: await contentOnly(user),
+                }),
+                at: now,
+            };
+        run.at = now;
+        studioRuns.set(key, run);
+        const credentials = credentialsOf(c);
+        return streamSSE(c, async (stream) => {
+            const send = (data) => stream.writeSSE({ data: JSON.stringify(data) });
+            const stop = new AbortController();
+            stream.onAbort(() => stop.abort());
+            const seen = new Set();
+            const tools = studioTools(apiCaller(app.fetch, credentials), (doc) => {
+                if (seen.has(doc.id))
+                    return;
+                seen.add(doc.id);
+                void send({ type: 'touched', doc });
+            });
+            try {
+                const reply = await runTurn(ai, run.conv, {
+                    system: run.system,
+                    text: input.message,
+                    images: input.images,
+                    tools,
+                    onEvent: (e) => void send(e),
+                    maxSteps: 40,
+                    signal: stop.signal,
+                });
+                if (seen.size)
+                    await record(c, 'site.ai_request', '', { documents: seen.size });
+                await send({ type: 'text', text: reply });
+                await send({ type: 'done', runId });
+            }
+            catch (error) {
+                if (!(error instanceof AiError))
+                    console.error(error);
+                studioRuns.delete(key);
+                await send({ type: 'error', message: error instanceof Error ? error.message : 'Errore' });
+                await send({ type: 'done' });
+            }
+        });
+    });
+    // ---------- forms ----------
+    /**
+     * Every form on the published site, by id, as the server checks it: canvas pages with their
+     * shared sections and components expanded, like the site renders them. Kept a minute.
+     */
+    const publishedForms = async () => {
+        if (formCache && Date.now() - formCache.at < 60_000)
+            return formCache.forms;
+        const forms = new Map();
+        const globals = (await settings.get('globals')) ?? {};
+        const components = (await settings.get('components')) ?? {};
+        const collect = (nodes) => walk(expandComponents(expandGlobals(nodes, globals), components), (n) => {
+            const def = formDefinition(n);
+            if (def && !forms.has(def.id))
+                forms.set(def.id, def);
+        });
+        for (const def of ctx.config().collections) {
+            const pageFields = Object.entries(def.fields)
+                .filter(([, f]) => f.kind === 'page')
+                .map(([name]) => name);
+            if (!pageFields.length)
+                continue;
+            for (const doc of await content.published(def.name)) {
+                for (const name of pageFields) {
+                    const nodes = doc.publishedData?.[name];
+                    if (Array.isArray(nodes))
+                        collect(nodes);
+                }
+            }
+        }
+        collect(Object.values(globals));
+        formCache = { at: Date.now(), forms };
+        return forms;
+    };
+    const formsSettings = async () => (await settings.get('forms')) ?? {};
+    /** The secret that signs webhook calls, made the first time it is needed. */
+    const webhookSecret = async () => {
+        const current = await formsSettings();
+        if (current.webhookSecret)
+            return current.webhookSecret;
+        const secret = `whsec_${randomBytes(24).toString('base64url')}`;
+        await settings.set('forms', { ...current, webhookSecret: secret });
+        return secret;
+    };
+    app.post('/api/forms/:form', bodyLimit({
+        maxSize: 25 * 1024 * 1024,
+        onError: () => {
+            throw new ApiError(413, 'file_too_large', 'Gli allegati sono troppo grandi');
+        },
+    }), async (c) => {
         const form = c.req.param('form').slice(0, 80);
         const ip = clientIp(c);
         if (!allowForm(`${ip}:${form}`))
             throw new ApiError(429, 'too_many_attempts', 'Troppi messaggi: riprova tra un minuto');
-        const isJson = (c.req.header('content-type') ?? '').includes('application/json');
+        const type = c.req.header('content-type') ?? '';
+        const isJson = type.includes('application/json');
+        const wantsJson = isJson || (c.req.header('accept') ?? '').includes('application/json');
         const raw = (isJson ? await c.req.json().catch(() => ({})) : await c.req.parseBody());
         const page = typeof raw._page === 'string' ? raw._page.slice(0, 300) : (c.req.header('referer') ?? '').slice(0, 300);
-        // A field people never see: bots fill it in.
-        const trap = typeof raw._gotcha === 'string' && raw._gotcha.length > 0;
-        const data = {};
-        for (const [k, v] of Object.entries(raw)) {
-            if (k.startsWith('_') || typeof v !== 'string' || Object.keys(data).length >= 30)
-                continue;
-            data[k.slice(0, 80)] = v.slice(0, 5000);
-        }
-        if (!trap && Object.values(data).some((v) => v.trim())) {
-            const saved = await submissions.add({ form, page, data });
+        const back = (c.req.header('referer') ?? '/').split('#')[0];
+        // A field people never see: bots fill it in. They get the same answer as everyone.
+        if (typeof raw._gotcha === 'string' && raw._gotcha.length > 0)
+            return wantsJson ? c.json({ ok: true }) : c.redirect(`${back}#inviato`, 303);
+        const def = (await publishedForms()).get(form) ?? null;
+        const { data, files, issues } = await readSubmission(raw, def);
+        if (issues.length) {
+            if (!wantsJson)
+                return c.redirect(`${back}#non-inviato`, 303);
+            return c.json({ error: { code: 'invalid', message: 'Controlla i campi evidenziati', issues } }, 422);
+        }
+        if (!Object.values(data).some((v) => v.trim()) && !files.length)
+            return wantsJson ? c.json({ ok: true }) : c.redirect(`${back}#inviato`, 303);
+        const elapsed = typeof raw._t === 'string' && /^\d+$/.test(raw._t) ? Number(raw._t) : null;
+        const fingerprint = fingerprintOf(form, data);
+        const spam = spamReason(data, elapsed) ??
+            ((await submissions.seen(fingerprint, new Date(Date.now() - 86_400_000))) ? 'Messaggio ripetuto' : null);
+        const formName = def?.name?.trim() || def?.subject?.trim() || '';
+        const saved = await submissions.add({ form, formName, page, data, spam, fingerprint });
+        if (files.length)
+            await submissions.setFiles(saved.id, await saveFiles(uploadsDir, saved.id, files));
+        // Spam stays in the panel, recoverable, but nobody is notified.
+        if (!spam) {
             const mail = await settings.get('mail');
-            if (isConfigured(mail) && mail.to) {
-                const replyTo = Object.entries(data).find(([k, v]) => /mail/i.test(k) && /^[^\s@]+@[^\s@]+$/.test(v))?.[1];
+            const to = (def?.to || mail?.to || '').trim();
+            const sender = Object.entries(data).find(([k, v]) => (def?.fields.find((f) => f.name === k)?.kind === 'email' || /mail/i.test(k)) && /^[^\s@]+@[^\s@]+$/.test(v))?.[1];
+            if (isConfigured(mail) && to) {
+                const subject = def?.subject || (typeof raw._subject === 'string' ? raw._subject.slice(0, 120) : '');
+                const attached = files.length
+                    ? `\n\nAllegati (${files.map((f) => f.name).join(', ')}): li trovi in Impostazioni → Messaggi.`
+                    : '';
                 sendMail(mail, {
-                    to: mail.to,
-                    subject: `Nuovo messaggio dal sito${typeof raw._subject === 'string' ? `: ${raw._subject.slice(0, 120)}` : ''}`,
-                    text: submissionText(page, data),
-                    replyTo,
+                    to,
+                    subject: `Nuovo messaggio dal sito${subject ? `: ${subject}` : ''}`,
+                    text: submissionText(page, data) + attached,
+                    replyTo: sender,
                 })
                     .then(() => submissions.markMailed(saved.id))
                     .catch((error) => console.error('Materialize: email not sent', error));
+                // An answer to whoever wrote: the site's own words only, never what was sent.
+                if (sender && def?.autoReply?.text?.trim())
+                    sendMail(mail, {
+                        to: sender,
+                        subject: def.autoReply.subject?.trim() || 'Abbiamo ricevuto il tuo messaggio',
+                        text: def.autoReply.text,
+                        replyTo: to.split(',')[0]?.trim(),
+                    }).catch((error) => console.error('Materialize: automatic reply not sent', error));
+            }
+            if (def?.webhook) {
+                const payload = {
+                    id: saved.id,
+                    form: { id: form, name: formName },
+                    page,
+                    data,
+                    files: files.map((f) => ({ field: f.field, name: f.name, size: f.bytes.length })),
+                    createdAt: saved.createdAt.toISOString(),
+                };
+                void webhookSecret()
+                    .then((secret) => sendWebhook(def.webhook, payload, secret))
+                    .then((ok) => submissions.setWebhook(saved.id, ok ? 'ok' : 'failed'))
+                    .catch((error) => console.error('Materialize: webhook not sent', error));
             }
         }
         // Without JavaScript the browser posted the form itself: back to the page, marked as sent.
-        if (!isJson) {
-            const back = (c.req.header('referer') ?? '/').split('#')[0];
-            return c.redirect(`${back}#inviato`, 303);
-        }
-        return c.json({ ok: true });
+        return wantsJson ? c.json({ ok: true }) : c.redirect(`${back}#inviato`, 303);
+    });
+    const filterOf = (c) => ({
+        form: c.req.query('form') || undefined,
+        status: ['unread', 'spam'].find((s) => s === c.req.query('status')),
+        q: c.req.query('q')?.slice(0, 200) || undefined,
     });
     app.get('/api/submissions', requireUser, async (c) => {
         const limit = Math.min(Number(c.req.query('limit') ?? 50), 200);
         const offset = Math.max(Number(c.req.query('offset') ?? 0), 0);
-        return c.json(await submissions.list(limit, offset));
+        return c.json({
+            ...(await submissions.list(limit, offset, filterOf(c))),
+            forms: await submissions.forms(),
+        });
+    });
+    /** The messages as a spreadsheet (one column per field), with the filters of the list. */
+    app.get('/api/submissions/export.csv', requireUser, async (c) => {
+        const { items } = await submissions.list(10_000, 0, filterOf(c));
+        const fields = [...new Set(items.flatMap((m) => Object.keys(m.data)))];
+        const cell = (v) => {
+            // A leading =, +, - or @ would run as a formula in a spreadsheet.
+            const safe = /^[=+\-@\t\r]/.test(v) ? `'${v}` : v;
+            return /[",\n;]/.test(safe) ? `"${safe.replace(/"/g, '""')}"` : safe;
+        };
+        const rows = [
+            ['Data', 'Modulo', 'Pagina', ...fields],
+            ...items.map((m) => [
+                m.createdAt.toISOString(),
+                m.formName || m.form,
+                m.page,
+                ...fields.map((f) => m.data[f] ?? ''),
+            ]),
+        ];
+        await record(c, 'message.exported', '', { count: items.length });
+        // With the byte order mark, Excel reads accented letters right.
+        return new Response(`${rows.map((r) => r.map(cell).join(',')).join('\r\n')}\r\n`, {
+            headers: {
+                'content-type': 'text/csv; charset=utf-8',
+                'content-disposition': `attachment; filename="messaggi-${new Date().toISOString().slice(0, 10)}.csv"`,
+                'cache-control': 'no-store',
+            },
+        });
     });
     app.patch('/api/submissions/:id', requireUser, async (c) => {
-        const input = await body(c, z.object({ read: z.boolean() }));
-        await submissions.markRead(c.req.param('id'), input.read);
+        const input = await body(c, z.object({ read: z.boolean().optional(), spam: z.boolean().optional() }));
+        const id = c.req.param('id');
+        if (input.read !== undefined)
+            await submissions.markRead(id, input.read);
+        if (input.spam !== undefined)
+            await submissions.markSpam(id, input.spam ? 'Segnato a mano' : null);
         return c.json({ ok: true });
     });
+    /** A file sent with a message: always downloaded, never opened in the panel's own page. */
+    app.get('/api/submissions/:id/files/:n', requireUser, async (c) => {
+        const message = await submissions.get(c.req.param('id'));
+        const file = message?.files[Number(c.req.param('n'))];
+        if (!message || !file)
+            throw new ApiError(404, 'not_found', 'File non trovato');
+        const bytes = await readFile(join(uploadsDir, file.path)).catch(() => null);
+        if (!bytes)
+            throw new ApiError(404, 'not_found', 'Il file non c’è più');
+        return new Response(bytes, {
+            headers: {
+                'content-type': 'application/octet-stream',
+                'content-disposition': `attachment; filename*=UTF-8''${encodeURIComponent(file.name)}`,
+                'x-content-type-options': 'nosniff',
+                'cache-control': 'no-store',
+            },
+        });
+    });
     app.delete('/api/submissions/:id', requireUser, requireAdmin, async (c) => {
         await submissions.remove(c.req.param('id'));
+        await removeFiles(uploadsDir, c.req.param('id'));
         await record(c, 'message.deleted');
         return c.body(null, 204);
     });
+    /** How long messages are kept, and the key to check webhook calls (admins only see the key). */
+    app.get('/api/forms/settings', requireUser, async (c) => {
+        const current = await formsSettings();
+        const admin = c.get('user').role === 'admin';
+        return c.json({
+            keepMonths: current.keepMonths ?? null,
+            webhookSecret: admin ? await webhookSecret() : null,
+        });
+    });
+    app.put('/api/forms/settings', requireUser, requireAdmin, async (c) => {
+        const input = await body(c, z.object({ keepMonths: z.number().int().min(1).max(120).nullable() }));
+        const current = await formsSettings();
+        await settings.set('forms', { ...current, keepMonths: input.keepMonths ?? undefined }, c.get('user').id);
+        await record(c, 'settings.forms', '', { keepMonths: input.keepMonths });
+        void pruneMessages();
+        return c.json({ keepMonths: input.keepMonths });
+    });
+    /** Deletes the messages older than the kept months, with their files. */
+    const pruneMessages = async () => {
+        const months = (await formsSettings()).keepMonths;
+        if (!months)
+            return 0;
+        const before = new Date();
+        before.setMonth(before.getMonth() - months);
+        const old = await submissions.olderThan(before);
+        for (const m of old) {
+            await submissions.remove(m.id);
+            await removeFiles(uploadsDir, m.id);
+        }
+        return old.length;
+    };
+    setTimeout(() => void pruneMessages().catch(() => { }), 10_000).unref?.();
+    setInterval(() => void pruneMessages().catch(() => { }), 6 * 3_600_000).unref?.();
     // Who may change what: editors limited to contents, if the admins want so.
     app.get('/api/editorial', requireUser, async (c) => c.json({ editorial: (await settings.get('editorial')) ?? {} }));
     app.put('/api/editorial', requireUser, requireSession, requireAdmin, async (c) => {
@@ -2087,7 +2693,7 @@ When done, say in one or two short sentences what you changed. Reply in the pers
             }),
         }));
         await settings.set('tracking', input.tracking, c.get('user').id);
-        ctx.onPublish?.();
+        sitePublished();
         await record(c, 'settings.tracking', '', {
             services: trackingBlocks(input.tracking).map((b) => b.name),
         });
@@ -2098,7 +2704,7 @@ When done, say in one or two short sentences what you changed. Reply in the pers
     app.put('/api/seo', requireUser, requireAdmin, async (c) => {
         const input = await body(c, z.object({ seo: siteSeoSchema }));
         await settings.set('seo', input.seo, c.get('user').id);
-        ctx.onPublish?.();
+        sitePublished();
         await record(c, 'settings.seo');
         return c.json({ seo: input.seo });
     });
@@ -2124,7 +2730,7 @@ When done, say in one or two short sentences what you changed. Reply in the pers
             .map((r) => ({ ...r, from: normalizePath(r.from), to: /^https?:\/\//.test(r.to) ? r.to : normalizePath(r.to) }))
             .filter((r, i, all) => r.from !== r.to && all.findIndex((o) => o.from === r.from) === i);
         await settings.set('redirects', redirects, c.get('user').id);
-        ctx.onPublish?.();
+        sitePublished();
         await record(c, 'settings.redirects', '', { count: redirects.length });
         return c.json({ redirects });
     });
@@ -2133,7 +2739,7 @@ When done, say in one or two short sentences what you changed. Reply in the pers
     app.put('/api/templates', requireUser, async (c) => {
         const input = await body(c, z.object({ templates: z.record(z.string(), z.string()) }));
         await settings.set('templates', input.templates, c.get('user').id);
-        ctx.onPublish?.();
+        sitePublished();
         return c.json({ templates: input.templates });
     });
     // Reusable components with their variants.
@@ -2145,7 +2751,7 @@ When done, say in one or two short sentences what you changed. Reply in the pers
         if (JSON.stringify(before) !== JSON.stringify(input.components) && (await contentOnly(c.get('user'))))
             throw designLocked();
         await settings.set('components', input.components, c.get('user').id);
-        ctx.onPublish?.();
+        sitePublished();
         return c.json({ components: input.components });
     });
     // Entries with their data, for lists bound to a collection on the canvas.
@@ -2233,7 +2839,18 @@ When done, say in one or two short sentences what you changed. Reply in the pers
                 return null;
             }
         };
-        return c.json({ ...result, items: result.items.map((i) => ({ ...i, url: urlOf(i.slug) })) });
+        // What goes on or off the site by itself, for a label in the list.
+        const pending = await schedules.pending();
+        const when = (id, action) => pending.find((p) => p.documentId === id && p.action === action)?.runAt ?? null;
+        return c.json({
+            ...result,
+            items: result.items.map((i) => ({
+                ...i,
+                url: urlOf(i.slug),
+                publishAt: when(i.id, 'publish'),
+                unpublishAt: when(i.id, 'unpublish'),
+            })),
+        });
     });
     app.post('/api/collections/:name', requireUser, async (c) => {
         const def = collection(c.req.param('name'));
@@ -2246,7 +2863,7 @@ When done, say in one or two short sentences what you changed. Reply in the pers
         guardEmbeds(c.get('user'), null, draft.data);
         const doc = await slugGuard(() => content.create({ collection: def.name, locale: lang, ...draft, userId: c.get('user').id }));
         await record(c, 'document.created', doc.title, { collection: def.name, id: doc.id });
-        return c.json(toJson(doc), 201);
+        return c.json(await toJson(doc), 201);
     });
     const loadDocument = async (id) => {
         const doc = await content.get(id);
@@ -2254,7 +2871,7 @@ When done, say in one or two short sentences what you changed. Reply in the pers
             throw new ApiError(404, 'not_found', 'This document does not exist');
         return doc;
     };
-    app.get('/api/documents/:id', requireUser, async (c) => c.json(toJson(await loadDocument(c.req.param('id')))));
+    app.get('/api/documents/:id', requireUser, async (c) => c.json(await toJson(await loadDocument(c.req.param('id')))));
     app.put('/api/documents/:id', requireUser, async (c) => {
         const existing = await loadDocument(c.req.param('id'));
         const input = await body(c, documentBody);
@@ -2265,10 +2882,10 @@ When done, say in one or two short sentences what you changed. Reply in the pers
             if (f.kind === 'page')
                 await guardDesign(c.get('user'), existing.data[name], draft.data[name]);
         const doc = await slugGuard(() => content.update(existing.id, { ...draft, userId: c.get('user').id }));
-        return c.json(toJson(doc));
+        return c.json(await toJson(doc));
     });
-    app.post('/api/documents/:id/publish', requireUser, async (c) => {
-        const existing = await loadDocument(c.req.param('id'));
+    /** Puts a document's draft on the site: the same steps from the button and from a schedule. */
+    const publishDocument = async (existing, userId) => {
         // Validated now, not at save time: drafts may be incomplete and the schema may have changed since.
         const def = collection(existing.collection);
         const data = publishableData(def, existing.data);
@@ -2282,26 +2899,390 @@ When done, say in one or two short sentences what you changed. Reply in the pers
                 ? addMove(redirects, before, after)
                 : redirects.filter((r) => normalizePath(r.from) !== normalizePath(after));
             if (next.length !== redirects.length || next.some((r, i) => r !== redirects[i]))
-                await settings.set('redirects', next, c.get('user').id);
+                await settings.set('redirects', next, userId);
         }
-        const doc = (await content.publish(existing.id, c.get('user').id, data));
-        ctx.onPublish?.();
-        await record(c, 'document.published', doc.title, { collection: def.name, id: doc.id, url: after });
-        return c.json(toJson(doc));
+        const doc = (await content.publish(existing.id, userId, data));
+        sitePublished();
+        return { doc, url: after };
+    };
+    const unpublishDocument = async (existing, userId) => {
+        const doc = (await content.unpublish(existing.id, userId));
+        if (existing.publishedAt)
+            sitePublished();
+        return doc;
+    };
+    app.post('/api/documents/:id/publish', requireUser, async (c) => {
+        const existing = await loadDocument(c.req.param('id'));
+        const { doc, url } = await publishDocument(existing, c.get('user').id);
+        // Published by hand: a publication still waiting would only repeat it.
+        await schedules.cancel(existing.id, 'publish');
+        await record(c, 'document.published', doc.title, { collection: doc.collection, id: doc.id, url });
+        return c.json(await toJson(doc));
     });
     app.post('/api/documents/:id/unpublish', requireUser, async (c) => {
         const existing = await loadDocument(c.req.param('id'));
-        const doc = (await content.unpublish(existing.id, c.get('user').id));
-        if (existing.publishedAt)
-            ctx.onPublish?.();
+        const doc = await unpublishDocument(existing, c.get('user').id);
+        await schedules.cancel(existing.id, 'unpublish');
         await record(c, 'document.unpublished', doc.title, { collection: doc.collection, id: doc.id });
-        return c.json(toJson(doc));
+        return c.json(await toJson(doc));
+    });
+    /**
+     * When a document goes on the site, or comes off it, by itself. `at` null cancels. A publication
+     * is checked now too, so missing fields show up when it is set, not when it fails at night.
+     */
+    app.put('/api/documents/:id/schedule', requireUser, async (c) => {
+        const existing = await loadDocument(c.req.param('id'));
+        const input = await body(c, z.object({ action: z.enum(['publish', 'unpublish']), at: z.iso.datetime({ offset: true }).nullable() }));
+        const user = c.get('user');
+        const label = input.action === 'publish' ? 'publish' : 'unpublish';
+        if (input.at === null) {
+            await schedules.cancel(existing.id, input.action);
+            await record(c, `document.schedule_cancelled`, existing.title, {
+                collection: existing.collection,
+                id: existing.id,
+                action: label,
+            });
+            return c.json(await toJson(existing));
+        }
+        const at = new Date(input.at);
+        if (at.getTime() <= Date.now() + 30_000)
+            throw new ApiError(400, 'past_time', 'Scegli un momento nel futuro, almeno tra un minuto');
+        const current = await schedules.forDocument(existing.id);
+        if (input.action === 'publish')
+            publishableData(collection(existing.collection), existing.data);
+        else {
+            if (!existing.publishedAt && !current.publish)
+                throw new ApiError(409, 'not_published', 'La pagina non è sul sito: programma prima la pubblicazione');
+            if (current.publish && current.publish.runAt >= at)
+                throw new ApiError(400, 'before_publish', 'La pagina verrebbe tolta prima di essere pubblicata');
+        }
+        if (input.action === 'publish' && current.unpublish && current.unpublish.runAt <= at)
+            throw new ApiError(400, 'after_unpublish', 'La pubblicazione verrebbe dopo il momento in cui la pagina va tolta');
+        await schedules.set({ documentId: existing.id, action: input.action, runAt: at, user });
+        await record(c, 'document.scheduled', existing.title, {
+            collection: existing.collection,
+            id: existing.id,
+            action: label,
+            at: at.toISOString(),
+        });
+        return c.json(await toJson(existing));
     });
+    /** Why a document's draft cannot go on the site now, in words; null when it can. */
+    const publishProblem = (doc) => {
+        const def = ctx.config().collections.find((x) => x.name === doc.collection);
+        if (!def)
+            return 'La raccolta non esiste più';
+        const check = validate(def, prepare(def, doc.data));
+        if (check.ok)
+            return null;
+        const fields = [...new Set(check.issues.map((i) => def.fields[i.path.split('.')[0] ?? '']?.label ?? i.path))];
+        return `Alcuni campi vanno completati${fields.length ? `: ${fields.join(', ')}` : ''}`;
+    };
+    /**
+     * Runs the actions whose time has come, as the person who set them. A server that was off at the
+     * time catches up when it starts. A publication whose fields are no longer complete fails with a
+     * reason the panel shows, instead of putting a broken page online.
+     */
+    let schedulesRunning = false;
+    const runSchedules = async (now = new Date()) => {
+        if (schedulesRunning)
+            return 0;
+        schedulesRunning = true;
+        let ran = 0;
+        try {
+            for (const item of await schedules.due(now)) {
+                const note = (action, target, detail) => activityLog
+                    .record({
+                    userId: item.createdBy,
+                    userName: item.createdByName,
+                    action,
+                    target,
+                    detail: { ...detail, scheduled: true },
+                    ip: null,
+                })
+                    .catch((error) => console.error('Materialize: activity not recorded', error));
+                const existing = await content.get(item.documentId);
+                if (!existing) {
+                    await schedules.finish(item.id, 'failed', 'La pagina non esiste più');
+                    continue;
+                }
+                try {
+                    if (item.action === 'publish') {
+                        const problem = publishProblem(existing);
+                        if (problem)
+                            throw new Error(problem);
+                        const { doc, url } = await publishDocument(existing, item.createdBy ?? undefined);
+                        await schedules.finish(item.id, 'done');
+                        await note('document.published', doc.title, { collection: doc.collection, id: doc.id, url });
+                    }
+                    else {
+                        const doc = await unpublishDocument(existing, item.createdBy ?? undefined);
+                        await schedules.finish(item.id, 'done');
+                        await note('document.unpublished', doc.title, { collection: doc.collection, id: doc.id });
+                    }
+                    ran++;
+                }
+                catch (error) {
+                    const message = error instanceof Error && error.message ? error.message : 'Errore imprevisto';
+                    await schedules.finish(item.id, 'failed', message);
+                    await note('document.schedule_failed', existing.title, {
+                        collection: existing.collection,
+                        id: existing.id,
+                        action: item.action,
+                        message,
+                    });
+                }
+            }
+            for (const release of await releases.due(now)) {
+                const by = release.scheduledBy ? { id: release.scheduledBy, name: release.scheduledByName } : null;
+                if (await releaseOut(release, by))
+                    ran++;
+            }
+        }
+        catch (error) {
+            console.error('Materialize: scheduled publishing failed', error);
+        }
+        finally {
+            schedulesRunning = false;
+        }
+        return ran;
+    };
+    setTimeout(() => void runSchedules(), 5_000).unref?.();
+    setInterval(() => void runSchedules(), 30_000).unref?.();
+    /** What is coming: every pending publication and removal, soonest first. */
+    app.get('/api/schedules', requireUser, async (c) => {
+        const items = await schedules.pending();
+        const docs = new Map();
+        for (const i of items)
+            if (!docs.has(i.documentId))
+                docs.set(i.documentId, await content.get(i.documentId));
+        return c.json({
+            items: items.flatMap((i) => {
+                const doc = docs.get(i.documentId);
+                return doc ? [{ ...i, title: doc.title, collection: doc.collection, locale: doc.locale }] : [];
+            }),
+        });
+    });
+    /** What stops a release from going out: every document must be ready, or none goes. */
+    const releaseProblems = async (release) => {
+        const out = [];
+        for (const item of release.items) {
+            const doc = await content.get(item.documentId);
+            if (!doc)
+                out.push({ documentId: item.documentId, title: '', message: 'La pagina non esiste più' });
+            else if (item.action === 'publish') {
+                const message = publishProblem(doc);
+                if (message)
+                    out.push({ documentId: doc.id, title: doc.title, message });
+            }
+        }
+        if (!release.items.length)
+            out.push({ documentId: '', title: '', message: 'Il rilascio è vuoto' });
+        return out;
+    };
+    /**
+     * Puts a release on the site: checked first, all or nothing. Returns whether it went out; when
+     * it did not, the release is marked failed with the reason, and the panel shows it.
+     */
+    const releaseOut = async (release, by) => {
+        const note = (action, target, detail) => activityLog
+            .record({ userId: by?.id ?? null, userName: by?.name ?? '', action, target, detail, ip: null })
+            .catch((error) => console.error('Materialize: activity not recorded', error));
+        const problems = await releaseProblems(release);
+        if (problems.length) {
+            const message = problems.map((p) => (p.title ? `${p.title}: ${p.message}` : p.message)).join('; ');
+            await releases.finish(release.id, 'failed', message);
+            await note('release.failed', release.name, { id: release.id, message });
+            return false;
+        }
+        const done = [];
+        try {
+            for (const item of release.items) {
+                const doc = await content.get(item.documentId);
+                if (!doc)
+                    continue;
+                if (item.action === 'publish') {
+                    await publishDocument(doc, by?.id);
+                    await schedules.cancel(doc.id, 'publish');
+                }
+                else if (doc.publishedAt) {
+                    await unpublishDocument(doc, by?.id);
+                    await schedules.cancel(doc.id, 'unpublish');
+                }
+                done.push(doc.title);
+            }
+        }
+        catch (error) {
+            const why = error instanceof Error && error.message ? error.message : 'Errore imprevisto';
+            const message = `${why}${done.length ? ` (già uscite: ${done.join(', ')})` : ''}`;
+            await releases.finish(release.id, 'failed', message);
+            await note('release.failed', release.name, { id: release.id, message });
+            return false;
+        }
+        await releases.finish(release.id, 'published');
+        await note('release.published', release.name, { id: release.id, items: release.items.length });
+        return true;
+    };
+    /** A release as the panel shows it: each document with its title, state and what stops it. */
+    const releaseJson = async (release) => {
+        const problems = release.status === 'published' ? [] : await releaseProblems(release);
+        const items = [];
+        for (const item of release.items) {
+            const doc = await content.get(item.documentId);
+            if (!doc)
+                continue;
+            items.push({
+                ...item,
+                title: doc.title,
+                collection: doc.collection,
+                locale: doc.locale,
+                status: doc.status,
+                problem: problems.find((p) => p.documentId === doc.id)?.message ?? null,
+            });
+        }
+        return { ...release, items, ready: problems.length === 0 };
+    };
+    const loadRelease = async (id) => {
+        const release = await releases.get(id);
+        if (!release)
+            throw new ApiError(404, 'not_found', 'Questo rilascio non esiste');
+        return release;
+    };
+    const openRelease = async (id) => {
+        const release = await loadRelease(id);
+        if (release.status === 'published' || release.status === 'cancelled')
+            throw new ApiError(409, 'release_closed', 'Questo rilascio è già uscito o è stato annullato');
+        return release;
+    };
+    app.get('/api/releases', requireUser, async (c) => {
+        const { active, done } = await releases.list();
+        return c.json({
+            releases: await Promise.all(active.map(releaseJson)),
+            published: await Promise.all(done.map(releaseJson)),
+        });
+    });
+    app.post('/api/releases', requireUser, async (c) => {
+        const input = await body(c, z.object({ name: z.string().trim().min(1).max(120) }));
+        const release = await releases.create(input.name, c.get('user'));
+        await record(c, 'release.created', release.name, { id: release.id });
+        return c.json(await releaseJson(release), 201);
+    });
+    app.get('/api/releases/:id', requireUser, async (c) => c.json(await releaseJson(await loadRelease(c.req.param('id')))));
+    app.patch('/api/releases/:id', requireUser, async (c) => {
+        const release = await openRelease(c.req.param('id'));
+        const input = await body(c, z.object({ name: z.string().trim().min(1).max(120) }));
+        await releases.rename(release.id, input.name);
+        return c.json(await releaseJson(await loadRelease(release.id)));
+    });
+    /** Cancels a release: its documents stay as they are. */
+    app.delete('/api/releases/:id', requireUser, async (c) => {
+        const release = await openRelease(c.req.param('id'));
+        await releases.finish(release.id, 'cancelled');
+        await record(c, 'release.cancelled', release.name, { id: release.id });
+        return c.body(null, 204);
+    });
+    /** Adds a document (or changes what happens to it): it leaves any other release. */
+    app.put('/api/releases/:id/items/:documentId', requireUser, async (c) => {
+        const release = await openRelease(c.req.param('id'));
+        const doc = await loadDocument(c.req.param('documentId'));
+        const input = await body(c, z.object({ action: z.enum(['publish', 'unpublish']).default('publish') }));
+        if (input.action === 'unpublish' && !doc.publishedAt)
+            throw new ApiError(409, 'not_published', 'La pagina non è sul sito: non c’è niente da togliere');
+        await releases.put(release.id, doc.id, input.action);
+        await record(c, 'release.item_added', doc.title, { id: release.id, release: release.name, action: input.action });
+        return c.json(await releaseJson(await loadRelease(release.id)));
+    });
+    app.delete('/api/releases/:id/items/:documentId', requireUser, async (c) => {
+        const release = await openRelease(c.req.param('id'));
+        await releases.remove(release.id, c.req.param('documentId'));
+        return c.json(await releaseJson(await loadRelease(release.id)));
+    });
+    /** Everything in the release goes on the site now, or nothing does (the reasons come back). */
+    app.post('/api/releases/:id/publish', requireUser, async (c) => {
+        const release = await openRelease(c.req.param('id'));
+        const problems = await releaseProblems(release);
+        if (problems.length)
+            return c.json({
+                error: {
+                    code: 'release_not_ready',
+                    message: 'Alcune pagine non sono pronte: non è uscito niente',
+                    problems,
+                },
+            }, 422);
+        const user = c.get('user');
+        const ok = await releaseOut(release, user);
+        const after = await loadRelease(release.id);
+        if (!ok)
+            throw new ApiError(422, 'release_failed', after.error ?? 'Il rilascio non è uscito');
+        return c.json(await releaseJson(after));
+    });
+    /** When the release goes out by itself; at null: only by hand. Checked now, and again at that moment. */
+    app.put('/api/releases/:id/schedule', requireUser, async (c) => {
+        const release = await openRelease(c.req.param('id'));
+        const input = await body(c, z.object({ at: z.iso.datetime({ offset: true }).nullable() }));
+        const user = c.get('user');
+        if (input.at === null) {
+            await releases.schedule(release.id, null, null);
+            await record(c, 'release.schedule_cancelled', release.name, { id: release.id });
+            return c.json(await releaseJson(await loadRelease(release.id)));
+        }
+        const at = new Date(input.at);
+        if (at.getTime() <= Date.now() + 30_000)
+            throw new ApiError(400, 'past_time', 'Scegli un momento nel futuro, almeno tra un minuto');
+        if (!release.items.length)
+            throw new ApiError(400, 'empty_release', 'Aggiungi prima qualcosa al rilascio');
+        await releases.schedule(release.id, at, user);
+        await record(c, 'release.scheduled', release.name, { id: release.id, at: at.toISOString() });
+        return c.json(await releaseJson(await loadRelease(release.id)));
+    });
+    // ---------- shared preview links ----------
+    const previewJson = (c, link) => {
+        const path = `/_materialize/share/${link.token}`;
+        return { ...link, path, url: new URL(path, publicOrigin(c)).toString() };
+    };
+    /** The links that still work for a document, newest first. */
+    app.get('/api/documents/:id/previews', requireUser, async (c) => {
+        const existing = await loadDocument(c.req.param('id'));
+        return c.json({ items: (await previewLinks.forDocument(existing.id)).map((l) => previewJson(c, l)) });
+    });
+    /**
+     * A secret address that shows the latest saved draft with the site's own design, to people
+     * without an account: a client, a colleague. `days` null: until someone revokes it.
+     */
+    app.post('/api/documents/:id/previews', requireUser, async (c) => {
+        const existing = await loadDocument(c.req.param('id'));
+        const input = await body(c, z.object({ days: z.number().int().min(1).max(365).nullable() }));
+        if (!ctx.preview)
+            throw new ApiError(409, 'no_site', 'Questo sito non ha pagine da mostrare in anteprima');
+        if (!collection(existing.collection).url)
+            throw new ApiError(400, 'no_page', 'Questo contenuto non ha una pagina sul sito');
+        const expiresAt = input.days === null ? null : new Date(Date.now() + input.days * 86_400_000);
+        const link = await previewLinks.create({ documentId: existing.id, expiresAt, user: c.get('user') });
+        await record(c, 'document.preview_shared', existing.title, {
+            collection: existing.collection,
+            id: existing.id,
+            expiresAt: expiresAt?.toISOString() ?? null,
+        });
+        return c.json(previewJson(c, link), 201);
+    });
+    app.delete('/api/previews/:id', requireUser, async (c) => {
+        const link = await previewLinks.get(c.req.param('id'));
+        if (!link)
+            throw new ApiError(404, 'not_found', 'Link non trovato');
+        const doc = await content.get(link.documentId);
+        await previewLinks.revoke(link.id);
+        await record(c, 'document.preview_revoked', doc?.title ?? '', { id: link.documentId });
+        return c.body(null, 204);
+    });
+    void previewLinks.prune().catch(() => { });
     app.delete('/api/documents/:id', requireUser, requireAdmin, async (c) => {
         const existing = await loadDocument(c.req.param('id'));
         await content.remove(existing.id);
+        await schedules.removeForDocument(existing.id);
+        await releases.removeDocument(existing.id);
+        await previewLinks.removeForDocument(existing.id);
         if (existing.publishedAt)
-            ctx.onPublish?.();
+            sitePublished();
         await record(c, 'document.deleted', existing.title, { collection: existing.collection });
         return c.body(null, 204);
     });
@@ -2321,7 +3302,7 @@ When done, say in one or two short sentences what you changed. Reply in the pers
         if (!doc)
             throw new ApiError(404, 'not_found', 'This version does not exist');
         await record(c, 'document.restored', doc.title, { collection: doc.collection, id: doc.id });
-        return c.json(toJson(doc));
+        return c.json(await toJson(doc));
     });
     // ---------- languages and translations ----------
     /** How many documents each language has: removing a language hides them from the site. */
@@ -2346,7 +3327,7 @@ When done, say in one or two short sentences what you changed. Reply in the pers
         const value = { default: input.default, available: [...new Set(input.available)] };
         await settings.set('locales', value, c.get('user').id);
         languages = value;
-        ctx.onPublish?.();
+        sitePublished();
         await record(c, 'settings.languages', value.available.join(', '));
         return c.json({ locales: ctx.config().locales, documents: await countsByLocale() });
     });
@@ -2368,7 +3349,7 @@ When done, say in one or two short sentences what you changed. Reply in the pers
             slots = only(slots);
         if (!slots.length)
             return;
-        const translated = await translateTexts(ai, slots.map((s) => s.text), from, to).catch(aiFailed);
+        const translated = await translateTexts(ai, slots.map((s) => s.text), from, to, undefined, await voiceText('style')).catch(aiFailed);
         for (const [i, slot] of slots.entries())
             slot.set(translated[i]);
     };
@@ -2409,7 +3390,7 @@ When done, say in one or two short sentences what you changed. Reply in the pers
             sourceId: original?.id ?? doc.id,
         }));
         await record(c, 'document.translated', created.title, { locale: lang, id: created.id, ai: input.translate });
-        return c.json(toJson(created), 201);
+        return c.json(await toJson(created), 201);
     });
     /**
      * Brings a translation in line with its original: the original's structure and design, with the
@@ -2445,7 +3426,7 @@ When done, say in one or two short sentences what you changed. Reply in the pers
                 const own = nodeSlots(walk(data[name]));
                 if (!own.length)
                     continue;
-                const translated = await translateTexts(ai, own.map((s) => s.text), original.locale, doc.locale).catch(aiFailed);
+                const translated = await translateTexts(ai, own.map((s) => s.text), original.locale, doc.locale, undefined, await voiceText('style')).catch(aiFailed);
                 for (const [i, slot] of own.entries())
                     slot.set(translated[i]);
             }
@@ -2455,7 +3436,7 @@ When done, say in one or two short sentences what you changed. Reply in the pers
                 await guardDesign(c.get('user'), doc.data[name], data[name]);
         const draft = draftData(def, data);
         const saved = await slugGuard(() => content.update(doc.id, { ...draft, userId: c.get('user').id }));
-        return c.json({ document: toJson(saved), added: fresh.size });
+        return c.json({ document: await toJson(saved), added: fresh.size });
     });
     // ---------- importing a WordPress site ----------
     /** Some hosts turn away requests that do not say who they are. */
@@ -2551,6 +3532,60 @@ When done, say in one or two short sentences what you changed. Reply in the pers
             ])),
         });
     });
+    /** The caller's credentials, for tools that go through the API as them. */
+    const credentialsOf = (c) => {
+        const authorization = c.req.header('authorization');
+        const cookie = c.req.header('cookie');
+        return authorization ? { authorization } : cookie ? { cookie } : {};
+    };
+    /**
+     * An imported page laid out again by the AI with the section library, in its draft. The texts
+     * and images must stay the same (checked after): otherwise the page is left as it was.
+     */
+    const relayoutPage = async (ai, id, user, credentials) => {
+        const doc = await content.get(id);
+        if (!doc)
+            return 'la pagina non c’è più';
+        const def = collection(doc.collection);
+        const field = Object.entries(def.fields).find(([, f]) => f.kind === 'page')?.[0];
+        const before = field && Array.isArray(doc.data[field]) ? doc.data[field] : null;
+        if (!field || !before?.length)
+            return 'la pagina è vuota';
+        const page = { nodes: before };
+        const call = apiCaller(app.fetch, credentials);
+        const getSchema = () => call('GET', '/api/schema');
+        const tools = [
+            ...contentTools(call, getSchema).filter((t) => ['list_library', 'get_theme'].includes(t.name)),
+            ...pageTools({
+                withId: false,
+                brand: async () => ctx.config().site.name,
+                source: async () => ({
+                    load: async () => page.nodes,
+                    save: async (nodes) => {
+                        page.nodes = nodes;
+                    },
+                }),
+            }),
+        ];
+        const system = `You redesign one page of the website "${ctx.config().site.name}", just imported from WordPress into Materialize. Its content arrived as a plain column of texts, images and buttons, one section per heading. Rebuild it so it looks designed, with the section library.
+
+How: read the page (get_page) and the library (list_library); replace the plain sections with library sections (edit_page: add_section, then fill them; remove what you replace and the library sample nodes you do not use); read the page again at the end and fix what is left.
+
+Rules:
+- Keep every text word for word: you may split it across sections, change its style (title, body, eyebrow) or turn a list into cards, but do not rewrite, shorten or translate it.
+- Keep every image (same src and alt) and every button with its link.
+- Add no text of your own: no new headings, slogans, labels or facts. Library sample texts and pictures you do not replace with the page's own content must be removed.
+- Do not add a menu or a footer: the site has its own.
+- Keep it simple: a clear opening, then sections that follow the page's order.
+When done, reply with one short sentence.`;
+        await runTurn(ai, { provider: ai.provider, messages: [] }, { system, text: `Lay out the page "${doc.title}".`, tools, onEvent: () => { }, maxSteps: 30 });
+        const problem = relayoutProblem(before, page.nodes);
+        if (problem)
+            return problem;
+        const draft = draftData(def, { ...doc.data, [field]: restoreAlts(before, page.nodes).map(plain) });
+        await content.update(doc.id, { ...draft, userId: user.id });
+        return null;
+    };
     app.post('/api/import/wordpress/run', requireUser, requireSession, requireAdmin, async (c) => {
         const target = z.object({ collection: z.string(), fields: z.record(z.string(), z.string()) }).nullable();
         const input = await body(c, z.object({
@@ -2563,9 +3598,11 @@ When done, say in one or two short sentences what you changed. Reply in the pers
                 locale: z.string().optional(),
                 categories: z.record(z.string(), z.string()).optional(),
                 fallbackCategory: z.string().optional(),
+                aiLayout: z.boolean().optional(),
             }),
         }));
         const held = wpSites.get(input.token);
+        const ai = input.plan.aiLayout ? await readyAi() : null;
         if (!held)
             throw new ApiError(409, 'import_expired', 'Read the site again');
         const lang = locale(input.plan.locale);
@@ -2584,6 +3621,7 @@ When done, say in one or two short sentences what you changed. Reply in the pers
             problems: [],
             media: { downloaded: 0, failed: 0, reasons: {} },
             redirects: 0,
+            relaid: 0,
             at: Date.now(),
         };
         wpJobs.set(id, job);
@@ -2674,18 +3712,24 @@ When done, say in one or two short sentences what you changed. Reply in the pers
                 return list.length - before;
             },
             onProgress: (p) => Object.assign(job, p),
+            relayout: ai ? (doc) => relayoutPage(ai, doc.id, user, credentialsOf(c)) : undefined,
         };
         void runImport(held.site, plan, deps)
             .then(async (result) => {
             await settings.set('imports:media', known, user.id);
             if (result.created.some((d) => d.published) || result.redirects)
-                ctx.onPublish?.();
+                sitePublished();
             await activityLog.record({
                 userId: user.id,
                 userName: user.name,
                 action: 'import.wordpress',
                 target: held.site.name,
-                detail: { created: result.created.length, media: result.media.downloaded, redirects: result.redirects },
+                detail: {
+                    created: result.created.length,
+                    media: result.media.downloaded,
+                    redirects: result.redirects,
+                    ...(result.relaid ? { relaid: result.relaid } : {}),
+                },
                 ip: null,
             });
         })
@@ -2866,5 +3910,6 @@ When done, say in one or two short sentences what you changed. Reply in the pers
             throw new ApiError(404, 'not_found', 'This page is not published');
         return c.json(publicDocument(doc));
     });
-    return app;
+    // runSchedules: for the tests, which cannot wait for the clock.
+    return Object.assign(app, { runSchedules });
 }