@simmalugnt-se/payload-editor-assistant 0.1.0

package/dist/endpoints/chat.js

@@ -0,0 +1,88 @@
+import { ENDPOINT_PREFIX } from "../package-name.js";
+import { runAgentTurn } from "../runtime/agent.js";
+import { beginInflight, endInflight } from "../runtime/inflight.js";
+import { resolveChatLanguage } from "../runtime/language.js";
+import { consumeRateLimit } from "../runtime/rate-limit.js";
+import { sanitizeAdminView } from "../view.js";
+import { verifyCsrf, verifyOrigin } from "./csrf.js";
+export function createChatEndpoint(options) {
+    return {
+        path: `${ENDPOINT_PREFIX}/chat`,
+        method: "post",
+        handler: async (req) => {
+            if (!req.user) {
+                return Response.json({ error: "unauthorized" }, { status: 401 });
+            }
+            if (!verifyOrigin(req, options.trustedOrigins) || !verifyCsrf(req)) {
+                return Response.json({ error: "unauthorized" }, { status: 403 });
+            }
+            if (options.enabled && !(await options.enabled({ userId: req.user.id }))) {
+                return Response.json({ error: "unavailable" }, { status: 403 });
+            }
+            const actor = String(req.user.id);
+            if (!consumeRateLimit(actor)) {
+                return Response.json({ error: "rate_limited" }, { status: 429 });
+            }
+            if (!beginInflight(actor)) {
+                return Response.json({ error: "rate_limited" }, { status: 429 });
+            }
+            try {
+                let body;
+                try {
+                    if (typeof req.json !== "function") {
+                        return Response.json({ error: "tool_denied" }, { status: 400 });
+                    }
+                    body = (await req.json());
+                }
+                catch {
+                    return Response.json({ error: "tool_denied" }, { status: 400 });
+                }
+                if (typeof body.message !== "string" || body.message.trim() === "") {
+                    return Response.json({ error: "tool_denied" }, { status: 400 });
+                }
+                const locale = nonEmpty(body.bridge?.locale) ?? nonEmpty(body.locale) ?? defaultLocale(req);
+                const messages = Array.isArray(body.messages)
+                    ? body.messages.filter(isChatMessage)
+                    : [{ role: "user", text: body.message }];
+                const language = resolveChatLanguage(messages.filter((message) => message.role === "user").map((message) => message.text), nonEmpty(body.uiLanguage));
+                const result = await runAgentTurn(req, options, {
+                    message: body.message,
+                    messages,
+                    bridge: {
+                        collection: body.bridge?.collectionSlug,
+                        global: body.bridge?.globalSlug,
+                        documentId: body.bridge?.documentId,
+                        title: typeof body.bridge?.title === "string" ? body.bridge.title : undefined,
+                        locale,
+                        language,
+                        view: sanitizeAdminView(body.view, options),
+                    },
+                    formData: body.formData,
+                });
+                if (!result.ok) {
+                    const status = result.error === "timeout" ? 504 : 503;
+                    return Response.json({ error: result.error, message: result.message }, { status });
+                }
+                return Response.json({ ...result, language });
+            }
+            finally {
+                endInflight(actor);
+            }
+        },
+    };
+}
+function nonEmpty(value) {
+    return typeof value === "string" && value.trim() ? value : undefined;
+}
+function defaultLocale(req) {
+    const localization = req.payload.config.localization;
+    return (localization && localization.defaultLocale) || "en";
+}
+function isChatMessage(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const record = value;
+    return ((record.role === "user" || record.role === "assistant" || record.role === "system") &&
+        typeof record.text === "string");
+}

package/dist/endpoints/csrf.d.ts

@@ -0,0 +1,6 @@
+import type { Endpoint, PayloadRequest } from "payload";
+import { CSRF_COOKIE, CSRF_HEADER } from "../package-name.ts";
+export declare function createCsrfEndpoint(): Endpoint;
+export declare function verifyCsrf(req: PayloadRequest): boolean;
+export declare function verifyOrigin(req: PayloadRequest, trustedOrigins: string[]): boolean;
+export { CSRF_COOKIE, CSRF_HEADER };

package/dist/endpoints/csrf.js

@@ -0,0 +1,57 @@
+import { CSRF_COOKIE, CSRF_HEADER, ENDPOINT_PREFIX } from "../package-name.js";
+export function createCsrfEndpoint() {
+    return {
+        path: `${ENDPOINT_PREFIX}/csrf`,
+        method: "get",
+        handler: async (req) => {
+            if (!req.user) {
+                return Response.json({ error: "unauthorized" }, { status: 401 });
+            }
+            const token = crypto.randomUUID();
+            const proto = req.headers.get("x-forwarded-proto") ?? req.headers.get("origin") ?? "";
+            const secure = proto.includes("https");
+            const cookie = `${CSRF_COOKIE}=${token}; Path=/; SameSite=Lax; HttpOnly${secure ? "; Secure" : ""}`;
+            return new Response(JSON.stringify({ token, header: CSRF_HEADER }), {
+                status: 200,
+                headers: {
+                    "Content-Type": "application/json",
+                    "Set-Cookie": cookie,
+                },
+            });
+        },
+    };
+}
+export function verifyCsrf(req) {
+    const header = req.headers.get(CSRF_HEADER);
+    const cookie = readCookie(req.headers.get("cookie"), CSRF_COOKIE);
+    return Boolean(header && cookie && header === cookie);
+}
+export function verifyOrigin(req, trustedOrigins) {
+    const origin = req.headers.get("origin");
+    if (!origin) {
+        return false;
+    }
+    if (trustedOrigins.length > 0) {
+        return trustedOrigins.includes(origin);
+    }
+    const host = req.headers.get("host");
+    try {
+        return new URL(origin).host === host;
+    }
+    catch {
+        return false;
+    }
+}
+function readCookie(header, name) {
+    if (!header) {
+        return undefined;
+    }
+    for (const part of header.split(";")) {
+        const [key, ...rest] = part.trim().split("=");
+        if (key === name) {
+            return rest.join("=");
+        }
+    }
+    return undefined;
+}
+export { CSRF_COOKIE, CSRF_HEADER };

package/dist/endpoints/decide.d.ts

@@ -0,0 +1,3 @@
+import type { Endpoint } from "payload";
+import type { ValidatedEditorAssistantOptions } from "../config/validate.ts";
+export declare function createDecideEndpoint(options: ValidatedEditorAssistantOptions): Endpoint;

package/dist/endpoints/decide.js

@@ -0,0 +1,33 @@
+import { decideChange } from "../domain/decide.js";
+import { guardMutationRequest, readJsonBody } from "../domain/guard.js";
+import { ENDPOINT_PREFIX } from "../package-name.js";
+export function createDecideEndpoint(options) {
+    return {
+        path: `${ENDPOINT_PREFIX}/decide`,
+        method: "post",
+        handler: async (req) => {
+            const guard = await guardMutationRequest(req, options);
+            if (!guard.ok) {
+                return Response.json({ error: guard.error }, { status: guard.status });
+            }
+            const body = await readJsonBody(req);
+            if (!body?.action || !body.approvalId || !body.nonce || !body.locale) {
+                return Response.json({ error: "tool_denied" }, { status: 400 });
+            }
+            const result = await decideChange(req, options, {
+                action: body.action,
+                approvalId: body.approvalId,
+                nonce: body.nonce,
+                collection: body.collection,
+                global: body.global,
+                documentId: body.documentId,
+                locale: body.locale,
+                formData: body.formData,
+            });
+            if (!result.ok) {
+                return Response.json({ error: result.error, message: result.message }, { status: 400 });
+            }
+            return Response.json(result);
+        },
+    };
+}

package/dist/endpoints/propose.d.ts

@@ -0,0 +1,3 @@
+import type { Endpoint } from "payload";
+import type { ValidatedEditorAssistantOptions } from "../config/validate.ts";
+export declare function createProposeEndpoint(options: ValidatedEditorAssistantOptions): Endpoint;

package/dist/endpoints/propose.js

@@ -0,0 +1,32 @@
+import { guardMutationRequest, readJsonBody } from "../domain/guard.js";
+import { proposeChange } from "../domain/propose.js";
+import { ENDPOINT_PREFIX } from "../package-name.js";
+export function createProposeEndpoint(options) {
+    return {
+        path: `${ENDPOINT_PREFIX}/propose`,
+        method: "post",
+        handler: async (req) => {
+            const guard = await guardMutationRequest(req, options);
+            if (!guard.ok) {
+                return Response.json({ error: guard.error }, { status: guard.status });
+            }
+            const body = await readJsonBody(req);
+            if (!body?.capability || !body.locale) {
+                return Response.json({ error: "tool_denied" }, { status: 400 });
+            }
+            const result = await proposeChange(req, options, {
+                capability: body.capability,
+                collection: body.collection,
+                global: body.global,
+                documentId: body.documentId,
+                locale: body.locale,
+                operations: body.operations,
+                formData: body.formData,
+            });
+            if (!result.ok) {
+                return Response.json({ error: result.error, message: result.message }, { status: 400 });
+            }
+            return Response.json(result);
+        },
+    };
+}

package/dist/exports/client.d.ts

@@ -0,0 +1,4 @@
+export { EditorAssistantAction } from "../components/EditorAssistantAction.tsx";
+export { EditorAssistantAside } from "../components/EditorAssistantAside.tsx";
+export { EditorAssistantDocumentBridge } from "../components/EditorAssistantDocumentBridge.tsx";
+export { EditorAssistantProvider } from "../components/EditorAssistantProvider.tsx";

package/dist/exports/client.js

@@ -0,0 +1,4 @@
+export { EditorAssistantAction } from "../components/EditorAssistantAction.js";
+export { EditorAssistantAside } from "../components/EditorAssistantAside.js";
+export { EditorAssistantDocumentBridge } from "../components/EditorAssistantDocumentBridge.js";
+export { EditorAssistantProvider } from "../components/EditorAssistantProvider.js";

package/dist/form/compile.d.ts

@@ -0,0 +1,17 @@
+import type { FieldAllowlist } from "../types.ts";
+export type CompileFailure = {
+    ok: false;
+    error: string;
+};
+export type CompileSuccess = {
+    ok: true;
+    data: Record<string, unknown>;
+};
+export type CompileResult = CompileSuccess | CompileFailure;
+type CompileOptions = {
+    allowlist: FieldAllowlist | undefined;
+    denyFields: string[];
+    generateId?: () => string;
+};
+export declare function compileOperations(current: Record<string, unknown>, operations: unknown, options: CompileOptions): CompileResult;
+export {};

package/dist/form/compile.js

@@ -0,0 +1,168 @@
+import { isDeniedFieldName } from "../config/denied-fields.js";
+import { isFormOperation } from "./operations.js";
+import { cloneData, getAtPath, parseFieldPath, setAtPath } from "./path.js";
+export function compileOperations(current, operations, options) {
+    if (!Array.isArray(operations) || operations.length === 0) {
+        return { ok: false, error: "A proposal must include at least one operation." };
+    }
+    const next = cloneData(current);
+    const generateId = options.generateId ?? (() => crypto.randomUUID());
+    try {
+        for (const raw of operations) {
+            if (!isFormOperation(raw)) {
+                return { ok: false, error: "Unknown or invalid operation." };
+            }
+            const result = applyOperation(next, raw, options, generateId);
+            if (!result.ok) {
+                return result;
+            }
+        }
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : "Failed to compile operations.",
+        };
+    }
+    return { ok: true, data: next };
+}
+function applyOperation(data, operation, options, generateId) {
+    const path = "path" in operation ? parseFieldPath(operation.path) : [];
+    assertWritablePath(path, options);
+    switch (operation.op) {
+        case "set":
+            if (isLocaleMap(operation.value)) {
+                return {
+                    ok: false,
+                    error: "Localized maps are not accepted; use the current locale value.",
+                };
+            }
+            setAtPath(data, path, operation.value);
+            return { ok: true, data };
+        case "unset":
+            unsetAtPath(data, path);
+            return { ok: true, data };
+        case "array.insert":
+            insertAt(data, path, operation.index, cloneData(operation.value), false, generateId);
+            return { ok: true, data };
+        case "array.replace":
+            replaceAt(data, path, operation.index, cloneData(operation.value), false, generateId);
+            return { ok: true, data };
+        case "array.remove":
+            removeAt(data, path, operation.index);
+            return { ok: true, data };
+        case "array.move":
+            moveAt(data, path, operation.from, operation.to);
+            return { ok: true, data };
+        case "blocks.insert":
+            insertAt(data, path, operation.index, { ...stripId(operation.data), blockType: operation.blockType, id: generateId() }, true, generateId);
+            return { ok: true, data };
+        case "blocks.replace":
+            replaceAt(data, path, operation.index, { ...stripId(operation.data), blockType: operation.blockType, id: generateId() }, true, generateId);
+            return { ok: true, data };
+        case "blocks.remove":
+            removeAt(data, path, operation.index);
+            return { ok: true, data };
+        case "blocks.move":
+            moveAt(data, path, operation.from, operation.to);
+            return { ok: true, data };
+        default:
+            return { ok: false, error: "Unknown or invalid operation." };
+    }
+}
+function assertWritablePath(path, options) {
+    if (path.length === 0) {
+        throw new Error("A field path is required.");
+    }
+    const root = path[0];
+    if (typeof root !== "string") {
+        throw new Error("A field path must start with a field name.");
+    }
+    if (isDeniedFieldName(root) || options.denyFields.includes(root)) {
+        throw new Error(`Field "${root}" is not writable.`);
+    }
+    const allowlist = options.allowlist;
+    if (allowlist && allowlist !== true) {
+        if ("include" in allowlist) {
+            const allowed = allowlist.include.some((entry) => entry === root || entry === path.join(".") || path.join(".").startsWith(`${entry}.`));
+            if (!allowed) {
+                throw new Error(`Field "${root}" is not allowlisted.`);
+            }
+        }
+        if ("exclude" in allowlist && allowlist.exclude.includes(root)) {
+            throw new Error(`Field "${root}" is not writable.`);
+        }
+    }
+    for (const segment of path) {
+        if (typeof segment === "string" && isDeniedFieldName(segment)) {
+            throw new Error(`Field "${segment}" is not writable.`);
+        }
+    }
+}
+function requireArray(data, path) {
+    const value = getAtPath(data, path);
+    if (!Array.isArray(value)) {
+        throw new Error(`Field "${path.join(".")}" is not an array.`);
+    }
+    return value;
+}
+function insertAt(data, path, index, value, _isBlock, _generateId) {
+    // New drafts start empty, so the first insert creates the list.
+    if (getAtPath(data, path) === undefined) {
+        setAtPath(data, path, []);
+    }
+    const list = requireArray(data, path);
+    if (index < 0 || index > list.length) {
+        throw new Error("Array index is out of bounds.");
+    }
+    list.splice(index, 0, value);
+}
+function replaceAt(data, path, index, value, _isBlock, _generateId) {
+    const list = requireArray(data, path);
+    if (index < 0 || index >= list.length) {
+        throw new Error("Array index is out of bounds.");
+    }
+    list[index] = value;
+}
+function removeAt(data, path, index) {
+    const list = requireArray(data, path);
+    if (index < 0 || index >= list.length) {
+        throw new Error("Array index is out of bounds.");
+    }
+    list.splice(index, 1);
+}
+function moveAt(data, path, from, to) {
+    const list = requireArray(data, path);
+    if (from < 0 || from >= list.length || to < 0 || to >= list.length) {
+        throw new Error("Array index is out of bounds.");
+    }
+    const [item] = list.splice(from, 1);
+    list.splice(to, 0, item);
+}
+function unsetAtPath(data, path) {
+    const parentPath = path.slice(0, -1);
+    const last = path[path.length - 1];
+    const parent = parentPath.length === 0 ? data : getAtPath(data, parentPath);
+    if (typeof last === "number") {
+        if (!Array.isArray(parent)) {
+            throw new Error("Path expected an array.");
+        }
+        parent.splice(last, 1);
+        return;
+    }
+    if (typeof parent !== "object" || parent === null || Array.isArray(parent)) {
+        throw new Error("Path expected an object.");
+    }
+    delete parent[last];
+}
+function stripId(data) {
+    const { id: _id, blockType: _blockType, ...rest } = data;
+    return rest;
+}
+function isLocaleMap(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const keys = Object.keys(value);
+    return keys.length > 0 && keys.every((key) => /^[a-z]{2}(-[A-Z]{2})?$/.test(key));
+}

package/dist/form/diff.d.ts

@@ -0,0 +1,9 @@
+import type { FormOperation } from "./operations.ts";
+export type HumanDiffLine = {
+    path: string;
+    text: string;
+};
+export type DiffLanguage = "sv" | "en";
+export declare function humanDiff(current: Record<string, unknown>, operations: FormOperation[], language?: DiffLanguage): HumanDiffLine[];
+/** Sub-lines are indented two spaces; the approval panel nests them under the header. */
+export declare const DIFF_SUBLINE_INDENT = "  ";

package/dist/form/diff.js

@@ -0,0 +1,155 @@
+import { getAtPath, parseFieldPath } from "./path.js";
+const COPY = {
+    en: {
+        empty: "empty",
+        clear: (field) => `Clear ${field}`,
+        addItem: (n, field) => `Add item at position ${n} in ${field}`,
+        removeItem: (n, field) => `Remove item ${n} from ${field}`,
+        moveItem: (from, to, field) => `Move item ${from} to ${to} in ${field}`,
+        replaceItem: (n, field) => `Replace item ${n} in ${field}`,
+        addBlock: (block, n) => `Add ${block} block at position ${n}`,
+        removeBlock: (n, field) => `Remove block ${n} from ${field}`,
+        moveBlock: (from, to) => `Move block ${from} to ${to}`,
+        replaceBlock: (n, block) => `Replace block ${n} with ${block}`,
+        unknown: "Unknown change",
+    },
+    sv: {
+        empty: "tomt",
+        clear: (field) => `Töm ${field}`,
+        addItem: (n, field) => `Lägg till rad ${n} i ${field}`,
+        removeItem: (n, field) => `Ta bort rad ${n} från ${field}`,
+        moveItem: (from, to, field) => `Flytta rad ${from} till ${to} i ${field}`,
+        replaceItem: (n, field) => `Ersätt rad ${n} i ${field}`,
+        addBlock: (block, n) => `Lägg till blocket ${block} på plats ${n}`,
+        removeBlock: (n, field) => `Ta bort block ${n} från ${field}`,
+        moveBlock: (from, to) => `Flytta block ${from} till ${to}`,
+        replaceBlock: (n, block) => `Ersätt block ${n} med ${block}`,
+        unknown: "Okänd ändring",
+    },
+};
+const HEADER_PREVIEW = 80;
+const FIELD_PREVIEW = 300;
+export function humanDiff(current, operations, language = "en") {
+    const copy = COPY[language];
+    return operations.map((operation) => {
+        switch (operation.op) {
+            case "set": {
+                const before = getAtPath(current, parseFieldPath(operation.path));
+                return {
+                    path: operation.path,
+                    text: `${label(operation.path)}: ${preview(before, copy)} → ${preview(operation.value, copy)}`,
+                };
+            }
+            case "unset":
+                return { path: operation.path, text: copy.clear(label(operation.path)) };
+            case "array.insert":
+                return {
+                    path: operation.path,
+                    text: withFields(copy.addItem(operation.index + 1, label(operation.path)), operation.value, copy),
+                };
+            case "array.remove":
+                return {
+                    path: operation.path,
+                    text: copy.removeItem(operation.index + 1, label(operation.path)),
+                };
+            case "array.move":
+                return {
+                    path: operation.path,
+                    text: copy.moveItem(operation.from + 1, operation.to + 1, label(operation.path)),
+                };
+            case "array.replace":
+                return {
+                    path: operation.path,
+                    text: withFields(copy.replaceItem(operation.index + 1, label(operation.path)), operation.value, copy),
+                };
+            case "blocks.insert":
+                return {
+                    path: operation.path,
+                    text: withFields(copy.addBlock(blockName(operation.blockType), operation.index + 1), operation.data, copy),
+                };
+            case "blocks.remove":
+                return {
+                    path: operation.path,
+                    text: copy.removeBlock(operation.index + 1, label(operation.path)),
+                };
+            case "blocks.move":
+                return { path: operation.path, text: copy.moveBlock(operation.from + 1, operation.to + 1) };
+            case "blocks.replace":
+                return {
+                    path: operation.path,
+                    text: withFields(copy.replaceBlock(operation.index + 1, blockName(operation.blockType)), operation.data, copy),
+                };
+            default:
+                return { path: "", text: copy.unknown };
+        }
+    });
+}
+/** Sub-lines are indented two spaces; the approval panel nests them under the header. */
+export const DIFF_SUBLINE_INDENT = "  ";
+function withFields(header, value, copy) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return header;
+    }
+    const lines = Object.entries(value)
+        .filter(([key, field]) => key !== "id" && key !== "blockType" && !isEmpty(field))
+        .map(([key, field]) => `${DIFF_SUBLINE_INDENT}${label(key)}: ${preview(field, copy, FIELD_PREVIEW)}`);
+    return [header, ...lines].join("\n");
+}
+function blockName(blockType) {
+    const words = blockType
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[-_]+/g, " ")
+        .toLowerCase();
+    return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function label(path) {
+    const segments = path.split(".").filter((segment) => !/^\d+$/.test(segment));
+    const last = segments.at(-1) ?? path;
+    return last.charAt(0).toUpperCase() + last.slice(1);
+}
+function isEmpty(value) {
+    return (value === undefined ||
+        value === null ||
+        value === "" ||
+        (isLexical(value) && !lexicalPlaintext(value)));
+}
+function preview(value, copy, max = HEADER_PREVIEW) {
+    if (isEmpty(value)) {
+        return copy.empty;
+    }
+    if (typeof value === "string") {
+        return truncate(value, max);
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    if (isLexical(value)) {
+        return truncate(lexicalPlaintext(value), max);
+    }
+    return truncate(JSON.stringify(value), max);
+}
+function isLexical(value) {
+    return Boolean(value && typeof value === "object" && "root" in value);
+}
+function lexicalPlaintext(value) {
+    const texts = [];
+    const visit = (node) => {
+        if (!node || typeof node !== "object") {
+            return;
+        }
+        const record = node;
+        if (typeof record.text === "string") {
+            texts.push(record.text);
+        }
+        if (Array.isArray(record.children)) {
+            for (const child of record.children) {
+                visit(child);
+            }
+        }
+    };
+    visit(value.root);
+    return texts.join(" ").trim();
+}
+function truncate(value, max) {
+    return value.length > max ? `${value.slice(0, max - 1)}…` : value;
+}

package/dist/form/empty.d.ts

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,79 @@
+import { isDeniedFieldName } from "../config/denied-fields.js";
+import { getAtPath, parseFieldPath } from "./path.js";
+const SKIP = new Set(["id", "slug", "blockType", "_status", "parent"]);
+const MAX_PATHS = 12;
+export function listEmptyTextPaths(data) {
+    const paths = [];
+    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;
+    }
+    const leaf = path.split(".").at(-1) ?? "";
+    if (leaf && (SKIP.has(leaf) || isDeniedFieldName(leaf))) {
+        return;
+    }
+    if (typeof value === "string") {
+        if (value.trim() === "" && path) {
+            into.push(path);
+        }
+        return;
+    }
+    if (value && typeof value === "object" && "root" in value) {
+        if (path && lexicalPlaintext(value) === "") {
+            into.push(path);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((item, index) => {
+            walk(item, path ? `${path}.${index}` : String(index), into);
+        });
+        return;
+    }
+    if (value && typeof value === "object") {
+        for (const [key, child] of Object.entries(value)) {
+            walk(child, path ? `${path}.${key}` : key, into);
+        }
+    }
+}
+function lexicalPlaintext(value) {
+    const texts = [];
+    const visit = (node) => {
+        if (!node || typeof node !== "object") {
+            return;
+        }
+        const record = node;
+        if (typeof record.text === "string") {
+            texts.push(record.text);
+        }
+        if (Array.isArray(record.children)) {
+            for (const child of record.children) {
+                visit(child);
+            }
+        }
+    };
+    visit(value.root);
+    return texts.join(" ").trim();
+}
+function truncate(value) {
+    return value.length > 80 ? `${value.slice(0, 77)}…` : value;
+}