@cosmicdrift/kumiko-bundled-features 0.373.0 → 0.377.0

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

@@ -0,0 +1,167 @@
+import type { FieldIssue } from "@cosmicdrift/kumiko-framework/errors";
+import { type JSONContent } from "@tiptap/core";
+import * as z from "zod";
+import type { DocumentHtmlKind } from "./constants.ts";
+export declare const MAX_DOCUMENT_OPS = 50;
+export type DocumentBlockType = "paragraph" | "heading" | "list" | "table" | "repeat" | "image" | "button" | "divider" | "pageBreak" | "steps";
+export type DocumentBlock = {
+    readonly id: string;
+    readonly type: DocumentBlockType;
+    /** Inline content with `{{name}}` for placeholders; containers list one line per text block. */
+    readonly text?: string;
+    readonly level?: number;
+    readonly align?: string;
+    readonly showIf?: string;
+    readonly resource?: string;
+    readonly alt?: string;
+    readonly href?: string;
+    readonly each?: string;
+};
+export declare function documentBlockId(index: number): string;
+export declare function documentBlocksOf(doc: JSONContent): DocumentBlock[];
+declare const blockInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"paragraph">;
+    text: z.ZodString;
+    align: z.ZodOptional<z.ZodEnum<{
+        center: "center";
+        justify: "justify";
+        left: "left";
+        right: "right";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"heading">;
+    level: z.ZodNumber;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    resource: z.ZodString;
+    alt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"button">;
+    text: z.ZodString;
+    href: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"divider">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"pageBreak">;
+}, z.core.$strip>], "type">;
+export type BlockInput = z.infer<typeof blockInputSchema>;
+export declare const documentOpSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"insertBlock">;
+    after: z.ZodNullable<z.ZodString>;
+    block: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"paragraph">;
+        text: z.ZodString;
+        align: z.ZodOptional<z.ZodEnum<{
+            center: "center";
+            justify: "justify";
+            left: "left";
+            right: "right";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"heading">;
+        level: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        resource: z.ZodString;
+        alt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"button">;
+        text: z.ZodString;
+        href: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"divider">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"pageBreak">;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"replaceText">;
+    blockId: z.ZodString;
+    find: z.ZodString;
+    replace: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"removeBlock">;
+    blockId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"setResource">;
+    blockId: z.ZodString;
+    resource: z.ZodString;
+    alt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"setMeta">;
+    meta: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"setVariable">;
+    name: z.ZodString;
+    definition: z.ZodNullable<z.ZodUnknown>;
+}, z.core.$strip>], "op">;
+export declare const documentOpsSchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"insertBlock">;
+    after: z.ZodNullable<z.ZodString>;
+    block: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"paragraph">;
+        text: z.ZodString;
+        align: z.ZodOptional<z.ZodEnum<{
+            center: "center";
+            justify: "justify";
+            left: "left";
+            right: "right";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"heading">;
+        level: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        resource: z.ZodString;
+        alt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"button">;
+        text: z.ZodString;
+        href: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"divider">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"pageBreak">;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"replaceText">;
+    blockId: z.ZodString;
+    find: z.ZodString;
+    replace: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"removeBlock">;
+    blockId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"setResource">;
+    blockId: z.ZodString;
+    resource: z.ZodString;
+    alt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"setMeta">;
+    meta: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"setVariable">;
+    name: z.ZodString;
+    definition: z.ZodNullable<z.ZodUnknown>;
+}, z.core.$strip>], "op">>;
+export type DocumentOp = z.infer<typeof documentOpSchema>;
+export type DocumentOpsInput = {
+    readonly doc: JSONContent;
+    readonly meta: Readonly<Record<string, unknown>>;
+    readonly variableSchema: Readonly<Record<string, unknown>>;
+    readonly kind: DocumentHtmlKind;
+    readonly ops: readonly DocumentOp[];
+};
+export type DocumentOpsResult = {
+    readonly ok: true;
+    readonly doc: JSONContent;
+    readonly meta: Record<string, unknown>;
+    readonly variableSchema: Record<string, unknown>;
+} | {
+    readonly ok: false;
+    readonly issues: FieldIssue[];
+};
+export declare function applyDocumentOps(input: DocumentOpsInput): DocumentOpsResult;
+export {};

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>;