@materializecms/server 0.5.0 → 0.6.0

package/src/app.js

@@ -13,7 +13,8 @@ import { expandComponents, expandGlobals, formDefinition, normalizeTheme, sameDe
 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, createPreviewLinkStore, createScheduleStore, 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,9 +25,10 @@ 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';
@@ -36,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';
@@ -190,6 +193,7 @@ 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 previewLinks = createPreviewLinkStore(ctx.database.db);
     const backups = createBackups(ctx.database, () => ctx.config().media.dir);
     const backupSettings = async () => ({
@@ -461,6 +465,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),
         };
     };
     /**
@@ -888,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) => {
@@ -1826,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.',
@@ -1854,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;
@@ -1948,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 = {};
@@ -1964,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.
@@ -1982,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({
@@ -2005,6 +2220,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
@@ -2563,6 +2967,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 +3008,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 +3033,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 +3063,178 @@ 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)));
+    });
     // ---------- shared preview links ----------
     const previewJson = (c, link) => {
         const path = `/_materialize/share/${link.token}`;
@@ -2692,6 +3279,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 +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]);
     };
@@ -2838,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]);
             }
@@ -2944,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({
@@ -2956,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);
@@ -2977,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);
@@ -3067,6 +3712,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 +3724,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,
             });
         })