@simmalugnt-se/payload-editor-assistant 0.8.0 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.9.0
+
+- Translation: on a document with localized text that is empty in the open language but filled in
+  the default one, the panel offers "Translate from English" ("Översätt från engelska"). The
+  assistant fills every such field in one proposal, rich text with its formatting and links, and
+  leaves translated fields alone unless asked to translate them again. The model is told which
+  fields to fill and which are translated already, instead of an 80-character preview of each
+  source, and replies in the editor's language rather than the one it translates into.
+- New endpoint `GET /api/editor-assistant/translation` says whether the open document has fields
+  to translate, and from which language.
+- Other language versions are read without fallback, as Admin reads them, and a language with no
+  text of its own is left out of the model's context.
+
+- Replies show their Markdown as formatting instead of asterisks: paragraphs, bullet and numbered
+  lists, bold, italic and code. Headings show as bold lines, and links as their text, with a web
+  address written out after it; the panel makes no link the model wrote clickable.
+- A reply keeps its line breaks. Before, filtering the model's reply joined it into one line, so a
+  list ran together.
+
 ## 0.8.0
 
 - Rich text keeps its formatting. The model reads Lexical as Markdown blocks, one per paragraph,

package/README.md

@@ -127,6 +127,17 @@ point at a collection the field's `LinkFeature` allows and that the editor can r
 cannot express, such as an embedded image, are kept as they are. Without the package, rich text is
 written as plain paragraphs as before.
 
+## Translation
+
+In a localized project, the assistant translates a document from the default language into the one
+open in Admin. On a document with localized text that is empty here but filled in the default
+language, the panel offers a button ("Translate from English"). The editor can also ask in the
+chat, or start from content health's work list. It fills every empty localized field in one
+proposal, rich text as Markdown blocks with headings, lists, bold, italic and links kept, and leaves
+fields that already have text alone unless asked to translate them again. Fields shared between the
+languages (blocks, images, slugs) never change. The button asks `GET /api/editor-assistant/translation`
+whether there is anything to translate, with the editor's access.
+
 ## Keep or undo
 
 A proposed form change goes straight into the open form, so the fields and Live Preview show it

package/dist/components/EditorAssistantAside.js

@@ -7,9 +7,11 @@ import { resolveChatLanguage } from "../runtime/language.js";
 import { parseAdminView } from "../view.js";
 import { assistantRequest, assistantStream } from "./assistant-api.js";
 import { useAssistantState, } from "./assistant-context.js";
-import { COPY, uiLanguage } from "./copy.js";
+import { COPY, translateAction, uiLanguage } from "./copy.js";
 import { isFormProposal, proposalSteps, refineProposal, replaceLatestStep, } from "./proposal-chain.js";
+import { ReplyText } from "./ReplyText.js";
 import { KEEP_SELECTION_ATTR } from "./selection-dom.js";
+import { useTranslationOffer } from "./translation-offer.js";
 export function EditorAssistantAside() {
     const { open, setOpen, status, messages, shortcuts, collections, bridge, formAdapter, pendingApproval, selection, setSelection, prefill, setPrefill, resetConversation, setStatus, setMessages, setPendingApproval, stop, setAbortController, } = useAssistantState();
     const { config, getEntityConfig } = useConfig();
@@ -39,6 +41,12 @@ export function EditorAssistantAside() {
     const [step, setStep] = useState(null);
     const stickToBottomRef = useRef(true);
     const apiBase = config.routes.api;
+    // The offer compares saved versions, so it waits while the form has unsaved changes and asks
+    // again once they are saved or after a message: a kept translation takes the button away.
+    const offer = useTranslationOffer(apiBase, bridge ?? undefined, `${messages.length}:${bridge?.modified ? 1 : 0}`);
+    const translate = offer?.source && offer.empty > 0 && !pendingApproval && !bridge?.modified
+        ? translateAction(uiLanguage(i18n.language), offer.source)
+        : undefined;
     // Scroll when the thread grows. The values are triggers, not reads.
     // biome-ignore lint/correctness/useExhaustiveDependencies: pin to bottom after new messages, working state, or approval cards
     useLayoutEffect(() => {
@@ -434,15 +442,17 @@ export function EditorAssistantAside() {
     if (!open) {
         return null;
     }
-    return (_jsxs("aside", { className: "ea-aside", "aria-label": copy.assistant, [KEEP_SELECTION_ATTR]: "", children: [_jsxs("div", { className: "ea-aside__head", children: [_jsxs("div", { className: "ea-aside__title", children: [_jsx("h2", { children: copy.assistant }), bridge ? _jsx("p", { className: "ea-aside__context", children: contextLine(bridge, config) }) : null] }), (messages.length > 0 || pendingApproval) && !pendingApproval?.applied ? (_jsx(Button, { buttonStyle: "subtle", margin: false, onClick: () => resetConversation(), size: "medium", children: copy.newChat })) : null, _jsx(Button, { "aria-label": copy.collapseLabel, buttonStyle: "icon-label", className: "ea-aside__collapse", icon: _jsx(ChevronIcon, { direction: "right" }), margin: false, onClick: () => setOpen(false), tooltip: copy.collapse })] }), _jsxs("div", { className: "ea-aside__body", children: [_jsxs("div", { className: "ea-messages", ref: threadRef, onScroll: onThreadScroll, children: [messages.length === 0 ? (_jsx("div", { className: "ea-msg ea-msg--assistant", children: introText(view, bridge, collections, config, copy) })) : null, messages.map((message) => (_jsxs("div", { className: `ea-msg ea-msg--${message.role}`, children: [message.text, message.candidates?.length ? (_jsx("div", { className: "ea-actions", children: message.candidates.map((candidate) => (_jsx(Button, { buttonStyle: "pill", margin: false, onClick: () => {
+    return (_jsxs("aside", { className: "ea-aside", "aria-label": copy.assistant, [KEEP_SELECTION_ATTR]: "", children: [_jsxs("div", { className: "ea-aside__head", children: [_jsxs("div", { className: "ea-aside__title", children: [_jsx("h2", { children: copy.assistant }), bridge ? _jsx("p", { className: "ea-aside__context", children: contextLine(bridge, config) }) : null] }), (messages.length > 0 || pendingApproval) && !pendingApproval?.applied ? (_jsx(Button, { buttonStyle: "subtle", margin: false, onClick: () => resetConversation(), size: "medium", children: copy.newChat })) : null, _jsx(Button, { "aria-label": copy.collapseLabel, buttonStyle: "icon-label", className: "ea-aside__collapse", icon: _jsx(ChevronIcon, { direction: "right" }), margin: false, onClick: () => setOpen(false), tooltip: copy.collapse })] }), _jsxs("div", { className: "ea-aside__body", children: [_jsxs("div", { className: "ea-messages", ref: threadRef, onScroll: onThreadScroll, children: [messages.length === 0 ? (_jsx("div", { className: "ea-msg ea-msg--assistant", children: introText(view, bridge, collections, config, copy) })) : null, messages.map((message) => (_jsxs("div", { className: `ea-msg ea-msg--${message.role}`, children: [message.role === "assistant" ? _jsx(ReplyText, { text: message.text }) : message.text, message.candidates?.length ? (_jsx("div", { className: "ea-actions", children: message.candidates.map((candidate) => (_jsx(Button, { buttonStyle: "pill", margin: false, onClick: () => {
                                                 router.push(candidate.href);
                                             }, size: "small", children: candidate.label }, candidate.href))) })) : null] }, message.id))), status === "streaming" ? (_jsxs("div", { className: "ea-msg ea-msg--working", children: [_jsxs("span", { className: "ea-dots", "aria-hidden": "true", children: [_jsx("span", {}), _jsx("span", {}), _jsx("span", {})] }), _jsx("span", { children: step ? talk.steps[step] : talk.working })] })) : null] }), pendingApproval ? (_jsxs("div", { className: "ea-approval", children: [_jsx("h3", { children: pendingApproval.title }), pendingApproval.applied ? (_jsxs("p", { className: "ea-approval__hint", children: [autosave ? copy.previewHintAutosave : copy.previewHint, pendingApproval.earlier?.length ? ` ${copy.refinedHint}` : ""] })) : null, _jsx("ul", { className: "ea-approval__diff", children: pendingApproval.summary.split("\n").map((line, index) => line.startsWith("  ") ? (
                                 // biome-ignore lint/suspicious/noArrayIndexKey: lines are static for one approval
                                 _jsx("li", { className: "ea-approval__sub", children: line.trim() }, index)) : (
                                 // biome-ignore lint/suspicious/noArrayIndexKey: lines are static for one approval
-                                _jsx("li", { children: line }, index))) }), confirmUndo ? (_jsxs(_Fragment, { children: [_jsx("p", { className: "ea-approval__warn", children: copy.undoLosesEdits }), _jsxs("div", { className: "ea-actions", children: [_jsx(Button, { buttonStyle: "primary", margin: false, onClick: () => void undoPreview(pendingApproval, true), size: "medium", children: copy.undoAnyway }), _jsx(Button, { buttonStyle: "secondary", margin: false, onClick: () => setConfirmUndo(false), size: "medium", children: copy.cancel })] })] })) : (_jsxs("div", { className: "ea-actions", children: [_jsx(Button, { buttonStyle: "primary", disabled: status === "streaming", margin: false, onClick: () => void decide("approve"), size: "medium", children: pendingApproval.applied ? copy.keep : copy.approve }), _jsx(Button, { buttonStyle: "secondary", disabled: status === "streaming", margin: false, onClick: () => void decide("reject"), size: "medium", children: pendingApproval.applied ? copy.undo : copy.reject })] }))] })) : null, status !== "idle" && status !== "streaming" ? (_jsx("div", { className: `ea-status ea-status--${status}`, children: statusText(status, talk) })) : null, _jsxs("form", { className: "ea-composer", onSubmit: onSubmit, children: [visibleShortcuts.length > 0 ? (_jsx("div", { className: "ea-shortcuts", children: visibleShortcuts.map((shortcut) => (_jsx(Button, { buttonStyle: "pill", disabled: status === "streaming", margin: false, onClick: () => {
-                                        void send(shortcut.prompt);
-                                    }, size: "small", children: shortcut.label }, shortcut.id))) })) : null, selection && bridge ? (_jsxs("div", { className: "ea-selection", children: [_jsxs("span", { className: "ea-selection__label", children: [copy.selected, ": ", _jsx("strong", { children: selection.label })] }), _jsx("button", { "aria-label": copy.clearSelection, className: "ea-selection__clear", type: "button", onClick: () => setSelection(null), children: _jsx(XIcon, {}) })] })) : null, _jsxs("div", { className: "ea-composer__box", children: [_jsx("textarea", { disabled: status === "streaming", placeholder: copy.placeholder, rows: 2, value: draft, onChange: (event) => setDraft(event.target.value), onKeyDown: onKeyDown }), _jsx("div", { className: "ea-composer__bar", children: status === "streaming" ? (
+                                _jsx("li", { children: line }, index))) }), confirmUndo ? (_jsxs(_Fragment, { children: [_jsx("p", { className: "ea-approval__warn", children: copy.undoLosesEdits }), _jsxs("div", { className: "ea-actions", children: [_jsx(Button, { buttonStyle: "primary", margin: false, onClick: () => void undoPreview(pendingApproval, true), size: "medium", children: copy.undoAnyway }), _jsx(Button, { buttonStyle: "secondary", margin: false, onClick: () => setConfirmUndo(false), size: "medium", children: copy.cancel })] })] })) : (_jsxs("div", { className: "ea-actions", children: [_jsx(Button, { buttonStyle: "primary", disabled: status === "streaming", margin: false, onClick: () => void decide("approve"), size: "medium", children: pendingApproval.applied ? copy.keep : copy.approve }), _jsx(Button, { buttonStyle: "secondary", disabled: status === "streaming", margin: false, onClick: () => void decide("reject"), size: "medium", children: pendingApproval.applied ? copy.undo : copy.reject })] }))] })) : null, status !== "idle" && status !== "streaming" ? (_jsx("div", { className: `ea-status ea-status--${status}`, children: statusText(status, talk) })) : null, _jsxs("form", { className: "ea-composer", onSubmit: onSubmit, children: [visibleShortcuts.length > 0 || translate ? (_jsxs("div", { className: "ea-shortcuts", children: [translate ? (_jsx(Button, { buttonStyle: "pill", disabled: status === "streaming", margin: false, onClick: () => {
+                                            void send(translate.prompt);
+                                        }, size: "small", children: translate.label })) : null, visibleShortcuts.map((shortcut) => (_jsx(Button, { buttonStyle: "pill", disabled: status === "streaming", margin: false, onClick: () => {
+                                            void send(shortcut.prompt);
+                                        }, size: "small", children: shortcut.label }, shortcut.id)))] })) : null, selection && bridge ? (_jsxs("div", { className: "ea-selection", children: [_jsxs("span", { className: "ea-selection__label", children: [copy.selected, ": ", _jsx("strong", { children: selection.label })] }), _jsx("button", { "aria-label": copy.clearSelection, className: "ea-selection__clear", type: "button", onClick: () => setSelection(null), children: _jsx(XIcon, {}) })] })) : null, _jsxs("div", { className: "ea-composer__box", children: [_jsx("textarea", { disabled: status === "streaming", placeholder: copy.placeholder, rows: 2, value: draft, onChange: (event) => setDraft(event.target.value), onKeyDown: onKeyDown }), _jsx("div", { className: "ea-composer__bar", children: status === "streaming" ? (
                                         // While the assistant works, Send becomes Stop, where the editor's eye already is.
                                         _jsx(Button, { "aria-label": copy.stop, buttonStyle: "secondary", className: "ea-composer__stop", icon: _jsx("span", { className: "ea-stop-icon", "aria-hidden": "true" }), iconPosition: "left", margin: false, onClick: () => stop(), size: "medium", type: "button", children: copy.stop })) : (_jsx(Button, { buttonStyle: "primary", disabled: draft.trim() === "", margin: false, size: "medium", type: "submit", children: copy.send })) })] })] })] })] }));
 }

package/dist/components/ReplyText.d.ts

@@ -0,0 +1,4 @@
+/** An assistant reply with the model's Markdown shown as formatting instead of asterisks. */
+export declare function ReplyText({ text }: {
+    text: string;
+}): import("react").JSX.Element[];

package/dist/components/ReplyText.js

@@ -0,0 +1,26 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { parseReply } from "./reply-markdown.js";
+/** An assistant reply with the model's Markdown shown as formatting instead of asterisks. */
+export function ReplyText({ text }) {
+    return parseReply(text).map((block, index) => {
+        const key = `${block.type}-${index}`;
+        if (block.type === "paragraph") {
+            return (_jsx("p", { className: "ea-reply__p", children: spans(block.spans) }, key));
+        }
+        const items = block.items.map((item, itemIndex) => _jsx("li", { children: spans(item) }, itemIndex));
+        return block.ordered ? (_jsx("ol", { className: "ea-reply__list", start: block.start, children: items }, key)) : (_jsx("ul", { className: "ea-reply__list", children: items }, key));
+    });
+}
+function spans(list) {
+    return list.map((span, index) => {
+        let node = span.text;
+        if (span.code)
+            node = _jsx("code", { children: node });
+        if (span.italic)
+            node = _jsx("em", { children: node });
+        if (span.bold)
+            node = _jsx("strong", { children: node });
+        return _jsx("span", { children: node }, index);
+    });
+}

package/dist/components/copy.d.ts

@@ -133,3 +133,11 @@ export declare const COPY: {
     };
 };
 export type Copy = (typeof COPY)[UiLanguage];
+/**
+ * The button the panel offers on a document with fields not translated yet. Its prompt is the one
+ * content health's work list sends for a missing translation.
+ */
+export declare function translateAction(language: UiLanguage, source: string): {
+    label: string;
+    prompt: string;
+};

package/dist/components/copy.js

@@ -133,3 +133,21 @@ export const COPY = {
         },
     },
 };
+/**
+ * The button the panel offers on a document with fields not translated yet. Its prompt is the one
+ * content health's work list sends for a missing translation.
+ */
+export function translateAction(language, source) {
+    const name = languageName(language, source);
+    return language === "sv"
+        ? { label: `Översätt från ${name}`, prompt: `Översätt de tomma fälten från ${name}.` }
+        : { label: `Translate from ${name}`, prompt: `Translate the empty fields from ${name}.` };
+}
+function languageName(language, code) {
+    try {
+        return new Intl.DisplayNames([language], { type: "language" }).of(code) ?? code;
+    }
+    catch {
+        return code;
+    }
+}

package/dist/components/reply-markdown.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The Markdown the model writes in its replies, read into a small tree the panel renders as React
+ * elements: paragraphs, lists, bold, italic and code. Headings show as bold paragraphs. Links show as
+ * their text, and a web address stays visible after it, so the panel never renders a link the model
+ * wrote. A marker that does not close stays as text, so a half-streamed reply reads the same.
+ */
+export type ReplySpan = {
+    text: string;
+    bold?: true;
+    italic?: true;
+    code?: true;
+};
+export type ReplyBlock = {
+    type: "paragraph";
+    spans: ReplySpan[];
+} | {
+    type: "list";
+    ordered: false;
+    items: ReplySpan[][];
+} | {
+    type: "list";
+    ordered: true;
+    start: number;
+    items: ReplySpan[][];
+};
+export declare function parseReply(text: string): ReplyBlock[];

package/dist/components/reply-markdown.js

@@ -0,0 +1,142 @@
+/**
+ * The Markdown the model writes in its replies, read into a small tree the panel renders as React
+ * elements: paragraphs, lists, bold, italic and code. Headings show as bold paragraphs. Links show as
+ * their text, and a web address stays visible after it, so the panel never renders a link the model
+ * wrote. A marker that does not close stays as text, so a half-streamed reply reads the same.
+ */
+const BULLET = /^\s*[-*+]\s+(.*)$/;
+const NUMBERED = /^\s*(\d{1,9})[.)]\s+(.*)$/;
+const HEADING = /^\s*#{1,6}\s+(.*?)\s*#*\s*$/;
+const WORD = /[\p{L}\p{N}]/u;
+export function parseReply(text) {
+    const blocks = [];
+    let paragraph = [];
+    let list;
+    const flush = () => {
+        if (paragraph.length) {
+            blocks.push({ type: "paragraph", spans: parseInline(paragraph.join("\n")) });
+        }
+        if (list) {
+            const items = list.items.map((item) => parseInline(item));
+            blocks.push(list.ordered
+                ? { type: "list", ordered: true, start: list.start, items }
+                : { type: "list", ordered: false, items });
+        }
+        paragraph = [];
+        list = undefined;
+    };
+    for (const line of text.split(/\r?\n/)) {
+        const numbered = NUMBERED.exec(line);
+        const bullet = numbered ? undefined : BULLET.exec(line);
+        if (numbered || bullet) {
+            const ordered = Boolean(numbered);
+            if (paragraph.length || (list && list.ordered !== ordered))
+                flush();
+            list ??= { ordered, start: numbered ? Number(numbered[1]) : 1, items: [] };
+            list.items.push((numbered ? numbered[2] : bullet?.[1]) ?? "");
+            continue;
+        }
+        if (list)
+            flush();
+        const heading = HEADING.exec(line);
+        if (heading) {
+            flush();
+            blocks.push({ type: "paragraph", spans: parseInline(heading[1] ?? "", { bold: true }) });
+        }
+        else if (line.trim() === "") {
+            flush();
+        }
+        else {
+            paragraph.push(line);
+        }
+    }
+    flush();
+    return blocks;
+}
+function parseInline(text, format = {}) {
+    const spans = [];
+    const push = (value, spanFormat) => {
+        if (!value)
+            return;
+        const last = spans.at(-1);
+        if (last && sameFormat(last, spanFormat))
+            last.text += value;
+        else
+            spans.push({ text: value, ...spanFormat });
+    };
+    const pushAll = (inner) => {
+        for (const { text: value, ...spanFormat } of inner)
+            push(value, spanFormat);
+    };
+    let i = 0;
+    while (i < text.length) {
+        const ch = text[i];
+        if (ch === "`") {
+            const end = text.indexOf("`", i + 1);
+            if (end > i + 1) {
+                push(text.slice(i + 1, end), { ...format, code: true });
+                i = end + 1;
+                continue;
+            }
+        }
+        else if (ch === "[") {
+            const link = /^\[([^\]]+)\]\(([^)\s]+)\)/.exec(text.slice(i));
+            if (link) {
+                pushAll(parseInline(link[1] ?? "", format));
+                const href = link[2] ?? "";
+                if (/^https?:\/\//i.test(href))
+                    push(` (${href})`, format);
+                i += link[0].length;
+                continue;
+            }
+        }
+        else if (ch === "*" || ch === "_") {
+            const double = text[i + 1] === ch;
+            const size = double ? 2 : 1;
+            const end = opens(text, i, ch, size) ? closing(text, i + size, ch, size) : -1;
+            if (end > -1) {
+                const inner = double
+                    ? { ...format, bold: true }
+                    : { ...format, italic: true };
+                pushAll(parseInline(text.slice(i + size, end), inner));
+                i = end + size;
+                continue;
+            }
+            // A marker that does not open or close is text, and so is the whole run of it.
+            push(text.slice(i, i + size), format);
+            i += size;
+            continue;
+        }
+        push(ch ?? "", format);
+        i += 1;
+    }
+    return spans;
+}
+function opens(text, at, ch, size) {
+    const next = text[at + size];
+    if (!next || /\s/.test(next) || (size === 1 && next === ch))
+        return false;
+    return ch !== "_" || !WORD.test(text[at - 1] ?? "");
+}
+/** Where the marker that closes one opened before `from` starts, or -1. */
+function closing(text, from, ch, size) {
+    for (let i = from + 1; i < text.length; i += 1) {
+        if (text[i] !== ch)
+            continue;
+        const before = text[i - 1] ?? "";
+        const after = text[i + size] ?? "";
+        if (/\s/.test(before) || after === ch)
+            continue;
+        if (size === 2 && text[i + 1] !== ch)
+            continue;
+        if (size === 1 && before === ch)
+            continue;
+        if (ch === "_" && WORD.test(after))
+            continue;
+        return i;
+    }
+    return -1;
+}
+function sameFormat(a, b) {
+    return a.bold === b.bold && a.italic === b.italic && a.code === b.code;
+}

package/dist/components/translation-offer.d.ts

@@ -0,0 +1,16 @@
+export type TranslationOffer = {
+    source?: string;
+    empty: number;
+};
+type Target = {
+    collectionSlug?: string;
+    globalSlug?: string;
+    documentId?: string | number;
+    locale: string;
+};
+/**
+ * Whether the open document has fields to translate from the default language, asked again when
+ * `refresh` changes (a new message, a kept or undone proposal). Undefined until known or on error.
+ */
+export declare function useTranslationOffer(apiBase: string, target: Target | undefined, refresh: unknown): TranslationOffer | undefined;
+export {};

package/dist/components/translation-offer.js

@@ -0,0 +1,38 @@
+"use client";
+import { useEffect, useState } from "react";
+import { ENDPOINT_PREFIX } from "../package-name.js";
+/**
+ * Whether the open document has fields to translate from the default language, asked again when
+ * `refresh` changes (a new message, a kept or undone proposal). Undefined until known or on error.
+ */
+export function useTranslationOffer(apiBase, target, refresh) {
+    const [offer, setOffer] = useState();
+    const collection = target?.collectionSlug;
+    const global = target?.globalSlug;
+    const id = target?.documentId;
+    const locale = target?.locale;
+    // biome-ignore lint/correctness/useExhaustiveDependencies: `refresh` only asks again.
+    useEffect(() => {
+        setOffer(undefined);
+        if (!locale || (!global && (!collection || id === undefined))) {
+            return;
+        }
+        const params = new URLSearchParams({ locale });
+        if (collection)
+            params.set("collection", collection);
+        if (global)
+            params.set("global", global);
+        if (id !== undefined)
+            params.set("id", String(id));
+        const controller = new AbortController();
+        fetch(`${apiBase}${ENDPOINT_PREFIX}/translation?${params}`, {
+            credentials: "include",
+            signal: controller.signal,
+        })
+            .then((response) => response.ok ? response.json() : undefined)
+            .then((result) => setOffer(result))
+            .catch(() => undefined);
+        return () => controller.abort();
+    }, [apiBase, collection, global, id, locale, refresh]);
+    return offer;
+}

package/dist/domain/content.js

@@ -85,6 +85,8 @@ export async function findContentById(req, options, input) {
                 slug: input.global,
                 depth: 0,
                 locale: input.locale,
+                // As Admin reads it: a field nobody filled in this language is empty, not another's text.
+                fallbackLocale: false,
                 draft: true,
                 req,
                 user: req.user,
@@ -105,6 +107,7 @@ export async function findContentById(req, options, input) {
             id: input.documentId,
             depth: 0,
             locale: input.locale,
+            fallbackLocale: false,
             draft: true,
             req,
             user: req.user,

package/dist/endpoints/translation.d.ts

@@ -0,0 +1,11 @@
+import type { Endpoint } from "payload";
+import type { ValidatedEditorAssistantOptions } from "../config/validate.ts";
+/**
+ * Whether the open document has fields to translate, so the panel can offer it: the language they
+ * come from and how many, compared on the saved version. Read only, with the editor's access.
+ */
+export declare function createTranslationEndpoint(options: ValidatedEditorAssistantOptions): Endpoint;
+export type TranslationOffer = {
+    source?: string;
+    empty: number;
+};

package/dist/endpoints/translation.js

@@ -0,0 +1,56 @@
+import { hasCapability, resolveAllowlist } from "../domain/allowlist.js";
+import { findContentById } from "../domain/content.js";
+import { loadRichText } from "../form/rich-text.js";
+import { translationPaths } from "../form/translation.js";
+import { ENDPOINT_PREFIX } from "../package-name.js";
+import { sourceLocale } from "../runtime/translation-source.js";
+import { configuredDefaultLocale, configuredLocales, entityFields } from "../schema/discover.js";
+/**
+ * Whether the open document has fields to translate, so the panel can offer it: the language they
+ * come from and how many, compared on the saved version. Read only, with the editor's access.
+ */
+export function createTranslationEndpoint(options) {
+    return {
+        path: `${ENDPOINT_PREFIX}/translation`,
+        method: "get",
+        handler: async (req) => {
+            if (!req.user) {
+                return Response.json({ error: "unauthorized" }, { status: 401 });
+            }
+            if (options.enabled && !(await options.enabled({ userId: req.user.id }))) {
+                return Response.json({ error: "unavailable" }, { status: 403 });
+            }
+            const params = req.searchParams ?? new URL(req.url ?? "", "http://localhost").searchParams;
+            const target = {
+                collection: params.get("collection") ?? undefined,
+                global: params.get("global") ?? undefined,
+                documentId: params.get("id") ?? undefined,
+                locale: params.get("locale") ?? "",
+            };
+            return Response.json(await translationOffer(req, options, target));
+        },
+    };
+}
+async function translationOffer(req, options, target) {
+    const resolved = resolveAllowlist(options, target);
+    const source = sourceLocale({
+        open: target.locale,
+        locales: configuredLocales(req),
+        defaultLocale: configuredDefaultLocale(req),
+    });
+    if (!source ||
+        !resolved ||
+        !hasCapability(resolved.allowlist, "form.propose") ||
+        (target.collection && !target.documentId)) {
+        return { empty: 0 };
+    }
+    await loadRichText();
+    // One after the other: both reads share the request and its transaction.
+    const from = await findContentById(req, options, { ...target, locale: source });
+    const to = await findContentById(req, options, target);
+    if (!from.ok || !to.ok) {
+        return { empty: 0 };
+    }
+    const fields = entityFields(req, options, target);
+    return { source, empty: translationPaths(fields, to.data, from.data).empty.length };
+}

package/dist/form/empty.d.ts

@@ -1,2 +1 @@
 export declare function listEmptyTextPaths(data: Record<string, unknown>): string[];
-export declare function previewAtPath(data: Record<string, unknown>, path: string): string | undefined;

package/dist/form/empty.js

@@ -1,6 +1,5 @@
 import { isDeniedFieldName } from "../config/denied-fields.js";
 import { lexicalPlaintext } from "./lexical.js";
-import { getAtPath, parseFieldPath } from "./path.js";
 const SKIP = new Set(["id", "slug", "blockType", "_status", "parent"]);
 const MAX_PATHS = 12;
 export function listEmptyTextPaths(data) {
@@ -8,22 +7,6 @@ export function listEmptyTextPaths(data) {
     walk(data, "", paths);
     return paths;
 }
-export function previewAtPath(data, path) {
-    try {
-        const value = getAtPath(data, parseFieldPath(path));
-        if (typeof value === "string" && value.trim()) {
-            return truncate(value.trim());
-        }
-        if (value && typeof value === "object" && "root" in value) {
-            const text = lexicalPlaintext(value);
-            return text ? truncate(text) : undefined;
-        }
-    }
-    catch {
-        return undefined;
-    }
-    return undefined;
-}
 function walk(value, path, into) {
     if (into.length >= MAX_PATHS) {
         return;
@@ -56,6 +39,3 @@ function walk(value, path, into) {
         }
     }
 }
-function truncate(value) {
-    return value.length > 80 ? `${value.slice(0, 77)}…` : value;
-}

package/dist/form/translation.d.ts

@@ -0,0 +1,14 @@
+import type { FieldNode } from "../schema/fields.ts";
+/** Localized text in the open language, by whether the source language has text for it. */
+export type TranslationPaths = {
+    /** Filled in the source, empty here: what "translate" fills in. */
+    empty: string[];
+    /** Filled in both: what "translate again" replaces. */
+    translated: string[];
+};
+/**
+ * Localized text, textarea and rich text fields of the open form, with array and block indexes, that
+ * the source language has text for. Rich text may be Lexical (the form) or Markdown blocks (the
+ * source as the model reads it). Blocks whose type differs between the languages are skipped.
+ */
+export declare function translationPaths(fields: FieldNode[], form: Record<string, unknown>, source: Record<string, unknown>): TranslationPaths;

package/dist/form/translation.js

@@ -0,0 +1,81 @@
+import { isLexical, lexicalPlaintext } from "./lexical.js";
+const TEXT_TYPES = new Set(["text", "textarea", "richText"]);
+/**
+ * Localized text, textarea and rich text fields of the open form, with array and block indexes, that
+ * the source language has text for. Rich text may be Lexical (the form) or Markdown blocks (the
+ * source as the model reads it). Blocks whose type differs between the languages are skipped.
+ */
+export function translationPaths(fields, form, source) {
+    const paths = { empty: [], translated: [] };
+    walkFields(fields, source, form, { data: "", template: "" }, false, paths);
+    return paths;
+}
+function walkFields(fields, source, target, prefix, inherited, paths) {
+    for (const field of fields) {
+        const relative = prefix.template ? field.path.slice(prefix.template.length + 1) : field.path;
+        const path = prefix.data ? `${prefix.data}.${relative}` : relative;
+        const localized = inherited || Boolean(field.localized);
+        const from = child(source, relative);
+        const to = child(target, relative);
+        const nested = (data) => ({ data, template: field.path });
+        if (TEXT_TYPES.has(field.type)) {
+            if (localized && hasText(from)) {
+                (hasText(to) ? paths.translated : paths.empty).push(path);
+            }
+            continue;
+        }
+        if (field.type === "group") {
+            walkFields(field.fields ?? [], from, to, nested(path), localized, paths);
+            continue;
+        }
+        if (field.type !== "array" && field.type !== "blocks") {
+            continue;
+        }
+        const sourceRows = Array.isArray(from) ? from : [];
+        const targetRows = Array.isArray(to) ? to : [];
+        // A localized list that is empty here is one field to translate; its rows do not exist yet.
+        if (field.localized && sourceRows.length > 0 && targetRows.length === 0) {
+            paths.empty.push(path);
+            continue;
+        }
+        for (const [index, sourceRow] of sourceRows.entries()) {
+            const targetRow = targetRows[index];
+            if (!targetRow || typeof targetRow !== "object") {
+                continue;
+            }
+            const rowPath = `${path}.${index}`;
+            if (field.type === "array") {
+                walkFields(field.fields ?? [], sourceRow, targetRow, nested(rowPath), localized, paths);
+                continue;
+            }
+            const type = sourceRow.blockType;
+            if (typeof type !== "string" || targetRow.blockType !== type) {
+                continue;
+            }
+            const block = field.blocks?.find((entry) => entry.slug === type);
+            if (block) {
+                walkFields(block.fields, sourceRow, targetRow, nested(rowPath), localized, paths);
+            }
+        }
+    }
+}
+function child(value, path) {
+    let current = value;
+    for (const segment of path.split(".")) {
+        if (!current || typeof current !== "object") {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+function hasText(value) {
+    if (typeof value === "string") {
+        return value.trim().length > 0;
+    }
+    if (Array.isArray(value)) {
+        // Markdown blocks; a kept part (`{ keep }`) is not text to translate.
+        return value.some((block) => typeof block === "string" && block.trim().length > 0);
+    }
+    return isLexical(value) ? lexicalPlaintext(value).length > 0 : false;
+}

package/dist/plugin.js

@@ -6,6 +6,7 @@ import { createChatEndpoint } from "./endpoints/chat.js";
 import { createCsrfEndpoint } from "./endpoints/csrf.js";
 import { createDecideEndpoint } from "./endpoints/decide.js";
 import { createProposeEndpoint } from "./endpoints/propose.js";
+import { createTranslationEndpoint } from "./endpoints/translation.js";
 import { ADMIN_CUSTOM_KEY, CLIENT_ENTRY, DEFAULT_APPROVAL_SLUG } from "./package-name.js";
 export function editorAssistantPlugin(options = {}) {
     const validated = validateEditorAssistantOptions(options);
@@ -75,6 +76,7 @@ export function editorAssistantPlugin(options = {}) {
                 createChatEndpoint(validated),
                 createProposeEndpoint(validated),
                 createDecideEndpoint(validated),
+                createTranslationEndpoint(validated),
             ],
         };
     };

package/dist/runtime/context.d.ts

@@ -37,7 +37,14 @@ export type TurnContext = {
     form?: Record<string, unknown>;
     /** What the editor clicked or focused; "this" in their message refers to it. */
     selection?: Selection;
+    /** Other languages of the open document that have text of their own, as the model reads them. */
     otherLanguages?: Record<string, Record<string, unknown>>;
+    /** Localized text of the open form that the default language has text for. */
+    translation?: {
+        source: string;
+        empty: string[];
+        translated: string[];
+    };
     documents: Record<string, unknown>[];
 };
 export declare function loadTurnContext(req: PayloadRequest, options: ValidatedEditorAssistantOptions, bridge: ToolBridge, formData?: Record<string, unknown>): Promise<TurnContext>;

package/dist/runtime/context.js

@@ -1,7 +1,9 @@
 import { findContent, findContentById } from "../domain/content.js";
-import { configuredLocales, discoverSchema, entityFields, } from "../schema/discover.js";
+import { translationPaths } from "../form/translation.js";
+import { configuredDefaultLocale, configuredLocales, discoverSchema, entityFields, } from "../schema/discover.js";
 import { resolveSelection } from "./selection.js";
 import { executeTool } from "./tools.js";
+import { sourceLocale } from "./translation-source.js";
 export async function loadTurnContext(req, options, bridge, formData) {
     const ctx = { req, options, bridge, formData };
     const schema = discoverSchema(req, options);
@@ -17,15 +19,17 @@ export async function loadTurnContext(req, options, bridge, formData) {
     const form = open
         ? ((await readOpenForm(ctx)) ?? (await readSavedDocument(req, options, bridge)))
         : undefined;
-    const selection = open
-        ? resolveSelection(bridge.selection, form, entityFields(req, options, { collection: bridge.collection, global: bridge.global }))
-        : undefined;
+    const fields = open
+        ? entityFields(req, options, { collection: bridge.collection, global: bridge.global })
+        : [];
+    const selection = open ? resolveSelection(bridge.selection, form, fields) : undefined;
     const listed = await findContent(req, options, {
         collection: bridge.collection ?? (bridge.view?.kind === "list" ? bridge.view.collection : undefined),
         query: "",
         locale: bridge.locale,
     });
-    const otherLanguages = open ? await readOtherLanguages(req, options, bridge) : undefined;
+    const otherLanguages = open ? await readOtherLanguages(req, options, bridge, fields) : undefined;
+    const translation = form ? translationFor(req, bridge, fields, form, otherLanguages) : undefined;
     return {
         allowlist: schema.map(compactEntity),
         open,
@@ -33,6 +37,7 @@ export async function loadTurnContext(req, options, bridge, formData) {
         form,
         selection,
         otherLanguages,
+        translation,
         documents: listed.ok ? listed.results : [],
     };
 }
@@ -57,7 +62,7 @@ async function readSavedDocument(req, options, bridge) {
     }
     return result.data;
 }
-async function readOtherLanguages(req, options, bridge) {
+async function readOtherLanguages(req, options, bridge, fields) {
     const locales = configuredLocales(req).filter((code) => code !== bridge.locale);
     if (locales.length === 0) {
         return undefined;
@@ -70,7 +75,8 @@ async function readOtherLanguages(req, options, bridge) {
             documentId: bridge.documentId,
             locale,
         });
-        if (result.ok && Object.keys(result.data).length > 0) {
+        // A language nobody wrote in yet is left out: it has nothing to translate from.
+        if (result.ok && translationPaths(fields, {}, result.data).empty.length > 0) {
             otherLanguages[locale] = result.data;
         }
     }
@@ -100,3 +106,15 @@ function compactField(field) {
         relationTo: field.type === "upload" || field.type === "relationship" ? field.relationTo : undefined,
     };
 }
+function translationFor(req, bridge, fields, form, otherLanguages) {
+    const source = sourceLocale({
+        open: bridge.locale,
+        locales: configuredLocales(req),
+        defaultLocale: configuredDefaultLocale(req),
+    });
+    const data = source ? otherLanguages?.[source] : undefined;
+    if (!source || !data) {
+        return undefined;
+    }
+    return { source, ...translationPaths(fields, form, data) };
+}

package/dist/runtime/system-prompt.js

@@ -1,4 +1,4 @@
-import { listEmptyTextPaths, previewAtPath } from "../form/empty.js";
+import { listEmptyTextPaths } from "../form/empty.js";
 export function buildSystemPrompt(instructions, bridge, turnContext) {
     const base = [
         "You are a colleague helping a content editor. They are not a developer.",
@@ -30,7 +30,7 @@ function openDocumentLine(bridge, turnContext) {
         const title = bridge.title ? `"${bridge.title}"` : "the open document";
         const language = languageName(bridge.locale);
         const sources = turnContext?.otherLanguages
-            ? " Other language versions of this same page are in the quoted context. If the editor asks to fill or translate empty fields, call form.propose with text written in the open language. Translate from the source language; do not copy the source wording unless they asked to copy it unchanged. Do not ask them to paste. Do not say the source is missing if it is in the context. If a layout block already exists, set its empty text fields; do not insert a new block."
+            ? " Other language versions of this same page are in the quoted context under otherLanguages. Do not ask the editor to paste them, and do not say a source is missing if it is there."
             : "";
         return `The editor is looking at ${title} in ${language}. Do not ask them which document it is.${sources}${imageLine(bridge, turnContext)}${selectionLine(turnContext)}`;
     }
@@ -111,34 +111,44 @@ function thisTurnBlock(bridge, turnContext) {
         const empty = listEmptyTextPaths(form);
         if (empty.length > 0) {
             lines.push(`Empty fields: ${empty.join(", ")}.`);
-            const source = sourceLine(turnContext?.otherLanguages, empty);
-            if (source) {
-                lines.push(source);
-            }
             lines.push("Fill them only when the editor asks for that (fill in, translate, write, fyll i, översätt). A greeting, a question or small talk is not such a request: answer it and propose nothing. When they do ask, call form.propose now with text in the open language. Do not ask.");
         }
     }
+    const translation = translationLines(bridge, turnContext);
+    if (translation) {
+        lines.push(translation);
+    }
     return `\n\n${lines.join(" ")}`;
 }
-function sourceLine(otherLanguages, empty) {
-    if (!otherLanguages) {
+const MAX_LISTED_PATHS = 60;
+/** What a translation fills in, from which language, and how rich text and shared fields go. */
+function translationLines(bridge, turnContext) {
+    const translation = turnContext?.translation;
+    if (!translation || (!translation.empty.length && !translation.translated.length)) {
         return undefined;
     }
-    const preferred = otherLanguages.en
-        ? ["en", otherLanguages.en]
-        : Object.entries(otherLanguages)[0];
-    if (!preferred) {
-        return undefined;
+    const source = languageName(translation.source);
+    const target = languageName(bridge?.locale ?? turnContext?.open?.locale);
+    const lines = [];
+    if (translation.empty.length) {
+        lines.push(`Not translated from ${source} yet (${translation.empty.length} fields): ${listPaths(translation.empty)}.`);
     }
-    const [code, data] = preferred;
-    const parts = empty.flatMap((path) => {
-        const preview = previewAtPath(data, path);
-        return preview ? [`${path}=${JSON.stringify(preview)}`] : [];
-    });
-    if (parts.length === 0) {
-        return undefined;
+    if (translation.translated.length) {
+        lines.push(`Already translated: ${listPaths(translation.translated)}.`);
     }
-    return `${languageName(code)} source: ${parts.join("; ")}.`;
+    lines.push(`The ${source} text is in the quoted context under otherLanguages.${translation.source}. When the editor asks to translate (translate, översätt, fyll i), translate from ${source} into ${target} and set every field not translated yet, all in one form.propose. Leave already translated fields as they are unless the editor asks to translate them again; then replace those too. Translate; do not copy the ${source} wording. Rich text: set the whole field to a list of Markdown blocks, one per ${source} block, keeping headings, lists, bold, italic and links, with link addresses unchanged. A ${source} block shown as { "keep" } cannot be copied: leave it out and say so. Never change fields that are not listed here, and never add, move or remove blocks or rows. Do not ask.`);
+    const chat = languageName(bridge?.language ?? bridge?.locale);
+    if (chat !== target) {
+        // Asked to translate into one language, models also replied in it.
+        lines.push(`Write your reply in ${chat}; only the field values are in ${target}.`);
+    }
+    return lines.join(" ");
+}
+function listPaths(paths) {
+    const listed = paths.slice(0, MAX_LISTED_PATHS).join(", ");
+    return paths.length > MAX_LISTED_PATHS
+        ? `${listed} and ${paths.length - MAX_LISTED_PATHS} more`
+        : listed;
 }
 function languageName(code) {
     if (code === "sv" || code?.startsWith("sv-")) {

package/dist/runtime/translation-source.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The language a translation comes from: the project's default one, unless that is the language
+ * already open. An editor who wants another source names it; the model reads it with
+ * `content.findById`.
+ */
+export declare function sourceLocale(input: {
+    open: string;
+    locales: string[];
+    defaultLocale: string | undefined;
+}): string | undefined;

package/dist/runtime/translation-source.js

@@ -0,0 +1,12 @@
+/**
+ * The language a translation comes from: the project's default one, unless that is the language
+ * already open. An editor who wants another source names it; the model reads it with
+ * `content.findById`.
+ */
+export function sourceLocale(input) {
+    const { defaultLocale } = input;
+    if (!defaultLocale || defaultLocale === input.open || !input.locales.includes(defaultLocale)) {
+        return undefined;
+    }
+    return defaultLocale;
+}

package/dist/runtime/voice.js

@@ -20,7 +20,7 @@ export function editorFacingText(input) {
 }
 export function stripInternalSpeech(text, locale) {
     const swedish = isSwedish(locale);
-    const kept = splitSentences(text).filter((sentence) => {
+    return keepSentences(text, (sentence) => {
         if (INTERNAL.test(sentence)) {
             return false;
         }
@@ -29,17 +29,13 @@ export function stripInternalSpeech(text, locale) {
         }
         return true;
     });
-    return kept.join(" ").replace(/\s+/g, " ").trim();
 }
 /** Keeping, saving and publishing are the editor's; a sentence that claims or asks for them goes. */
 const OVERCLAIM = /godkänn|godkann|approve|spara|sparat|sparad|sparats|publicer|\bsaved?\b|publish|behåll|\bkeep\b|klicka|\bclick|(?:^|\s)är nu\b|\bis now\b/i;
 const MAX_OWN_TEXT = 600;
 export function withoutOverclaims(text) {
-    const kept = splitSentences(text)
-        // A quoted proposal ("Spara 20 %") is the editor's content, not a claim about the panel.
-        .filter((sentence) => !OVERCLAIM.test(withoutQuotes(sentence)))
-        .join(" ")
-        .trim();
+    // A quoted proposal ("Spara 20 %") is the editor's content, not a claim about the panel.
+    const kept = keepSentences(text, (sentence) => !OVERCLAIM.test(withoutQuotes(sentence)));
     return kept.length <= MAX_OWN_TEXT ? kept : "";
 }
 export function approvalCopy(locale, capability) {
@@ -65,6 +61,23 @@ function isSwedish(locale) {
 }
 const QUOTES = '"“”„«»';
 const QUOTED = /["“”„«»][^"“”„«»]*["“”„«»]/g;
+/**
+ * The sentences that pass `keep`, line by line: the panel shows the reply's Markdown, so its line
+ * breaks, lists and blank lines between paragraphs stay. A line that loses every sentence goes.
+ */
+function keepSentences(text, keep) {
+    return text
+        .split(/\r?\n/)
+        .flatMap((line) => {
+        if (line.trim() === "")
+            return [""];
+        const kept = splitSentences(line).filter(keep).join(" ");
+        return kept ? [kept.replace(/[ \t]+/g, " ")] : [];
+    })
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
 /**
  * Sentences, keeping a quoted proposal ("Click. Edit. Done.") inside the sentence that quotes it.
  * A line with an unclosed quote is split as if it had none, so the quote cannot hide a claim.

package/dist/schema/discover.d.ts

@@ -32,4 +32,6 @@ export declare function entityFields(req: PayloadRequest, options: ValidatedEdit
     global?: string;
 }): FieldNode[];
 export declare function hasDrafts(versions: unknown): boolean;
+/** Payload's `localization.defaultLocale`, when the project is localized. */
+export declare function configuredDefaultLocale(req: PayloadRequest): string | undefined;
 export declare function configuredLocales(req: PayloadRequest): string[];

package/dist/schema/discover.js

@@ -71,6 +71,15 @@ export function hasDrafts(versions) {
 function asString(value) {
     return typeof value === "string" && value.trim() ? value : undefined;
 }
+/** Payload's `localization.defaultLocale`, when the project is localized. */
+export function configuredDefaultLocale(req) {
+    const localization = req.payload.config.localization;
+    if (!localization || typeof localization !== "object") {
+        return undefined;
+    }
+    const code = localization.defaultLocale;
+    return typeof code === "string" && code ? code : undefined;
+}
 export function configuredLocales(req) {
     const localization = req.payload.config.localization;
     if (!localization || typeof localization !== "object") {

package/dist/styles/assistant.css

@@ -108,7 +108,7 @@ html[data-theme="dark"] .ea-aside {
   gap: calc(var(--base) * 0.8);
 }
 
-/* The assistant writes plain text, the editor's messages sit in a quiet bubble. */
+/* The assistant's replies sit on the panel, the editor's messages in a quiet bubble. */
 .ea-msg {
   max-width: 100%;
   line-height: 1.5;
@@ -128,6 +128,35 @@ html[data-theme="dark"] .ea-aside {
   align-self: flex-start;
 }
 
+/* A reply's Markdown: paragraphs and lists spaced like the thread, a line break kept inside one. */
+.ea-reply__p,
+.ea-reply__list {
+  margin: 0;
+}
+
+.ea-reply__p + .ea-reply__p,
+.ea-reply__p + .ea-reply__list,
+.ea-reply__list + .ea-reply__p,
+.ea-reply__list + .ea-reply__list {
+  margin-top: calc(var(--base) * 0.5);
+}
+
+.ea-reply__list {
+  padding-inline-start: calc(var(--base) * 1.2);
+  white-space: normal;
+}
+
+.ea-reply__list li + li {
+  margin-top: calc(var(--base) * 0.2);
+}
+
+.ea-msg code {
+  font-size: 0.9em;
+  padding: 0 0.25em;
+  border-radius: var(--style-radius-s);
+  background: var(--theme-elevation-100);
+}
+
 .ea-msg--system {
   color: var(--theme-elevation-500);
   font-size: 12px;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simmalugnt-se/payload-editor-assistant",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Context-aware editor assistant plugin for Payload Admin",
   "keywords": [
     "payload",