wizards 0.5.12 → 0.6.0

package/apps/runtime/dist/model-errors.js

@@ -1,14 +1,21 @@
 import { noteText } from "@engenty-wizards/shared/run";
+import { serverText } from "./texts.js";
 /**
- * A failure the person reads, given as a note of `RUN_NOTES` where it has
- * one: a run shows it in the wizard's language, a response in the asker's, and the message keeps
- * the English line for the log. Free text has no note.
+ * A failure the person reads, given as a note of `RUN_NOTES` or a line of the server's table
+ * where it has one: a run shows it in the wizard's language, a response in the asker's, and the
+ * message keeps the English line for the log. Free text has neither.
  */
 export class NotedError extends Error {
     note;
+    line;
     constructor(said) {
-        super(typeof said === "string" ? said : noteText(said, "en"));
-        this.note = typeof said === "string" ? null : said;
+        super(typeof said === "string"
+            ? said
+            : "server" in said
+                ? serverText("en", said.server, said.params)
+                : noteText(said, "en"));
+        this.note = typeof said === "string" || "server" in said ? null : said;
+        this.line = typeof said !== "string" && "server" in said ? said : null;
     }
 }
 /** A class has nothing to run on: no key, no account, no installed client — the person can fix it in the settings. */
@@ -22,8 +29,14 @@ export function noteOf(err) {
 export function saidOf(err) {
     return noteOf(err) ?? err?.message ?? String(err);
 }
-/** A failure in a language: its note where it has one, else its message as it is. */
+/** A failure in a language: its note or server line where it has one, else its message as it is. */
 export function errorText(err, lang) {
     const note = noteOf(err);
-    return note ? noteText(note, lang) : (err?.message ?? String(err));
+    if (note) {
+        return noteText(note, lang);
+    }
+    if (err instanceof NotedError && err.line) {
+        return serverText(lang, err.line.server, err.line.params);
+    }
+    return err?.message ?? String(err);
 }

package/apps/runtime/dist/render/downloads.js

@@ -7,6 +7,7 @@ import { extFor, inlineAssetRefs, loadAsset, loadAssetText, saveAsset } from "..
 import { widgetMp4, widgetPdf, widgetPng } from "../widgets/render.js";
 import { allTables, firstTable, htmlToDocx, htmlToMarkdown, htmlToPdf, htmlToPng, jsonToMarkdown, MIME, markdownToHtml, tablesToXlsx, tableToCsv, } from "./convert.js";
 import { guardHtml } from "./guard.js";
+import { shapedCsvRows, shapedMarkdown, shapedTables } from "./shaped.js";
 export function slug(s) {
     return (s
         .toLowerCase()
@@ -155,8 +156,14 @@ export async function renderDownload(step, output, format, baseName) {
         }
         const text = output.text ?? "";
         if (step.output.format === "json") {
-            const rows = firstTable(output.json);
-            const tables = allTables(output.json);
+            // A step with a schema: its lists by their labels, the tree as headings.
+            const shape = step.output.schema;
+            const data = (output.json ?? {});
+            const rows = shape ? shapedCsvRows(shape, data) : firstTable(output.json);
+            const tables = shape ? shapedTables(shape, data) : allTables(output.json);
+            const md = shape
+                ? `# ${baseName}\n\n${shapedMarkdown(shape, data)}`
+                : jsonAsMarkdown(output.json);
             switch (format) {
                 case "json":
                     return {
@@ -171,7 +178,13 @@ export async function renderDownload(step, output, format, baseName) {
                         ? { data: await tablesToXlsx(tables), mime: MIME.xlsx, filename: file("xlsx") }
                         : null;
                 case "md":
-                    return { data: jsonAsMarkdown(output.json), mime: MIME.md, filename: file("md") };
+                    return { data: md, mime: MIME.md, filename: file("md") };
+                case "pdf":
+                    return {
+                        data: await htmlToPdf(markdownToHtml(md, baseName)),
+                        mime: MIME.pdf,
+                        filename: file("pdf"),
+                    };
                 default:
                     return null;
             }

package/apps/runtime/dist/render/shaped.js

@@ -0,0 +1,137 @@
+import { labelOf, titleKey, } from "@engenty-wizards/shared/shape";
+const isEntry = (v) => Boolean(v) && typeof v === "object" && !Array.isArray(v);
+/** A value that fits in a cell or a line: no lists of entries, no objects. */
+const flat = (s) => s.kind !== "object" && s.kind !== "table" && !(s.kind === "list" && s.of.kind === "object");
+/** An entry's title: its first short text. */
+function titleOf(shape, entry) {
+    const key = titleKey(shape);
+    return key ? String(entry[key] ?? "") : "";
+}
+/** A flat value as words. */
+function words(s, value, root, data) {
+    if (value === null || value === undefined) {
+        return "";
+    }
+    switch (s.kind) {
+        case "yesno":
+            return value ? (s.yes ?? "✓") : (s.no ?? "–");
+        case "number":
+            return `${value}${s.unit ? ` ${s.unit}` : ""}`;
+        case "ref": {
+            const target = root.fields[s.to];
+            const list = Array.isArray(data[s.to]) ? data[s.to] : [];
+            const hit = list.find((e) => isEntry(e) && e.id === value);
+            return target?.kind === "list" && target.of.kind === "object" && isEntry(hit)
+                ? titleOf(target.of, hit) || String(value)
+                : String(value);
+        }
+        case "list":
+            return Array.isArray(value) ? value.map((v) => words(s.of, v, root, data)).join(", ") : "";
+        default:
+            return typeof value === "object" ? JSON.stringify(value) : String(value);
+    }
+}
+/** One row of a sheet: flat values by label; a list of entries as their titles. */
+function rowOf(shape, entry, root, data) {
+    const row = {};
+    for (const [k, f] of Object.entries(shape.fields)) {
+        const v = entry[k];
+        if (f.kind === "list" && f.of.kind === "object") {
+            const of = f.of;
+            row[labelOf(k, f)] = Array.isArray(v)
+                ? v
+                    .map((e) => (isEntry(e) ? titleOf(of, e) : ""))
+                    .filter(Boolean)
+                    .join("; ")
+                : "";
+        }
+        else if (f.kind === "number" && typeof v === "number") {
+            row[labelOf(k, f)] = v;
+        }
+        else if (flat(f)) {
+            row[labelOf(k, f)] = words(f, v, root, data);
+        }
+    }
+    return row;
+}
+/** One sheet per top-level list, named by its label. */
+export function shapedTables(shape, data) {
+    const out = [];
+    for (const [k, f] of Object.entries(shape.fields)) {
+        const value = Array.isArray(data[k]) ? data[k] : [];
+        if (f.kind !== "list" || !value.length) {
+            continue;
+        }
+        const of = f.of;
+        const rows = of.kind === "object"
+            ? value.filter(isEntry).map((e) => rowOf(of, e, shape, data))
+            : value.map((v) => ({ [labelOf(k, f)]: words(of, v, shape, data) }));
+        out.push({ name: labelOf(k, f), rows });
+    }
+    return out;
+}
+/** The rows of the first top-level list whose entries are flat: what a CSV holds. */
+export function shapedCsvRows(shape, data) {
+    for (const [k, f] of Object.entries(shape.fields)) {
+        if (f.kind === "list" &&
+            f.of.kind === "object" &&
+            Object.values(f.of.fields).every(flat) &&
+            Array.isArray(data[k])) {
+            const of = f.of;
+            return data[k].filter(isEntry).map((e) => rowOf(of, e, shape, data));
+        }
+    }
+    return null;
+}
+const cellText = (v) => String(v ?? "")
+    .replace(/\|/g, "\\|")
+    .replace(/\n/g, " ");
+/** The tree as Markdown: a heading per part and per entry with lists of its own, tables for flat entries. */
+export function shapedMarkdown(shape, data) {
+    return objectMarkdown(shape, data, 2, shape, data);
+}
+const h = (n) => "#".repeat(Math.min(6, n));
+function objectMarkdown(shape, value, depth, root, data) {
+    const parts = [];
+    const short = [];
+    // An entry under its title as a heading says neither the title nor its id again.
+    const skip = shape === root ? [] : ["id", titleKey(shape)];
+    for (const [k, f] of Object.entries(shape.fields)) {
+        const v = value[k];
+        const label = labelOf(k, f);
+        if (v === undefined || v === null || v === "" || skip.includes(k)) {
+            continue;
+        }
+        if (f.kind === "text" && f.long) {
+            parts.push(`${h(depth)} ${label}\n\n${String(v)}`);
+        }
+        else if (f.kind === "list" && Array.isArray(v)) {
+            parts.push(`${h(depth)} ${label}\n\n${listMarkdown(f, v, depth + 1, root, data)}`);
+        }
+        else if (flat(f)) {
+            short.push(`**${label}:** ${words(f, v, root, data)}`);
+        }
+    }
+    return [short.join("  \n"), ...parts].filter(Boolean).join("\n\n");
+}
+function listMarkdown(f, value, depth, root, data) {
+    const of = f.of;
+    if (of.kind !== "object") {
+        return value.map((v) => `- ${words(of, v, root, data)}`).join("\n");
+    }
+    const entries = value.filter(isEntry);
+    if (Object.values(of.fields).every(flat)) {
+        const cols = Object.entries(of.fields);
+        return [
+            `| ${cols.map(([c, s]) => cellText(labelOf(c, s))).join(" | ")} |`,
+            `| ${cols.map(() => "---").join(" | ")} |`,
+            ...entries.map((e) => `| ${cols.map(([c, s]) => cellText(words(s, e[c], root, data))).join(" | ")} |`),
+        ].join("\n");
+    }
+    return entries
+        .map((e, i) => {
+        const title = titleOf(of, e) || `${of.label ?? f.label ?? ""} ${i + 1}`.trim();
+        return `${h(depth)} ${title}\n\n${objectMarkdown(of, e, depth + 1, root, data)}`;
+    })
+        .join("\n\n");
+}

package/apps/runtime/dist/routes/runs.js

@@ -1,6 +1,7 @@
-import { FORMATS, LANGS, LIST_FORMATS, TEXT_CLASSES } from "@engenty-wizards/shared/definition";
+import { FORMATS, isLang, LANG_CODE, LANGS, LIST_FORMATS, TEXT_CLASSES, wizardLang, } from "@engenty-wizards/shared/definition";
 import { TableColumnValueError } from "@engenty-wizards/shared/engenty/data-tables";
 import { noteText } from "@engenty-wizards/shared/run";
+import { machineTranslated, translateDefinition, } from "@engenty-wizards/shared/translation";
 import { getConnInfo } from "@hono/node-server/conninfo";
 import { and, eq } from "drizzle-orm";
 import { Hono } from "hono";
@@ -20,7 +21,7 @@ import { fieldErrorsIn } from "../engine/input.js";
 import { fromOwner } from "../engine/owner.js";
 import { pushAvailable, setPushDevice } from "../engine/push.js";
 import { liveResources } from "../engine/resources.js";
-import { cancel, createRun, goBack, NoCreditsError, projectIdOf, RunConflict, RunInputError, retry, reviewStep, runView, submitPage, talkAllowed, } from "../engine/runner.js";
+import { cancel, createRun, editOutput, goBack, NoCreditsError, projectIdOf, RunConflict, RunInputError, retry, reviewStep, runView, submitPage, talkAllowed, } from "../engine/runner.js";
 import { basePath, env } from "../env.js";
 import { loadAsset, saveAsset } from "../files/storage.js";
 import { reverseGeocode } from "../geocode.js";
@@ -35,6 +36,7 @@ import { brandView } from "../services/brand.js";
 import { ServiceError } from "../services/errors.js";
 import { publicRunners, servePageRunner } from "../services/runners.js";
 import { sharedRun, shareImage, shareRun, shareView, unshareRun } from "../services/shares.js";
+import { isLangCode, storedTranslation, translateResult, translationFor, uiTexts, } from "../services/translations.js";
 import { isIconFile, wizardAvatarSvg, wizardIcon } from "../services/wizard-icon.js";
 import { clearStore, deleteRows, listRows, listSecrets, readStoreFile, StoreError, saveRows, scopeOf, storeFiles, updateRow, } from "../store/index.js";
 import { tenantOfLink, tenantOfRun, tenantStatus, tokenOfCode, visitorOverLimit, } from "../tenants/control.js";
@@ -108,6 +110,8 @@ function visitorId(c, create, embedded = false) {
  * the owner's AI app with its run ticket, or — on the read-only file routes — a signed link
  * handed out to the owner's MCP client.
  */
+/** A view's kept state stays small: ticks and choices, not data. */
+const MAX_VIEW_STATE = 32_000;
 async function accessibleRun(c, runId, opts = {}) {
     const run = await db.query.run.findFirst({ where: eq(schema.run.id, runId) });
     if (!run) {
@@ -199,6 +203,50 @@ async function pageRunner(c, rest) {
         : null;
     return served ?? c.json(notFoundAnswer(c), 404);
 }
+/** A wizard's link with its published version, or null where it has none. */
+async function publishedWizard(token) {
+    const w = await db.query.wizard.findFirst({
+        where: eq(schema.wizard.shareToken, token ?? ""),
+    });
+    if (!w || w.publishedVersion === null) {
+        return null;
+    }
+    const version = await db.query.wizardVersion.findFirst({
+        where: and(eq(schema.wizardVersion.wizardId, w.id), eq(schema.wizardVersion.version, w.publishedVersion)),
+    });
+    return version ? { w, def: version.definition, version: w.publishedVersion } : null;
+}
+/** The author offers the wizard translated, and the language is not the one it is written in. */
+function wantsTranslation(w, def, lang) {
+    return w.translate && lang !== wizardLang(def);
+}
+/** What a wizard's page shows before a run: in the viewer's language where `as` is given. */
+async function publicBody(c, w, original, as) {
+    const translated = as ? translateDefinition(original, as.memory) : null;
+    const def = translated?.def ?? original;
+    const reason = await wizardUnavailable(w);
+    return {
+        token: w.shareToken,
+        title: def.title,
+        description: def.description,
+        avatar: def.avatar,
+        intro: def.intro ?? null,
+        brand: await brandView(w.projectId),
+        turnstileSiteKey: env.turnstile.siteKey || null,
+        available: !reason,
+        unavailableReason: reason && noteText(reason, requestLang(c)),
+        runners: await publicRunners(w, original),
+        lang: wizardLang(original),
+        translatable: w.translate,
+        translation: as && translated
+            ? {
+                lang: as.lang,
+                labels: translated.labels,
+                machine: machineTranslated(as.memory, original),
+            }
+            : null,
+    };
+}
 export const publicRoutes = new Hono()
     // A wizard's ID, typed into the mobile app: answers its share token.
     .get("/codes/:code", async (c) => {
@@ -220,30 +268,59 @@ export const publicRoutes = new Hono()
     .use("/wizards/:token/*", wizardLink)
     .use("/logos/:id", logoLink)
     .get("/wizards/:token", async (c) => {
-    const w = await db.query.wizard.findFirst({
-        where: eq(schema.wizard.shareToken, c.req.param("token")),
-    });
-    if (!w || w.publishedVersion === null) {
+    const found = await publishedWizard(c.req.param("token"));
+    if (!found) {
         return c.json(notFoundAnswer(c), 404);
     }
-    const version = await db.query.wizardVersion.findFirst({
-        where: and(eq(schema.wizardVersion.wizardId, w.id), eq(schema.wizardVersion.version, w.publishedVersion)),
-    });
-    const def = version.definition;
-    const reason = await wizardUnavailable(w);
-    const body = {
-        token: w.shareToken,
-        title: def.title,
-        description: def.description,
-        avatar: def.avatar,
-        intro: def.intro ?? null,
-        brand: await brandView(w.projectId),
-        turnstileSiteKey: env.turnstile.siteKey || null,
-        available: !reason,
-        unavailableReason: reason && noteText(reason, requestLang(c)),
-        runners: await publicRunners(w, def),
-    };
-    return c.json(body);
+    // The page in the viewer's language where it is kept; making it is the POST below.
+    const lang = c.req.query("lang");
+    const memory = isLangCode(lang) && wantsTranslation(found.w, found.def, lang)
+        ? await storedTranslation(found.w.id, lang)
+        : null;
+    return c.json(await publicBody(c, found.w, found.def, lang && memory ? { lang, memory } : null));
+})
+    // The wizard in the viewer's language: translated now where it is not kept yet.
+    .post("/wizards/:token/translation", async (c) => {
+    const found = await publishedWizard(c.req.param("token"));
+    if (!found) {
+        return c.json(notFoundAnswer(c), 404);
+    }
+    const { lang } = z
+        .object({ lang: z.string().regex(LANG_CODE) })
+        .parse(await c.req.json().catch(() => ({})));
+    if (!wantsTranslation(found.w, found.def, lang)) {
+        return refuse(c, { code: "translationOff" }, 403);
+    }
+    try {
+        const memory = await translationFor(found.w.id, found.def, lang, found.version);
+        return c.json(await publicBody(c, found.w, found.def, { lang, memory }));
+    }
+    catch (err) {
+        if (err instanceof ServiceError || err instanceof ModelUnavailableError) {
+            return refuse(c, { code: "translationFailed" }, 502);
+        }
+        throw err;
+    }
+})
+    // The runner's own words in a language outside LANGS, booked to this wizard's owner when new.
+    .get("/wizards/:token/texts/:lang", async (c) => {
+    const found = await publishedWizard(c.req.param("token"));
+    const lang = c.req.param("lang");
+    if (!found || !isLangCode(lang) || isLang(lang)) {
+        return c.json(notFoundAnswer(c), 404);
+    }
+    if (!wantsTranslation(found.w, found.def, lang)) {
+        return refuse(c, { code: "translationOff" }, 403);
+    }
+    try {
+        return c.json(await uiTexts(lang));
+    }
+    catch (err) {
+        if (err instanceof ServiceError || err instanceof ModelUnavailableError) {
+            return refuse(c, { code: "translationFailed" }, 502);
+        }
+        throw err;
+    }
 })
     .post("/wizards/:token/runs", async (c) => {
     const w = await db.query.wizard.findFirst({
@@ -262,6 +339,8 @@ export const publicRoutes = new Hono()
         embedded: z.boolean().optional(),
         // The website page that embeds the wizard: shown with the result.
         origin: z.string().max(2000).optional(),
+        // The language the viewer reads the wizard in, translated on request.
+        lang: z.string().regex(LANG_CODE).optional(),
     })
         .parse(await c.req.json().catch(() => ({})));
     const ip = clientIp(c);
@@ -286,6 +365,11 @@ export const publicRoutes = new Hono()
             visitorId: vid,
             ipHash,
             origin: body.embedded ? webAddress(body.origin) : null,
+            lang: body.lang &&
+                wantsTranslation(w, version.definition, body.lang) &&
+                (await storedTranslation(w.id, body.lang))
+                ? body.lang
+                : null,
         });
         return c.json({ runId });
     }
@@ -478,6 +562,54 @@ export const runRoutes = new Hono()
     catch (err) {
         return commandError(c, err);
     }
+})
+    // What the person did in a step's view — a checklist's ticks, a widget's state — kept with the
+    // run, so the next visit shows it. Only while the run waits or is done: a running step owns
+    // the state then.
+    .put("/:id/views/:stepId", async (c) => {
+    const run = await accessibleRun(c, c.req.param("id"));
+    const stepId = c.req.param("stepId");
+    const output = run?.state.outputs[stepId];
+    if (!run || !output) {
+        return c.json(notFoundAnswer(c), 404);
+    }
+    if (run.status !== "waiting_input" && run.status !== "done") {
+        return c.json({ error: "busy" }, 409);
+    }
+    const { state } = z
+        .object({ state: z.record(z.string(), z.unknown()) })
+        .parse(await c.req.json());
+    if (JSON.stringify(state).length > MAX_VIEW_STATE) {
+        return c.json({ error: "too large" }, 413);
+    }
+    await db
+        .update(schema.run)
+        .set({
+        state: {
+            ...run.state,
+            outputs: { ...run.state.outputs, [stepId]: { ...output, view: state } },
+        },
+    })
+        .where(eq(schema.run.id, run.id));
+    return c.json({ ok: true });
+})
+    // A json step's data, edited in the studio by someone of the team the run belongs to.
+    .put("/:id/outputs/:stepId", async (c) => {
+    const run = await accessibleRun(c, c.req.param("id"));
+    const user = await principalOf(c);
+    if (!run || !user || user.tenantId !== run.tenantId) {
+        return c.json(notFoundAnswer(c), 404);
+    }
+    const { json } = z
+        .object({ json: z.record(z.string(), z.unknown()) })
+        .parse(await c.req.json());
+    try {
+        await editOutput(run.id, c.req.param("stepId"), json);
+        return c.json({ ok: true });
+    }
+    catch (err) {
+        return commandError(c, err);
+    }
 })
     .post("/:id/reviews/:stepId", async (c) => {
     const run = await accessibleRun(c, c.req.param("id"));
@@ -486,7 +618,13 @@ export const runRoutes = new Hono()
     }
     const action = z
         .discriminatedUnion("type", [
-        z.object({ type: z.literal("accept"), edits: z.record(z.string(), z.string()).optional() }),
+        z.object({
+            type: z.literal("accept"),
+            // A text, or the data of a json step (checked against its schema).
+            edits: z
+                .record(z.string(), z.union([z.string(), z.record(z.string(), z.unknown())]))
+                .optional(),
+        }),
         z.object({
             type: z.literal("regenerate"),
             target: z.string(),
@@ -536,6 +674,71 @@ export const runRoutes = new Hono()
     }
     await cancel(run.id);
     return c.json({ ok: true });
+})
+    // The viewer reads the run in another language from now on: null for the wizard's own.
+    .post("/:id/lang", async (c) => {
+    const run = await accessibleRun(c, c.req.param("id"));
+    if (!run) {
+        return c.json(notFoundAnswer(c), 404);
+    }
+    const { lang } = z
+        .object({ lang: z.string().regex(LANG_CODE).nullable() })
+        .parse(await c.req.json().catch(() => ({})));
+    const w = await db.query.wizard.findFirst({ where: eq(schema.wizard.id, run.wizardId) });
+    const own = !lang || lang === wizardLang(run.definition);
+    if (!(own || (w && wantsTranslation(w, run.definition, lang)))) {
+        return refuse(c, { code: "translationOff" }, 403);
+    }
+    if (!own) {
+        try {
+            await translationFor(run.wizardId, run.definition, lang, run.version);
+        }
+        catch (err) {
+            if (err instanceof ServiceError || err instanceof ModelUnavailableError) {
+                return refuse(c, { code: "translationFailed" }, 502);
+            }
+            throw err;
+        }
+    }
+    await db
+        .update(schema.run)
+        .set({ lang: own ? null : lang })
+        .where(eq(schema.run.id, run.id));
+    signalChanged(run.id);
+    return c.json({ ok: true });
+})
+    // A finished result's text in the language the viewer reads the run in, kept on the run.
+    .post("/:id/translate-result", async (c) => {
+    const run = await accessibleRun(c, c.req.param("id"));
+    if (!run) {
+        return c.json(notFoundAnswer(c), 404);
+    }
+    const { stepId } = z.object({ stepId: z.string() }).parse(await c.req.json().catch(() => ({})));
+    const text = run.state.outputs[stepId]?.text;
+    if (!(run.lang && text)) {
+        return c.json(notFoundAnswer(c), 404);
+    }
+    if (!run.state.translated?.[run.lang]?.[stepId]) {
+        let translated;
+        try {
+            translated = await translateResult(text, run.lang, wizardLang(run.definition));
+        }
+        catch (err) {
+            if (err instanceof ServiceError || err instanceof ModelUnavailableError) {
+                return refuse(c, { code: "translationFailed" }, 502);
+            }
+            throw err;
+        }
+        const fresh = await db.query.run.findFirst({ where: eq(schema.run.id, run.id) });
+        const state = fresh?.state ?? run.state;
+        state.translated = {
+            ...state.translated,
+            [run.lang]: { ...state.translated?.[run.lang], [stepId]: translated },
+        };
+        await db.update(schema.run).set({ state }).where(eq(schema.run.id, run.id));
+        signalChanged(run.id);
+    }
+    return c.json({ ok: true });
 })
     // A live conversation on the run: the secret the browser opens the session with.
     .post("/:id/talk", async (c) => {

package/apps/runtime/dist/routes/studio.js

@@ -1,11 +1,12 @@
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { ASSISTANT_LAYOUTS, ASSISTANT_PAGE_BYTES, assistantSignalSchema, assistantTurnSchema, } from "@engenty-wizards/shared/assistant";
-import { LANGS, MODEL_CLASSES, TEXT_CLASSES, } from "@engenty-wizards/shared/definition";
+import { LANGS, MODEL_CLASSES, TEXT_CLASSES, wizardLang, } from "@engenty-wizards/shared/definition";
 import { CATEGORY_TYPES, whereSchema } from "@engenty-wizards/shared/knowledge";
 import { PROJECT_FILE_KINDS } from "@engenty-wizards/shared/projects";
 import { isCreditsRef } from "@engenty-wizards/shared/providers";
 import { note } from "@engenty-wizards/shared/run";
+import { wizardTexts } from "@engenty-wizards/shared/translation";
 import { PACKAGE_EXTENSION, PACKAGE_MAX_BYTES, PACKAGE_MIME, } from "@engenty-wizards/shared/wizard-package";
 import { generateText } from "ai";
 import { Hono } from "hono";
@@ -58,6 +59,7 @@ import { runnersOf, wizardRunners } from "../services/runners.js";
 import { listResults, listRuns, startTestRun } from "../services/runs.js";
 import { addCategoryValue, categoryRow, categoryValue, deleteCategory, deleteCategoryValue, mergeCategoryValues, orderCategoryValues, putCategory, renameCategoryValue, setItemCategory, updateCategory, } from "../services/space-categories.js";
 import { addTableRow, createPage, createTable, deletePage, deleteTable, deleteTableRows, getPage, getTable, listSpaceData, orderSubPages, updatePage, updateTable, updateTableRow, } from "../services/space-data.js";
+import { deleteTranslation, editTranslation, isLangCode, publishedDefinition, translationsOf, } from "../services/translations.js";
 import { draftWidgetPreview } from "../services/widgets.js";
 import { createWizard, deleteWizard, draftChanges, duplicateWizard, listWizards, ownedWizard, rotateShareLink, updateWizardSettings, wizardMessages, wizardState, writableWizard, writeDraft, } from "../services/wizards.js";
 import { readSetting, writeSetting } from "../settings.js";
@@ -66,7 +68,7 @@ import { currentTenant } from "../tenants/tenant.js";
 import { serverText } from "../texts.js";
 import { applyUpdate, updateStatus } from "../update.js";
 import { byteRange } from "./delivery.js";
-import { requestLang, say } from "./lang.js";
+import { notFoundAnswer, requestLang, say } from "./lang.js";
 /** The model sources a test call has worked on: the setup is done for those, not for the others. */
 async function testedSources() {
     const tested = await readSetting("setup-done");
@@ -1008,16 +1010,52 @@ export const studio = new Hono()
         dailyRunLimit: z.number().int().min(1).max(10_000).optional(),
         projectId: z.string().optional(),
         runners: z.object({ default: z.string(), enabled: z.array(z.string()).max(20) }).optional(),
+        translate: z.boolean().optional(),
     })
         .parse(await c.req.json());
     await updateWizardSettings(c.get("user").id, c.req.param("id"), patch);
     // The copy in the cloud of a linked account is shared the same way.
     if (patch.shareEnabled !== undefined ||
         patch.dailyRunLimit !== undefined ||
-        patch.runners !== undefined) {
+        patch.runners !== undefined ||
+        patch.translate !== undefined) {
         await pushSharing(c.get("user").id, c.req.param("id"));
     }
     return c.json({ ok: true });
+})
+    // The languages the published wizard is kept in, each original text with its translation.
+    .get("/wizards/:id/translations", async (c) => {
+    const w = await ownedWizard(c.get("user").id, c.req.param("id"));
+    const def = await publishedDefinition(w);
+    const kept = await translationsOf(w.id);
+    return c.json({
+        lang: def ? wizardLang(def) : wizardLang(w.draft),
+        texts: def ? wizardTexts(def) : [],
+        translations: kept.map((t) => ({
+            lang: t.lang,
+            texts: t.texts,
+            updatedAt: t.updatedAt.toISOString(),
+        })),
+    });
+})
+    // The author's own lines for a language: they replace what a model wrote.
+    .put("/wizards/:id/translations/:lang", async (c) => {
+    const w = await writableWizard(c.get("user").id, c.req.param("id"));
+    const def = await publishedDefinition(w);
+    const lang = c.req.param("lang");
+    if (!(def && isLangCode(lang))) {
+        return c.json(notFoundAnswer(c), 404);
+    }
+    const { lines } = z
+        .object({ lines: z.record(z.string(), z.string().max(4000)) })
+        .parse(await c.req.json());
+    await editTranslation(w.id, def, lang, lines);
+    return c.json({ ok: true });
+})
+    .delete("/wizards/:id/translations/:lang", async (c) => {
+    const w = await writableWizard(c.get("user").id, c.req.param("id"));
+    await deleteTranslation(w.id, c.req.param("lang"));
+    return c.json({ ok: true });
 })
     // The wizard's ID for the mobile app, beside its link.
     .get("/wizards/:id/code", async (c) => {

package/apps/runtime/dist/services/brand.js

@@ -1,4 +1,4 @@
-import { GRADIENT_TYPES, gradientCss, mainLogo, } from "@engenty-wizards/shared/projects";
+import { GRADIENT_TYPES, gradientCss, mainLogo, runTheme, } from "@engenty-wizards/shared/projects";
 import { note } from "@engenty-wizards/shared/run";
 import { generateText, Output } from "ai";
 import { and, asc, eq } from "drizzle-orm";
@@ -24,6 +24,7 @@ export async function brandView(projectId) {
         name: p?.brand.name ?? "",
         accent: p?.brand.colors?.[0]?.value ?? null,
         logoUrl: logo ? `/api/public/logos/${logo}` : null,
+        theme: runTheme(p?.brand ?? {}),
     };
 }
 const HEX = /^#[0-9a-f]{6}$/i;

package/apps/runtime/dist/services/cloud.js

@@ -292,6 +292,7 @@ export async function pushSharing(userId, wizardId) {
     await call("PATCH", `/spaces/${w.projectId}/wizards/${w.id}`, {
         shareEnabled: w.shareEnabled,
         dailyRunLimit: w.dailyRunLimit,
+        translate: w.translate,
         ...(w.runners ? { runners: w.runners } : {}),
     }).catch((err) => console.error("[cloud] sharing not sent:", err.message));
 }

package/apps/runtime/dist/services/spaces.js

@@ -69,6 +69,7 @@ export const syncWizardSchema = z.object({
 });
 export const syncSettingsSchema = z.object({
     shareEnabled: z.boolean().optional(),
+    translate: z.boolean().optional(),
     dailyRunLimit: z.number().int().min(1).max(10_000).optional(),
 });
 export const checkSchema = z.object({