@materializecms/server 0.5.0 → 0.7.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 { expandComponents, expandGlobals, formDefinition, normalizeTheme, sameDesign, walk, } from '@materializecms/core/page';
-import { addMove, normalizePath } from '@materializecms/core/seo';
+import { expandComponents, expandGlobals, formDefinition, normalizeTheme, richTextHtml, sameDesign, walk, } from '@materializecms/core/page';
+import { addMove, feedCollections, 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, createPreviewLinkStore, createScheduleStore, createSettingsStore, createSubmissionStore, EmailTakenError, SlugTakenError, } from '@materializecms/db';
+import { VOICE_TONES, voicePrompt } from '@materializecms/core/voice';
+import { createActivityStore, createAuthStore, createCommentStore, createContentStore, createMediaStore, createNewsletterStore, 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,22 +25,25 @@ 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';
+import { confirmEmail, langOf, linkSignature, newsletterHtml, newsletterText, PIXEL, parseSubscribersCsv, validLink, } from './newsletter.js';
 import { DEFAULT_OFFSITE, newRecoveryKey, runOffsite, testOffsite, } from './offsite.js';
 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';
@@ -190,6 +194,8 @@ export function createApp(base) {
     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 newsletter = createNewsletterStore(ctx.database.db);
     const previewLinks = createPreviewLinkStore(ctx.database.db);
     const backups = createBackups(ctx.database, () => ctx.config().media.dir);
     const backupSettings = async () => ({
@@ -461,6 +467,12 @@ export function createApp(base) {
             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),
         };
     };
     /**
@@ -494,7 +506,9 @@ export function createApp(base) {
     app.use('*', secureHeaders());
     // Requests with a bearer token carry no cookie, so a forged form cannot ride on them.
     const checkOrigin = csrf();
-    app.use('/api/*', (c, next) => (bearerOf(c) ? next() : checkOrigin(c, next)));
+    app.use('/api/*', (c, next) => 
+    // Leaving the newsletter with one click from the email app comes with no Origin: the token is the proof.
+    bearerOf(c) || c.req.path.startsWith('/api/newsletter/unsubscribe/') ? next() : checkOrigin(c, next));
     // Answers change with every edit: browsers must not reuse them.
     app.use('/api/*', async (c, next) => {
         await next();
@@ -888,7 +902,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.', 'newsletter.', 'import.', 'media.', 'message.'],
         settings: ['settings.', 'backup.', 'update.'],
     };
     app.get('/api/activity', requireUser, requireAdmin, async (c) => {
@@ -1347,7 +1361,11 @@ export function createApp(base) {
         return c.json({ ok: true });
     });
     app.patch('/api/auth/me', requireUser, async (c) => {
-        const input = await body(c, z.object({ name: z.string().trim().min(1).max(80) }));
+        const input = await body(c, z.object({
+            name: z.string().trim().min(1).max(80).optional(),
+            /** The panel's language; null: follow the browser. */
+            locale: z.enum(['it', 'en']).nullable().optional(),
+        }));
         return c.json({ user: await auth.updateUser(c.get('user').id, input) });
     });
     /** A changed sign-in address: the old one is told, in case it was not its owner who changed it. */
@@ -1826,6 +1844,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.',
@@ -1854,8 +2069,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;
@@ -1948,8 +2167,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 = {};
@@ -1964,7 +2187,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.
@@ -1982,7 +2205,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({
@@ -2005,6 +2228,195 @@ When done, say in one or two short sentences what you changed. Reply in the pers
             }
         });
     });
+    // 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
@@ -2081,6 +2493,12 @@ When done, say in one or two short sentences what you changed. Reply in the pers
         const fingerprint = fingerprintOf(form, data);
         const spam = spamReason(data, elapsed) ??
             ((await submissions.seen(fingerprint, new Date(Date.now() - 86_400_000))) ? 'Messaggio ripetuto' : null);
+        // A signup form: no message, a subscriber waiting to confirm. Spam gets the same answer.
+        if (def?.newsletter) {
+            if (!spam)
+                await signUp(c, def, data, page);
+            return wantsJson ? c.json({ ok: true }) : c.redirect(`${back}#inviato`, 303);
+        }
         const formName = def?.name?.trim() || def?.subject?.trim() || '';
         const saved = await submissions.add({ form, formName, page, data, spam, fingerprint });
         if (files.length)
@@ -2563,6 +2981,17 @@ When done, say in one or two short sentences what you changed. Reply in the pers
         });
         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
@@ -2593,14 +3022,9 @@ When done, say in one or two short sentences what you changed. Reply in the pers
                 }
                 try {
                     if (item.action === 'publish') {
-                        const def = ctx.config().collections.find((x) => x.name === existing.collection);
-                        const check = def ? validate(def, prepare(def, existing.data)) : null;
-                        if (!def || !check?.ok) {
-                            const fields = def && check && !check.ok
-                                ? [...new Set(check.issues.map((i) => def.fields[i.path.split('.')[0] ?? '']?.label ?? i.path))].join(', ')
-                                : '';
-                            throw new Error(def ? `Alcuni campi vanno completati${fields ? `: ${fields}` : ''}` : 'La raccolta non esiste più');
-                        }
+                        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 });
@@ -2623,6 +3047,11 @@ When done, say in one or two short sentences what you changed. Reply in the pers
                     });
                 }
             }
+            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);
@@ -2648,6 +3077,677 @@ When done, say in one or two short sentences what you changed. Reply in the pers
             }),
         });
     });
+    /** 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)));
+    });
+    // ---------- newsletter ----------
+    const escapeHtml = (v) => v.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+    const newsletterSettings = async () => (await settings.get('newsletter')) ?? {};
+    /** The secret that signs tracked links, made the first time it is needed. */
+    const newsletterSecret = async () => {
+        const found = await settings.get('newsletter:secret');
+        if (found)
+            return found;
+        const secret = randomBytes(24).toString('base64url');
+        await settings.set('newsletter:secret', secret);
+        return secret;
+    };
+    /** Where links in newsletters point: the site's address, or the one last used in the panel. */
+    const newsletterOrigin = async (c) => {
+        if (c) {
+            const origin = publicOrigin(c);
+            const current = await newsletterSettings();
+            if (current.origin !== origin)
+                await settings.set('newsletter', { ...current, origin });
+            return origin;
+        }
+        const site = ctx.config().site.url;
+        try {
+            if (site)
+                return new URL(site).origin;
+        }
+        catch { }
+        return (await newsletterSettings()).origin ?? 'http://localhost:4321';
+    };
+    const accentColor = async () => normalizeTheme(await settings.get('theme')).colors.light.accent;
+    const allowSignup = createLimiter(5, 60_000);
+    /** A signup from a form: the email field, a name if there is one, and the confirmation email. */
+    const signUp = async (c, def, data, page) => {
+        const field = def.fields.find((f) => f.kind === 'email') ?? def.fields.find((f) => /mail/i.test(f.name));
+        const email = (field ? data[field.name] : '')?.trim().toLowerCase() ?? '';
+        if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email))
+            return;
+        if (!allowSignup(`${clientIp(c)}:newsletter`))
+            return;
+        const nameField = def.fields.find((f) => f.kind !== 'email' && /^(nome|name|first.?name)$/i.test(f.name));
+        const { subscriber, confirm } = await newsletter.subscribe({
+            email,
+            name: nameField ? data[nameField.name] : '',
+            locale: langOf(c.req.header('accept-language')),
+            source: page || def.name || def.id,
+        });
+        if (!confirm)
+            return;
+        const mail = await settings.get('mail');
+        if (!isConfigured(mail)) {
+            console.warn('Materialize: a newsletter signup waits for confirmation, but email is not set up');
+            return;
+        }
+        const url = `${await newsletterOrigin()}/api/newsletter/confirm/${subscriber.token}`;
+        const message = confirmEmail({
+            site: ctx.config().site.name,
+            url,
+            accent: await accentColor(),
+            locale: subscriber.locale,
+        });
+        await sendMail(mail, { to: email, ...message }).catch((error) => console.error('Materialize: confirmation email not sent', error));
+    };
+    /** A small page for people coming from an email link: no panel, the site's name and a sentence. */
+    const notice = (c, lang, title, text, form) => c.html(`<!doctype html><html lang="${lang}"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta name="robots" content="noindex"><title>${escapeHtml(title)}</title>
+<style>body{margin:0;min-height:100vh;display:grid;place-items:center;background:#f4f4f5;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Helvetica,Arial,sans-serif;color:#18181b}main{max-width:420px;margin:24px;padding:32px;background:#fff;border-radius:14px;box-shadow:0 1px 3px rgba(0,0,0,.08)}h1{margin:0 0 10px;font-size:22px}p{margin:0 0 16px;line-height:1.6;color:#52525b}button{padding:11px 18px;border:0;border-radius:8px;background:#18181b;color:#fff;font:inherit;font-weight:600;cursor:pointer}a{color:inherit}</style></head>
+<body><main><p style="font-weight:700;color:#18181b">${escapeHtml(ctx.config().site.name)}</p><h1>${escapeHtml(title)}</h1><p>${escapeHtml(text)}</p>${form ?? ''}<p><a href="/">${lang === 'it' ? 'Vai al sito' : 'Go to the site'}</a></p></main></body></html>`);
+    app.get('/api/newsletter/confirm/:token', async (c) => {
+        const lang = langOf(c.req.header('accept-language'));
+        const found = await newsletter.confirm(c.req.param('token'));
+        if (!found)
+            return notice(c, lang, lang === 'it' ? 'Link non valido' : 'Link not valid', lang === 'it'
+                ? 'Questo link non funziona più. Iscriviti di nuovo dal sito, se vuoi ricevere la newsletter.'
+                : 'This link no longer works. Sign up again on the site if you want the newsletter.');
+        return notice(c, langOf(found.locale), langOf(found.locale) === 'it' ? 'Iscrizione confermata' : 'Subscription confirmed', langOf(found.locale) === 'it'
+            ? `Da ora riceverai la newsletter di ${ctx.config().site.name} a ${found.email}. Puoi disiscriverti quando vuoi, dal link in fondo a ogni email.`
+            : `From now on you will get the ${ctx.config().site.name} newsletter at ${found.email}. You can unsubscribe whenever you like, from the link at the bottom of every email.`);
+    });
+    // A page with a button, so that link scanners opening the address do not unsubscribe anyone;
+    // email apps' one-click unsubscribe posts to the same address (RFC 8058).
+    app.get('/api/newsletter/unsubscribe/:token', async (c) => {
+        const found = await newsletter.byToken(c.req.param('token'));
+        const lang = langOf(found?.locale ?? c.req.header('accept-language'));
+        if (!found)
+            return notice(c, lang, lang === 'it' ? 'Link non valido' : 'Link not valid', lang === 'it' ? 'Questo link non funziona.' : 'This link does not work.');
+        if (found.status === 'unsubscribed')
+            return notice(c, lang, lang === 'it' ? 'Sei già disiscritto' : 'You are already unsubscribed', lang === 'it'
+                ? `${found.email} non riceve più la newsletter.`
+                : `${found.email} no longer gets the newsletter.`);
+        const send = c.req.query('s') ?? '';
+        return notice(c, lang, lang === 'it' ? 'Disiscriviti dalla newsletter' : 'Unsubscribe from the newsletter', lang === 'it'
+            ? `${found.email} non riceverà più la newsletter di ${ctx.config().site.name}.`
+            : `${found.email} will no longer get the ${ctx.config().site.name} newsletter.`, `<form method="post"><input type="hidden" name="s" value="${escapeHtml(send)}"><p><button type="submit">${lang === 'it' ? 'Disiscrivimi' : 'Unsubscribe me'}</button></p></form>`);
+    });
+    app.post('/api/newsletter/unsubscribe/:token', async (c) => {
+        const found = await newsletter.byToken(c.req.param('token'));
+        const lang = langOf(found?.locale ?? c.req.header('accept-language'));
+        if (!found)
+            return notice(c, lang, lang === 'it' ? 'Link non valido' : 'Link not valid', '');
+        const form = (await c.req.parseBody().catch(() => ({})));
+        const send = typeof form.s === 'string' ? form.s : (c.req.query('s') ?? '');
+        if (found.status !== 'unsubscribed') {
+            await newsletter.unsubscribe(found.id);
+            const sent = send ? await newsletter.send(send) : null;
+            if (sent && sent.subscriberId === found.id)
+                await newsletter.track(sent.id, 'unsubscribe');
+        }
+        return notice(c, lang, lang === 'it' ? 'Fatto: sei disiscritto' : 'Done: you are unsubscribed', lang === 'it'
+            ? 'Non riceverai più la newsletter. Se cambi idea, puoi iscriverti di nuovo dal sito.'
+            : 'You will not get the newsletter any more. If you change your mind, you can sign up again on the site.');
+    });
+    /** Statistics: the picture that tells the email was opened. */
+    app.get('/api/newsletter/o/:send', async (c) => {
+        const id = c.req.param('send').replace(/\.gif$/, '');
+        if ((await newsletterSettings()).tracking !== false && (await newsletter.send(id)))
+            await newsletter.track(id, 'open');
+        return c.body(new Uint8Array(PIXEL), 200, { 'content-type': 'image/gif', 'cache-control': 'no-store' });
+    });
+    /** Statistics: a link followed, then on to where it points (only addresses this site signed). */
+    app.get('/api/newsletter/c/:send', async (c) => {
+        const id = c.req.param('send');
+        const url = c.req.query('u') ?? '';
+        if (!/^https?:\/\//i.test(url) || !validLink(id, url, c.req.query('s') ?? '', await newsletterSecret()))
+            return c.text('Link not valid', 400);
+        if (await newsletter.send(id))
+            await newsletter.track(id, 'click');
+        return c.redirect(url, 302);
+    });
+    // ----- panel: subscribers -----
+    app.get('/api/subscribers', requireUser, async (c) => {
+        const status = c.req.query('status');
+        return c.json(await newsletter.subscribers({
+            status: status === 'pending' || status === 'active' || status === 'unsubscribed' ? status : undefined,
+            search: c.req.query('search') || undefined,
+            limit: Math.min(200, Number(c.req.query('limit') ?? 50)),
+            offset: Number(c.req.query('offset') ?? 0),
+        }));
+    });
+    /** Someone added by hand gets the confirmation email too: consent is theirs to give. */
+    app.post('/api/subscribers', requireUser, requireAdmin, async (c) => {
+        const input = await body(c, z.object({ email: z.email(), name: z.string().trim().max(120).optional() }));
+        const { subscriber, confirm } = await newsletter.subscribe({ ...input, source: 'panel', locale: null });
+        let mailed = false;
+        if (confirm) {
+            const mail = await settings.get('mail');
+            if (isConfigured(mail)) {
+                const url = `${await newsletterOrigin(c)}/api/newsletter/confirm/${subscriber.token}`;
+                await sendMail(mail, {
+                    to: subscriber.email,
+                    ...confirmEmail({
+                        site: ctx.config().site.name,
+                        url,
+                        accent: await accentColor(),
+                        locale: ctx.config().locales.default,
+                    }),
+                });
+                mailed = true;
+            }
+        }
+        await record(c, 'newsletter.subscriber_added', subscriber.email);
+        return c.json({ subscriber, mailed }, 201);
+    });
+    app.delete('/api/subscribers/:id', requireUser, requireAdmin, async (c) => {
+        const found = await newsletter.subscriber(c.req.param('id'));
+        if (!found)
+            throw new ApiError(404, 'not_found', 'Questo iscritto non esiste');
+        await newsletter.removeSubscriber(found.id);
+        await record(c, 'newsletter.subscriber_removed', found.email);
+        return c.body(null, 204);
+    });
+    app.post('/api/subscribers/import', requireUser, requireAdmin, async (c) => {
+        const input = await body(c, z.object({ csv: z.string().max(5_000_000) }));
+        const rows = parseSubscribersCsv(input.csv);
+        if (!rows.length)
+            throw new ApiError(422, 'no_addresses', 'Nel file non ho trovato indirizzi email');
+        const result = await newsletter.importMany(rows);
+        await record(c, 'newsletter.imported', '', result);
+        return c.json({ found: rows.length, ...result });
+    });
+    app.get('/api/subscribers/export.csv', requireUser, requireAdmin, async (c) => {
+        const cell = (v) => {
+            const safe = /^[=+\-@\t\r]/.test(v) ? `'${v}` : v;
+            return /[",;\n]/.test(safe) ? `"${safe.replace(/"/g, '""')}"` : safe;
+        };
+        const rows = (await newsletter.allSubscribers()).map((s) => [
+            s.email,
+            s.name,
+            s.status,
+            s.source,
+            s.createdAt.toISOString(),
+            s.confirmedAt?.toISOString() ?? '',
+            s.unsubscribedAt?.toISOString() ?? '',
+        ]
+            .map(cell)
+            .join(','));
+        const csv = `email,name,status,source,created,confirmed,unsubscribed\n${rows.join('\n')}\n`;
+        await record(c, 'newsletter.exported', '', { subscribers: rows.length });
+        return c.body(csv, 200, {
+            'content-type': 'text/csv; charset=utf-8',
+            'content-disposition': 'attachment; filename="iscritti.csv"',
+        });
+    });
+    app.get('/api/newsletter/settings', requireUser, async (c) => {
+        const s = await newsletterSettings();
+        return c.json({ footer: s.footer ?? '', tracking: s.tracking !== false });
+    });
+    app.put('/api/newsletter/settings', requireUser, requireAdmin, async (c) => {
+        const input = await body(c, z.object({ footer: z.string().max(1000), tracking: z.boolean() }));
+        await settings.set('newsletter', { ...(await newsletterSettings()), ...input });
+        await record(c, 'settings.newsletter');
+        return c.json(input);
+    });
+    // ----- panel: newsletters -----
+    const newsletterJson = async (n) => ({ ...n, stats: await newsletter.stats(n.id) });
+    const loadNewsletter = async (id) => {
+        const found = await newsletter.get(id);
+        if (!found)
+            throw new ApiError(404, 'not_found', 'Questa newsletter non esiste');
+        return found;
+    };
+    const editable = (n) => {
+        if (n.status === 'sending' || n.status === 'sent')
+            throw new ApiError(409, 'newsletter_sent', 'Questa newsletter è già partita: non si può più cambiare');
+    };
+    const newsletterBody = z.object({
+        subject: z.string().trim().min(1).max(200),
+        preheader: z.string().max(200).default(''),
+        body: z.array(z.record(z.string(), z.unknown())).max(2000).default([]),
+    });
+    app.get('/api/newsletters', requireUser, async (c) => c.json({ newsletters: await Promise.all((await newsletter.list()).map(newsletterJson)) }));
+    app.post('/api/newsletters', requireUser, async (c) => {
+        const input = await body(c, newsletterBody);
+        const created = await newsletter.create({ ...input, user: c.get('user') });
+        await record(c, 'newsletter.created', created.subject);
+        return c.json(await newsletterJson(created), 201);
+    });
+    app.get('/api/newsletters/:id', requireUser, async (c) => c.json(await newsletterJson(await loadNewsletter(c.req.param('id')))));
+    app.put('/api/newsletters/:id', requireUser, async (c) => {
+        const found = await loadNewsletter(c.req.param('id'));
+        editable(found);
+        const input = await body(c, newsletterBody);
+        await newsletter.update(found.id, input);
+        return c.json(await newsletterJson(await loadNewsletter(found.id)));
+    });
+    app.delete('/api/newsletters/:id', requireUser, async (c) => {
+        const found = await loadNewsletter(c.req.param('id'));
+        if (found.status === 'sending')
+            throw new ApiError(409, 'newsletter_sending', 'La newsletter sta partendo: aspetta che finisca');
+        await newsletter.remove(found.id);
+        await record(c, 'newsletter.deleted', found.subject);
+        return c.body(null, 204);
+    });
+    /** The email for one send: links, picture and unsubscribe address made for that person. */
+    const composeNewsletter = async (n, send) => {
+        const origin = await newsletterOrigin();
+        const s = await newsletterSettings();
+        const tracking = !!send && s.tracking !== false;
+        const secret = tracking ? await newsletterSecret() : '';
+        const unsubscribeUrl = send
+            ? `${origin}/api/newsletter/unsubscribe/${send.token}?s=${encodeURIComponent(send.id)}`
+            : `${origin}/api/newsletter/unsubscribe/prova`;
+        const content = {
+            site: ctx.config().site.name,
+            siteUrl: origin,
+            subject: n.subject,
+            preheader: n.preheader,
+            body: n.body,
+            accent: await accentColor(),
+            footer: s.footer ?? '',
+            unsubscribeUrl,
+            locale: send?.locale ?? ctx.config().locales.default,
+            ...(tracking && send
+                ? {
+                    openUrl: `${origin}/api/newsletter/o/${send.id}.gif`,
+                    link: (href) => `${origin}/api/newsletter/c/${send.id}?u=${encodeURIComponent(href)}&s=${linkSignature(send.id, href, secret)}`,
+                }
+                : {}),
+        };
+        return {
+            subject: n.subject,
+            html: newsletterHtml(content),
+            text: newsletterText(content),
+            headers: (send
+                ? { 'List-Unsubscribe': `<${unsubscribeUrl}>`, 'List-Unsubscribe-Post': 'List-Unsubscribe=One-Click' }
+                : {}),
+        };
+    };
+    const readyMail = async () => {
+        const mail = await settings.get('mail');
+        if (!isConfigured(mail))
+            throw new ApiError(400, 'mail_not_configured', 'Per inviare la newsletter serve l’email: Impostazioni → Email');
+        return mail;
+    };
+    /** A try, to the person writing it (or another address): nothing is counted. */
+    app.post('/api/newsletters/:id/test', requireUser, async (c) => {
+        const found = await loadNewsletter(c.req.param('id'));
+        const input = await body(c, z.object({ to: z.email().optional() }));
+        const mail = await readyMail();
+        await newsletterOrigin(c);
+        const message = await composeNewsletter(found, null);
+        await sendMail(mail, { to: input.to ?? c.get('user').email, ...message, subject: `[Prova] ${message.subject}` });
+        return c.json({ ok: true });
+    });
+    app.post('/api/newsletters/:id/send', requireUser, async (c) => {
+        const found = await loadNewsletter(c.req.param('id'));
+        editable(found);
+        await readyMail();
+        await newsletterOrigin(c);
+        const { counts } = await newsletter.subscribers({ limit: 1 });
+        if (!counts.active)
+            throw new ApiError(400, 'no_subscribers', 'Non ci sono ancora iscritti attivi');
+        await newsletter.setStatus(found.id, 'sending', { runAt: new Date(), error: null });
+        await record(c, 'newsletter.sent', found.subject, { subscribers: counts.active });
+        void runNewsletters();
+        return c.json(await newsletterJson(await loadNewsletter(found.id)));
+    });
+    app.put('/api/newsletters/:id/schedule', requireUser, async (c) => {
+        const found = await loadNewsletter(c.req.param('id'));
+        editable(found);
+        const input = await body(c, z.object({ at: z.iso.datetime({ offset: true }).nullable() }));
+        if (input.at === null) {
+            await newsletter.setStatus(found.id, 'draft', { runAt: null });
+            return c.json(await newsletterJson(await loadNewsletter(found.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');
+        await readyMail();
+        await newsletterOrigin(c);
+        await newsletter.setStatus(found.id, 'scheduled', { runAt: at, error: null });
+        await record(c, 'newsletter.scheduled', found.subject, { at: at.toISOString() });
+        return c.json(await newsletterJson(await loadNewsletter(found.id)));
+    });
+    /** An article becomes a newsletter: its title, its summary, its text and a link to read it on the site. */
+    app.post('/api/newsletters/from-document', requireUser, async (c) => {
+        const input = await body(c, z.object({ id: z.string() }));
+        const doc = await loadDocument(input.id);
+        const def = collection(doc.collection);
+        const data = (doc.publishedData ?? doc.data);
+        const fieldOf = (kind) => Object.entries(def.fields).find(([, f]) => f.kind === kind)?.[0];
+        const rich = fieldOf('richText');
+        const summary = Object.entries(def.fields).find(([n, f]) => f.kind === 'text' && /excerpt|summary|sommario|riassunto|descr/i.test(n))?.[0];
+        const seo = (fieldOf('seo') ? data[fieldOf('seo')] : null);
+        const preheader = (summary ? String(data[summary] ?? '') : '') || seo?.description || '';
+        const blocks = rich && Array.isArray(data[rich]) ? [...data[rich]] : [];
+        const url = (() => {
+            try {
+                return publicUrl(def, doc.locale, data);
+            }
+            catch {
+                return null;
+            }
+        })();
+        if (!blocks.length && preheader)
+            blocks.push({ type: 'paragraph', children: [{ text: preheader }] });
+        if (url)
+            blocks.push({
+                type: 'paragraph',
+                children: [
+                    { text: langOf(doc.locale) === 'it' ? 'Leggi sul sito →' : 'Read it on the site →', href: url, bold: true },
+                ],
+            });
+        const created = await newsletter.create({
+            subject: doc.title,
+            preheader: preheader.slice(0, 200),
+            body: blocks,
+            user: c.get('user'),
+        });
+        await record(c, 'newsletter.created', created.subject, { from: doc.id });
+        return c.json(await newsletterJson(created), 201);
+    });
+    /** A draft written by the AI from the latest articles, in the brand voice, with a link to each. */
+    app.post('/api/ai/newsletter', requireUser, async (c) => {
+        const input = await body(c, z.object({ count: z.number().int().min(1).max(10).default(3), note: z.string().max(1000).optional() }));
+        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 config = ctx.config();
+        const lang = config.locales.default;
+        const items = [];
+        for (const name of feedCollections(config.collections)) {
+            const def = collection(name);
+            for (const doc of await content.published(name)) {
+                if (doc.locale !== lang)
+                    continue;
+                const data = (doc.publishedData ?? {});
+                let url = null;
+                try {
+                    url = publicUrl(def, lang, data);
+                }
+                catch { }
+                if (!url)
+                    continue;
+                const text = Object.entries(def.fields)
+                    .filter(([, f]) => f.kind === 'text' || f.kind === 'richText')
+                    .map(([n]) => ((f) => (typeof f === 'string' ? f : Array.isArray(f) ? richTextHtml(f).replace(/<[^>]+>/g, ' ') : ''))(data[n]))
+                    .join('\n')
+                    .replace(/\s+/g, ' ')
+                    .slice(0, 2500);
+                items.push({ title: doc.title, url, text, date: (doc.publishedAt ?? doc.updatedAt).getTime() });
+            }
+        }
+        items.sort((a, b) => b.date - a.date);
+        const latest = items.slice(0, input.count);
+        if (!latest.length)
+            throw new ApiError(400, 'no_articles', 'Non ci sono ancora articoli pubblicati da raccontare');
+        const voice = await voiceText();
+        const system = `${voice ? `${voice}\n\n` : ''}You write the email newsletter of the website "${config.site.name}", in ${languageName(lang)}. You get its latest articles; write a short newsletter that makes people want to read them: a subject (at most 70 characters), a preheader (one sentence, at most 120 characters), an opening of one or two sentences, then for each article a heading with its title and two or three sentences on why it is worth reading, ending with a link to it. Use only facts from the articles. Reply with JSON only: {"subject": "...", "preheader": "...", "blocks": [{"type": "paragraph"|"heading", "text": "...", "link": {"text": "...", "href": "..."}?}]}.`;
+        const prompt = `${input.note ? `<note>${input.note}</note>\n` : ''}${latest.map((a) => `<article title="${a.title.replace(/"/g, "'")}" url="${a.url}">\n${a.text}\n</article>`).join('\n')}`;
+        const reply = await complete(ai, { system, prompt }).catch(aiFailed);
+        let parsed;
+        try {
+            parsed = JSON.parse(reply.replace(/^```(?:json)?\s*|\s*```$/g, ''));
+        }
+        catch {
+            throw new ApiError(422, 'ai_failed', 'La risposta dell’AI non era leggibile: riprova');
+        }
+        const known = new Set(latest.map((a) => a.url));
+        const blocks = [];
+        for (const b of parsed.blocks ?? []) {
+            const text = (b.text ?? '').trim();
+            const children = text ? [{ text }] : [];
+            if (b.link?.href && known.has(b.link.href) && b.link.text)
+                children.push({ text: `${text ? ' ' : ''}${b.link.text.trim()}`, href: b.link.href, bold: true });
+            if (!children.length)
+                continue;
+            blocks.push(b.type === 'heading' ? { type: 'heading', level: 2, children } : { type: 'paragraph', children });
+        }
+        const created = await newsletter.create({
+            subject: (parsed.subject ?? '').trim().slice(0, 200) || latest[0]?.title || config.site.name,
+            preheader: (parsed.preheader ?? '').trim().slice(0, 200),
+            body: blocks,
+            user,
+        });
+        await record(c, 'newsletter.created', created.subject, { ai: true });
+        return c.json(await newsletterJson(created), 201);
+    });
+    /**
+     * Sends what is due: scheduled newsletters whose time has come and those a stopped server left
+     * halfway. One email at a time, a short pause between them, so the email service keeps up.
+     */
+    let newslettersRunning = false;
+    const runNewsletters = async (now = new Date(), pause = 120) => {
+        if (newslettersRunning)
+            return 0;
+        newslettersRunning = true;
+        let sent = 0;
+        try {
+            for (const n of await newsletter.due(now)) {
+                const mail = await settings.get('mail');
+                if (!isConfigured(mail)) {
+                    await newsletter.setStatus(n.id, 'failed', { error: 'L’email non è configurata' });
+                    continue;
+                }
+                if (n.status === 'scheduled')
+                    await newsletter.setStatus(n.id, 'sending');
+                await newsletter.prepare(n.id);
+                for (;;) {
+                    const batch = await newsletter.pending(n.id, 50);
+                    if (!batch.length)
+                        break;
+                    for (const item of batch) {
+                        const who = await newsletter.subscriber(item.subscriberId);
+                        if (!who || who.status !== 'active') {
+                            await newsletter.markSend(item.id, 'failed', 'Non più iscritto');
+                            continue;
+                        }
+                        try {
+                            const message = await composeNewsletter(n, { id: item.id, token: who.token, locale: who.locale });
+                            await sendMail(mail, { to: who.email, ...message });
+                            await newsletter.markSend(item.id, 'sent');
+                            sent++;
+                        }
+                        catch (error) {
+                            await newsletter.markSend(item.id, 'failed', error instanceof Error ? error.message.slice(0, 300) : 'Errore');
+                        }
+                        if (pause)
+                            await new Promise((r) => setTimeout(r, pause));
+                    }
+                }
+                const stats = await newsletter.stats(n.id);
+                const allFailed = stats.total > 0 && stats.sent === 0;
+                await newsletter.setStatus(n.id, allFailed ? 'failed' : 'sent', {
+                    sentAt: new Date(),
+                    error: allFailed ? 'Nessun invio riuscito: controlla Impostazioni → Email' : null,
+                });
+            }
+            // Signups never confirmed are dropped after a week.
+            await newsletter.dropUnconfirmed(new Date(now.getTime() - 7 * 86_400_000));
+        }
+        catch (error) {
+            console.error('Materialize: newsletter sending failed', error);
+        }
+        finally {
+            newslettersRunning = false;
+        }
+        return sent;
+    };
+    setInterval(() => void runNewsletters(), 30_000).unref?.();
     // ---------- shared preview links ----------
     const previewJson = (c, link) => {
         const path = `/_materialize/share/${link.token}`;
@@ -2692,6 +3792,7 @@ When done, say in one or two short sentences what you changed. Reply in the pers
         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)
             sitePublished();
@@ -2761,7 +3862,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]);
     };
@@ -2838,7 +3939,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]);
             }
@@ -2944,6 +4045,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({
@@ -2956,9 +4111,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);
@@ -2977,6 +4134,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);
@@ -3067,6 +4225,7 @@ 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) => {
@@ -3078,7 +4237,12 @@ When done, say in one or two short sentences what you changed. Reply in the pers
                 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,
             });
         })
@@ -3260,5 +4424,5 @@ When done, say in one or two short sentences what you changed. Reply in the pers
         return c.json(publicDocument(doc));
     });
     // runSchedules: for the tests, which cannot wait for the clock.
-    return Object.assign(app, { runSchedules });
+    return Object.assign(app, { runSchedules, runNewsletters });
 }