@cosmicdrift/kumiko-bundled-features 0.374.0 → 0.377.0

package/dist/template-resolver/document-ops.js

@@ -0,0 +1,390 @@
+import { getSchema } from "@tiptap/core";
+import * as z from "zod";
+import { documentBlocksForKind } from "./document-blocks.js";
+import { DOCUMENT_TEXT_ALIGNMENTS, documentExtensions, isDocumentPlaceholderHref, isDocumentReferenceName, isDocumentResourceKey, } from "./document-schema.js";
+import { contentToLine, lineToContent, singleLine } from "./placeholder-text.js";
+import { toVariableDef } from "./template-validation.js";
+export const MAX_DOCUMENT_OPS = 50;
+// Assigning these keys would reach the prototype of the meta object.
+const FORBIDDEN_META_KEYS = new Set(["__proto__", "prototype", "constructor"]);
+const TEXT_BLOCK_TYPES = new Set(["paragraph", "heading", "button"]);
+function blockTypeOf(node) {
+    switch (node.type) {
+        case "paragraph":
+        case "heading":
+        case "button":
+        case "divider":
+        case "pageBreak":
+        case "steps":
+            return node.type;
+        case "bulletList":
+        case "orderedList":
+            return "list";
+        case "table":
+            return eachOf(node) === undefined ? "table" : "repeat";
+        case "resource":
+            return "image";
+        default:
+            return null;
+    }
+}
+function stringAttr(node, name) {
+    const value = node.attrs?.[name];
+    return typeof value === "string" && value !== "" ? value : undefined;
+}
+function eachOf(table) {
+    for (const row of table.content ?? []) {
+        const each = stringAttr(row, "each");
+        if (each !== undefined)
+            return each;
+    }
+    return undefined;
+}
+function textLinesOf(node) {
+    if (TEXT_BLOCK_TYPES.has(node.type ?? ""))
+        return [contentToLine(node.content)];
+    return (node.content ?? []).flatMap(textLinesOf);
+}
+const NON_TEXT_BLOCK_TYPES = new Set([
+    "image",
+    "divider",
+    "pageBreak",
+    "steps",
+]);
+function setOptionalAttrs(block, node) {
+    const align = stringAttr(node, "textAlign");
+    if (align !== undefined)
+        block.align = align;
+    const showIf = stringAttr(node, "showIf");
+    if (showIf !== undefined)
+        block.showIf = showIf;
+}
+function setTypeSpecificAttrs(block, node) {
+    const level = node.attrs?.["level"];
+    if (block.type === "heading" && typeof level === "number")
+        block.level = level;
+    const resource = stringAttr(node, "resource");
+    if (block.type === "image" && resource !== undefined)
+        block.resource = resource;
+    const alt = stringAttr(node, "alt");
+    if (block.type === "image" && alt !== undefined)
+        block.alt = alt;
+    const href = stringAttr(node, "href");
+    if (block.type === "button" && href !== undefined)
+        block.href = href;
+    const each = eachOf(node);
+    if (block.type === "repeat" && each !== undefined)
+        block.each = each;
+}
+function blockOf(node, id) {
+    const type = blockTypeOf(node);
+    if (type === null)
+        return null;
+    const block = { id, type };
+    if (!NON_TEXT_BLOCK_TYPES.has(type))
+        block.text = textLinesOf(node).join("\n");
+    setOptionalAttrs(block, node);
+    setTypeSpecificAttrs(block, node);
+    return block;
+}
+export function documentBlockId(index) {
+    return `b${index}`;
+}
+export function documentBlocksOf(doc) {
+    return (doc.content ?? []).flatMap((node, index) => blockOf(node, documentBlockId(index)) ?? []);
+}
+const blockIdSchema = z.string().min(1).max(20);
+const singleLineText = z.string().max(2000);
+const blockInputSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("paragraph"),
+        text: singleLineText,
+        align: z.enum(DOCUMENT_TEXT_ALIGNMENTS).optional(),
+    }),
+    z.object({
+        type: z.literal("heading"),
+        level: z.number().int().min(1).max(3),
+        text: singleLineText,
+    }),
+    z.object({
+        type: z.literal("image"),
+        resource: z.string().min(1).max(200),
+        alt: z.string().max(500).optional(),
+    }),
+    z.object({ type: z.literal("button"), text: singleLineText, href: z.string().max(300) }),
+    z.object({ type: z.literal("divider") }),
+    z.object({ type: z.literal("pageBreak") }),
+]);
+export const documentOpSchema = z.discriminatedUnion("op", [
+    z.object({
+        op: z.literal("insertBlock"),
+        after: blockIdSchema.nullable(),
+        block: blockInputSchema,
+    }),
+    z.object({
+        op: z.literal("replaceText"),
+        blockId: blockIdSchema,
+        find: z.string().min(1).max(2000),
+        replace: z.string().max(2000),
+    }),
+    z.object({ op: z.literal("removeBlock"), blockId: blockIdSchema }),
+    z.object({
+        op: z.literal("setResource"),
+        blockId: blockIdSchema,
+        resource: z.string().min(1).max(200),
+        alt: z.string().max(500).nullable().optional(),
+    }),
+    z.object({ op: z.literal("setMeta"), meta: z.record(z.string(), z.unknown()) }),
+    z.object({
+        op: z.literal("setVariable"),
+        name: z.string().min(1).max(100),
+        definition: z.unknown().nullable(),
+    }),
+]);
+export const documentOpsSchema = z.array(documentOpSchema).min(1).max(MAX_DOCUMENT_OPS);
+function patchIssue(path, code, params) {
+    const camel = code.replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase());
+    return {
+        path,
+        code,
+        i18nKey: `templateResolver.errors.patch.${camel}`,
+        ...(params === undefined ? {} : { params }),
+    };
+}
+function textNodesIn(nodes) {
+    return nodes.flatMap((node) => (node.type === "text" ? [node] : textNodesIn(node.content ?? [])));
+}
+function occurrencesOf(text, find) {
+    return text.split(find).length - 1;
+}
+function replacementNodes(textNode, find, replace) {
+    const text = textNode.text ?? "";
+    const at = text.indexOf(find);
+    const withMarks = (node) => node.type === "text" && textNode.marks !== undefined
+        ? { ...node, marks: textNode.marks }
+        : node;
+    const before = text.slice(0, at);
+    const after = text.slice(at + find.length);
+    return [
+        ...(before === "" ? [] : [{ ...textNode, text: before }]),
+        ...lineToContent(singleLine(replace)).map(withMarks),
+        ...(after === "" ? [] : [{ ...textNode, text: after }]),
+    ];
+}
+function replaceInContent(content, find, replace) {
+    return content.flatMap((node) => {
+        if (node.type === "text") {
+            return (node.text ?? "").includes(find) ? replacementNodes(node, find, replace) : [node];
+        }
+        return [
+            node.content === undefined
+                ? node
+                : { ...node, content: replaceInContent(node.content, find, replace) },
+        ];
+    });
+}
+function nodeOfInput(input) {
+    switch (input.type) {
+        case "paragraph":
+            return {
+                type: "paragraph",
+                ...(input.align === undefined ? {} : { attrs: { textAlign: input.align } }),
+                content: lineToContent(singleLine(input.text)),
+            };
+        case "heading":
+            return {
+                type: "heading",
+                attrs: { level: input.level },
+                content: lineToContent(singleLine(input.text)),
+            };
+        case "image":
+            return { type: "resource", attrs: { resource: input.resource, alt: input.alt ?? null } };
+        case "button":
+            return {
+                type: "button",
+                attrs: { href: input.href },
+                content: lineToContent(singleLine(input.text)),
+            };
+        case "divider":
+        case "pageBreak":
+            return { type: input.type };
+    }
+}
+const TOOLBAR_BLOCK_OF_INPUT = {
+    image: "image",
+    button: "button",
+    divider: "divider",
+    pageBreak: "pageBreak",
+};
+function isBlockAllowed(input, kind) {
+    if (input.type === "paragraph" || input.type === "heading")
+        return true;
+    return documentBlocksForKind(kind).includes(TOOLBAR_BLOCK_OF_INPUT[input.type]);
+}
+function inputIssue(input, path) {
+    if (input.type === "image" && !isDocumentResourceKey(input.resource)) {
+        return patchIssue(`${path}.block.resource`, "invalid_resource_key", {
+            resource: input.resource,
+        });
+    }
+    if (input.type === "button" && !isDocumentPlaceholderHref(input.href)) {
+        return patchIssue(`${path}.block.href`, "invalid_button_href", { href: input.href });
+    }
+    return null;
+}
+let cachedSchema = null;
+function documentSchema() {
+    cachedSchema ??= getSchema(documentExtensions);
+    return cachedSchema;
+}
+function isValidDocument(doc) {
+    try {
+        documentSchema().nodeFromJSON(doc).check();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function lookupEntry(state, blockId, fieldPath) {
+    const entry = state.entries.get(blockId);
+    if (entry === undefined)
+        return { issue: patchIssue(fieldPath, "unknown_block", { blockId }) };
+    if (entry.removed)
+        return { issue: patchIssue(fieldPath, "block_removed", { blockId }) };
+    return { entry };
+}
+function blockInputIssue(op, path, kind) {
+    if (!isBlockAllowed(op.block, kind)) {
+        return patchIssue(`${path}.block.type`, "block_not_allowed", { type: op.block.type, kind });
+    }
+    if (op.block.type === "paragraph" &&
+        op.block.align !== undefined &&
+        !documentBlocksForKind(kind).includes("align")) {
+        return patchIssue(`${path}.block.align`, "block_not_allowed", { type: "align", kind });
+    }
+    return inputIssue(op.block, path);
+}
+function insertBlockOp(state, op, path) {
+    const anchor = op.after === null ? null : lookupEntry(state, op.after, `${path}.after`);
+    if (anchor !== null && "issue" in anchor)
+        return anchor.issue;
+    const invalid = blockInputIssue(op, path, state.kind);
+    if (invalid !== null)
+        return invalid;
+    const target = anchor === null ? state.insertedAtStart : anchor.entry.insertedAfter;
+    target.push(nodeOfInput(op.block));
+    return null;
+}
+function removeBlockOp(state, op, path) {
+    const found = lookupEntry(state, op.blockId, `${path}.blockId`);
+    if ("issue" in found)
+        return found.issue;
+    found.entry.removed = true;
+    return null;
+}
+function replaceTextOp(state, op, path) {
+    const found = lookupEntry(state, op.blockId, `${path}.blockId`);
+    if ("issue" in found)
+        return found.issue;
+    const { entry } = found;
+    const count = textNodesIn([entry.node]).reduce((sum, node) => sum + occurrencesOf(node.text ?? "", op.find), 0);
+    if (count === 0)
+        return patchIssue(`${path}.find`, "text_not_found", { find: op.find });
+    if (count > 1)
+        return patchIssue(`${path}.find`, "text_ambiguous", { find: op.find, count });
+    entry.node = replaceInContent([entry.node], op.find, op.replace)[0] ?? entry.node;
+    return null;
+}
+function setResourceOp(state, op, path) {
+    const found = lookupEntry(state, op.blockId, `${path}.blockId`);
+    if ("issue" in found)
+        return found.issue;
+    const { entry } = found;
+    if (entry.node.type !== "resource") {
+        return patchIssue(`${path}.blockId`, "block_type_mismatch", {
+            expected: "image",
+            actual: entry.node.type ?? "unknown",
+        });
+    }
+    if (!isDocumentResourceKey(op.resource)) {
+        return patchIssue(`${path}.resource`, "invalid_resource_key", { resource: op.resource });
+    }
+    const alt = op.alt === undefined ? (entry.node.attrs?.["alt"] ?? null) : op.alt;
+    entry.node = { ...entry.node, attrs: { resource: op.resource, alt } };
+    return null;
+}
+function setMetaOp(state, op, path) {
+    const forbidden = Object.keys(op.meta).find((key) => FORBIDDEN_META_KEYS.has(key));
+    if (forbidden !== undefined) {
+        return patchIssue(`${path}.meta`, "invalid_meta_key", { key: forbidden });
+    }
+    for (const [key, value] of Object.entries(op.meta)) {
+        if (value === null)
+            delete state.meta[key];
+        else
+            state.meta[key] = value;
+    }
+    return null;
+}
+function setVariableOp(state, op, path) {
+    if (!isDocumentReferenceName(op.name)) {
+        return patchIssue(`${path}.name`, "invalid_variable_name", { name: op.name });
+    }
+    if (op.definition === null) {
+        delete state.variableSchema[op.name];
+        return null;
+    }
+    const definition = toVariableDef(op.definition);
+    if (definition === null) {
+        return patchIssue(`${path}.definition`, "invalid_variable_definition", { name: op.name });
+    }
+    state.variableSchema[op.name] = definition;
+    return null;
+}
+function applyOp(state, op, path) {
+    switch (op.op) {
+        case "insertBlock":
+            return insertBlockOp(state, op, path);
+        case "removeBlock":
+            return removeBlockOp(state, op, path);
+        case "replaceText":
+            return replaceTextOp(state, op, path);
+        case "setResource":
+            return setResourceOp(state, op, path);
+        case "setMeta":
+            return setMetaOp(state, op, path);
+        case "setVariable":
+            return setVariableOp(state, op, path);
+    }
+}
+// Ops address blocks by the ids of the document as it was read, so inserted blocks are
+// collected per anchor and the list is assembled once at the end.
+export function applyDocumentOps(input) {
+    const entries = new Map();
+    (input.doc.content ?? []).forEach((node, index) => {
+        entries.set(documentBlockId(index), {
+            node: structuredClone(node),
+            removed: false,
+            insertedAfter: [],
+        });
+    });
+    const state = {
+        kind: input.kind,
+        entries,
+        insertedAtStart: [],
+        meta: { ...input.meta },
+        variableSchema: { ...input.variableSchema },
+    };
+    const issues = input.ops.flatMap((op, index) => applyOp(state, op, `ops.${index}`) ?? []);
+    if (issues.length > 0)
+        return { ok: false, issues };
+    const content = [
+        ...state.insertedAtStart,
+        ...[...entries.values()].flatMap((entry) => entry.removed ? entry.insertedAfter : [entry.node, ...entry.insertedAfter]),
+    ];
+    const doc = { ...input.doc, content };
+    if (!isValidDocument(doc))
+        return { ok: false, issues: [patchIssue("ops", "invalid_document")] };
+    return { ok: true, doc, meta: state.meta, variableSchema: state.variableSchema };
+}

package/dist/template-resolver/document-sanitizer.d.ts

@@ -1,4 +1,5 @@
 import type { FieldIssue } from "@cosmicdrift/kumiko-framework/errors";
+import type { JSONContent } from "@tiptap/core";
 import { type Element as ScanElement } from "happy-dom";
 import type { ContentFormat } from "./constants.ts";
 export type DocumentViolationCode = "script_element" | "event_handler_attribute" | "disallowed_link_href" | "external_image_source" | "image_without_resource" | "invalid_reference_name" | "embedded_content" | "unsafe_attribute_value" | "button_href_not_placeholder" | "document_requires_html_format" | "layout_requires_mjml_format" | "layout_invalid_structure" | "layout_missing_content_slot" | "layout_source_system_only";
@@ -24,6 +25,8 @@ export type SanitizeBodyResult = {
 export declare function violation(code: DocumentViolationCode, detail: string, message: string): DocumentViolation;
 export declare function withParsedDocument<T>(html: string, read: (body: ScanElement) => T): T;
 export declare function sanitizeDocumentHtml(html: string): SanitizeHtmlResult;
+export declare function parseDocumentJson(html: string): JSONContent;
+export declare function serializeDocumentJson(doc: JSONContent): string;
 export declare function flattenParagraphsToLineBreaks(sanitizedHtml: string): string;
 export declare function sanitizeTemplateBody(input: {
     readonly kind: string;

package/dist/template-resolver/document-sanitizer.js

@@ -156,6 +156,12 @@ export function sanitizeDocumentHtml(html) {
         html: generateHTML(generateJSON(html, documentExtensions), documentExtensions),
     };
 }
+export function parseDocumentJson(html) {
+    return generateJSON(html, documentExtensions);
+}
+export function serializeDocumentJson(doc) {
+    return generateHTML(doc, documentExtensions);
+}
 // For a sanitized value placed inside a line of text: paragraphs become line
 // breaks. Other blocks (lists, headings) cannot be made inline and stay as they are.
 export function flattenParagraphsToLineBreaks(sanitizedHtml) {

package/dist/template-resolver/feature.d.ts

@@ -31,6 +31,7 @@ export declare function createTemplateResolverFeature(opts?: TemplateResolverOpt
             resourceRemove: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
             resourceLinkPdf: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
             sendTest: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            patchDraft: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
         };
         queries: {
             findById: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
@@ -44,6 +45,7 @@ export declare function createTemplateResolverFeature(opts?: TemplateResolverOpt
             diffToSystem: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
             validate: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
             preview: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            documentBlocks: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
             exportBundle: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
         };
         treeHandle: import("@cosmicdrift/kumiko-types/tree-node").TreeActionsHandle<"template-resolver", {

package/dist/template-resolver/feature.js

@@ -8,6 +8,7 @@ import { makeCollectionSetWrite } from "./handlers/collection-set.write.js";
 import { copyLocaleWrite } from "./handlers/copy-locale.write.js";
 import { diffToSystemQuery } from "./handlers/diff-to-system.query.js";
 import { discardDraftSystemWrite, discardDraftWrite } from "./handlers/discard-draft.write.js";
+import { documentBlocksQuery } from "./handlers/document-blocks.query.js";
 import { exportBundleQuery } from "./handlers/export-bundle.query.js";
 import { findByIdQuery } from "./handlers/find-by-id.query.js";
 import { importBundleWrite } from "./handlers/import-bundle.write.js";
@@ -15,6 +16,7 @@ import { importBundleSystemWrite } from "./handlers/import-bundle-system.write.j
 import { layoutSourceQuery } from "./handlers/layout-source.query.js";
 import { listQuery } from "./handlers/list.query.js";
 import { overviewQuery } from "./handlers/overview.query.js";
+import { patchDraftWrite } from "./handlers/patch-draft.write.js";
 import { previewQuery } from "./handlers/preview.query.js";
 import { resetToSystemWrite } from "./handlers/reset-to-system.write.js";
 import { resourceLinkPdfWrite } from "./handlers/resource-link-pdf.write.js";
@@ -88,6 +90,7 @@ export function createTemplateResolverFeature(opts = {}) {
             resourceRemove: r.writeHandler(resourceRemoveWrite),
             resourceLinkPdf: r.writeHandler(resourceLinkPdfWrite),
             sendTest: r.writeHandler(sendTestWrite),
+            patchDraft: r.writeHandler(patchDraftWrite),
         };
         const queries = {
             findById: r.queryHandler(findByIdQuery),
@@ -101,6 +104,7 @@ export function createTemplateResolverFeature(opts = {}) {
             diffToSystem: r.queryHandler(diffToSystemQuery),
             validate: r.queryHandler(validateQuery),
             preview: r.queryHandler(previewQuery),
+            documentBlocks: r.queryHandler(documentBlocksQuery),
             exportBundle: r.queryHandler(exportBundleQuery),
         };
         for (const collection of collections) {

package/dist/template-resolver/handlers/bundle-import.js

@@ -147,6 +147,7 @@ export async function importTemplateBundle(args) {
             contentFormat: args.bundle.contentFormat,
             variableSchema,
             meta: entry.meta,
+            ...(entry.title !== undefined && { title: entry.title }),
         };
         const written = await writeTemplateRow({
             ctx: args.ctx,

package/dist/template-resolver/handlers/document-base.d.ts

@@ -0,0 +1,23 @@
+import { type HandlerContext, type SessionUser } from "@cosmicdrift/kumiko-framework/engine";
+import type { DocumentHtmlKind } from "../constants.ts";
+export type DocumentBase = {
+    readonly scope: "tenant" | "system";
+    /** The stored row's own version, which counts every draft save. */
+    readonly version: number;
+};
+export type LoadedDocument = {
+    readonly rowId: string;
+    readonly base: DocumentBase;
+    readonly status: string;
+    readonly content: string;
+    readonly meta: Readonly<Record<string, unknown>>;
+    readonly variableSchema: Readonly<Record<string, unknown>>;
+    readonly title: string | null;
+    readonly folder: string | null;
+    readonly parentTemplateId: string | null;
+};
+export declare function loadDocumentBase(ctx: HandlerContext, user: SessionUser, where: {
+    readonly slug: string;
+    readonly kind: DocumentHtmlKind;
+    readonly locale: string;
+}): Promise<LoadedDocument | null>;

package/dist/template-resolver/handlers/document-base.js

@@ -0,0 +1,55 @@
+import { fetchOne } from "@cosmicdrift/kumiko-framework/db";
+import { SYSTEM_TENANT_ID, } from "@cosmicdrift/kumiko-framework/engine";
+import { isPlainObject } from "@cosmicdrift/kumiko-types/type-guards";
+import { templateResourcesTable } from "../table.js";
+import { isHiddenSystemDraft, toWorkingRow } from "../template-draft.js";
+import { isSystemOnlyTemplateHiddenFrom } from "../template-system-only.js";
+import { parseStoredJson } from "./template-gates.js";
+function recordOrEmpty(raw) {
+    const parsed = parseStoredJson(raw);
+    return isPlainObject(parsed) ? parsed : {};
+}
+// The version an editor works on: the caller's own row (its open draft if there is one),
+// else the served system default. A system default as base is what a patch copies into a tenant draft.
+export async function loadDocumentBase(ctx, user, where) {
+    const own = await fetchOne(ctx.db, templateResourcesTable, {
+        tenantId: user.tenantId,
+        ...where,
+    });
+    if (own !== undefined && !isSystemOnlyTemplateHiddenFrom(user, ctx.registry, own)) {
+        const working = toWorkingRow(own, user.tenantId);
+        return {
+            rowId: String(own.id),
+            base: { scope: own.scope === "system" ? "system" : "tenant", version: own.version },
+            status: working.status,
+            content: working.content ?? "",
+            meta: recordOrEmpty(working.meta),
+            variableSchema: recordOrEmpty(working.variableSchema),
+            title: working.title,
+            folder: working.folder,
+            parentTemplateId: working.parentTemplateId,
+        };
+    }
+    const system = await fetchOne(ctx.db, templateResourcesTable, {
+        tenantId: SYSTEM_TENANT_ID,
+        scope: "system",
+        status: "active",
+        ...where,
+    });
+    if (system === undefined ||
+        isHiddenSystemDraft(user, system) ||
+        isSystemOnlyTemplateHiddenFrom(user, ctx.registry, system)) {
+        return null;
+    }
+    return {
+        rowId: String(system.id),
+        base: { scope: "system", version: system.version },
+        status: system.status,
+        content: system.content ?? "",
+        meta: recordOrEmpty(system.meta),
+        variableSchema: recordOrEmpty(system.variableSchema),
+        title: system.title,
+        folder: system.folder,
+        parentTemplateId: String(system.id),
+    };
+}

package/dist/template-resolver/handlers/document-blocks.query.d.ts

@@ -0,0 +1,22 @@
+import * as z from "zod";
+export declare const documentBlocksQuery: import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"document-blocks", z.ZodObject<{
+    slug: z.ZodString;
+    kind: z.ZodEnum<{
+        "document-pdf": "document-pdf";
+        mail: "mail";
+    }>;
+    locale: z.ZodString;
+}, z.core.$strip>, {
+    slug: string;
+    kind: "document-pdf" | "mail";
+    locale: string;
+    base: import("./document-base.ts").DocumentBase;
+    status: string;
+    blocks: import("../document-ops.ts").DocumentBlock[];
+    meta: Readonly<Record<string, unknown>>;
+    variableSchema: Readonly<Record<string, unknown>>;
+    variables: Readonly<Record<string, import("@cosmicdrift/kumiko-types/config").TemplateVariableDef>>;
+    variablesDeclaredByFeature: boolean;
+    allowedBlocks: readonly import("../document-blocks.ts").DocumentToolbarBlock[];
+    resourceKeys: string[];
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/template-resolver/handlers/document-blocks.query.js

@@ -0,0 +1,46 @@
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { NotFoundError } from "@cosmicdrift/kumiko-framework/errors";
+import * as z from "zod";
+import { DOCUMENT_HTML_KINDS } from "../constants.js";
+import { documentBlocksForKind } from "../document-blocks.js";
+import { documentBlocksOf } from "../document-ops.js";
+import { parseDocumentJson } from "../document-sanitizer.js";
+import { resolveTemplateVariables } from "../template-validation.js";
+import { loadDocumentBase } from "./document-base.js";
+import { localeSchema, templateSlugSchema } from "./shared.js";
+import { knownResourceKeysFor } from "./validate.query.js";
+export const documentBlocksQuery = defineQueryHandler({
+    name: "document-blocks",
+    schema: z.object({
+        slug: templateSlugSchema,
+        kind: z.enum(DOCUMENT_HTML_KINDS),
+        locale: localeSchema,
+    }),
+    access: { roles: ["TenantAdmin", "SystemAdmin"] },
+    description: "Reads a mail or PDF document template as a list of blocks with stable ids (b0, b1, ...) for structured editing: each block has its type (paragraph, heading, list, table, repeat, image, button, divider, pageBreak, steps), its text with {{name}} placeholders and its settings, plus the meta, the stored and effective variables (variablesDeclaredByFeature is true when a notification declares them, so they cannot be changed), the block types allowed for the kind and the uploaded image keys. It reads the caller's own version (the open draft if there is one), else the served system default; base carries the scope and version that patch-draft expects back.",
+    handler: async (query, ctx) => {
+        const { slug, kind, locale } = query.payload;
+        const loaded = await loadDocumentBase(ctx, query.user, { slug, kind, locale });
+        if (loaded === null)
+            throw new NotFoundError("template-resource", slug);
+        return {
+            slug,
+            kind,
+            locale,
+            base: loaded.base,
+            status: loaded.status,
+            blocks: documentBlocksOf(parseDocumentJson(loaded.content)),
+            meta: loaded.meta,
+            variableSchema: loaded.variableSchema,
+            variables: resolveTemplateVariables(ctx.registry, slug, loaded.variableSchema),
+            variablesDeclaredByFeature: ctx.registry.getAllNotifications().get(slug)?.variables !== undefined,
+            allowedBlocks: documentBlocksForKind(kind),
+            resourceKeys: await knownResourceKeysFor(ctx, query.user, {
+                slug,
+                kind,
+                scope: "tenant",
+                locale,
+            }),
+        };
+    },
+});

package/dist/template-resolver/handlers/export-bundle.query.d.ts

@@ -21,6 +21,7 @@ export declare const exportBundleQuery: import("@cosmicdrift/kumiko-types/define
     locales: Record<string, {
         body: string;
         meta?: unknown;
+        title?: string;
     }>;
     resources: Record<string, {
         fileName: string;

package/dist/template-resolver/handlers/export-bundle.query.js

@@ -55,6 +55,14 @@ function assertLocalesShareFormat(rows) {
         ],
     });
 }
+function localeEntryOf(row) {
+    const meta = parseStoredJson(row.meta);
+    return {
+        body: row.content ?? "",
+        ...(meta === undefined ? {} : { meta }),
+        ...(row.title === null ? {} : { title: row.title }),
+    };
+}
 export const exportBundleQuery = defineQueryHandler({
     name: "export-bundle",
     schema: z.object({
@@ -79,8 +87,7 @@ export const exportBundleQuery = defineQueryHandler({
         const locales = {};
         const entryByKey = new Map();
         for (const row of rows) {
-            const meta = parseStoredJson(row.meta);
-            locales[row.locale] = { body: row.content ?? "", ...(meta === undefined ? {} : { meta }) };
+            locales[row.locale] = localeEntryOf(row);
             for (const [key, entry] of Object.entries(parseLinkedResourceEntries(row.linkedResources))) {
                 if (!entryByKey.has(key))
                     entryByKey.set(key, entry);

package/dist/template-resolver/handlers/import-bundle-system.write.d.ts

@@ -20,6 +20,7 @@ export declare const importBundleSystemWrite: import("@cosmicdrift/kumiko-types/
         locales: z.ZodRecord<z.ZodString, z.ZodObject<{
             body: z.ZodString;
             meta: z.ZodOptional<z.ZodUnknown>;
+            title: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         resources: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
             fileName: z.ZodString;