@cosmicdrift/kumiko-bundled-features 0.373.0 → 0.377.0

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;

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

@@ -20,6 +20,7 @@ export declare const importBundleWrite: import("@cosmicdrift/kumiko-types/define
         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;

package/dist/template-resolver/handlers/patch-draft.write.d.ts

@@ -0,0 +1,66 @@
+import * as z from "zod";
+export declare const patchDraftWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<"patch-draft", z.ZodObject<{
+    slug: z.ZodString;
+    kind: z.ZodEnum<{
+        "document-pdf": "document-pdf";
+        mail: "mail";
+    }>;
+    locale: z.ZodString;
+    base: z.ZodObject<{
+        scope: z.ZodEnum<{
+            system: "system";
+            tenant: "tenant";
+        }>;
+        version: z.ZodNumber;
+    }, z.core.$strip>;
+    ops: 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">>;
+}, z.core.$strip>, import("./template-write.ts").WrittenTemplateRow, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;

package/dist/template-resolver/handlers/patch-draft.write.js

@@ -0,0 +1,105 @@
+import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { NotFoundError, ValidationError, VersionConflictError, writeFailure, } from "@cosmicdrift/kumiko-framework/errors";
+import * as z from "zod";
+import { DOCUMENT_HTML_KINDS } from "../constants.js";
+import { applyDocumentOps, documentOpsSchema } from "../document-ops.js";
+import { parseDocumentJson, serializeDocumentJson } from "../document-sanitizer.js";
+import { resolveTemplateVariables } from "../template-validation.js";
+import { loadDocumentBase } from "./document-base.js";
+import { localeSchema, templateSlugSchema } from "./shared.js";
+import { writeTemplateRow } from "./template-write.js";
+import { validateTemplateDraft } from "./validate.query.js";
+function validationFailure(issue) {
+    return writeFailure(new ValidationError({ fields: [issue] }));
+}
+export const patchDraftWrite = defineWriteHandler({
+    name: "patch-draft",
+    schema: z.object({
+        slug: templateSlugSchema,
+        kind: z.enum(DOCUMENT_HTML_KINDS),
+        locale: localeSchema,
+        base: z.object({
+            scope: z.enum(["tenant", "system"]),
+            version: z.number().int().nonnegative(),
+        }),
+        ops: documentOpsSchema,
+    }),
+    access: { roles: ["TenantAdmin", "SystemAdmin"] },
+    description: "Changes a mail or PDF document template with structured operations instead of a full rewrite and saves the result as the caller's tenant draft (never published, an active version keeps being served until publish): insertBlock after a block id (null = at the start; paragraph, heading, image, button, divider, pageBreak), replaceText inside one block (the text must occur exactly once), removeBlock, setResource on an image block, setMeta (flat merge, null removes a key) and setVariable (adds, replaces or with null removes a variable definition; refused when a notification declares the variables). Block ids and base come from document-blocks and refer to the state that was read; if the template changed since, the call fails with version_conflict and nothing is written. A patch that removes a required placeholder is refused. Returns the written row.",
+    handler: async (event, ctx) => {
+        const { slug, kind, locale, base, ops } = event.payload;
+        const loaded = await loadDocumentBase(ctx, event.user, { slug, kind, locale });
+        if (loaded === null)
+            return writeFailure(new NotFoundError("template-resource", slug));
+        if (loaded.base.scope !== base.scope || loaded.base.version !== base.version) {
+            return writeFailure(new VersionConflictError({
+                entityId: loaded.rowId,
+                expectedVersion: base.version,
+                currentVersion: loaded.base.version,
+            }));
+        }
+        const variableOpIndex = ops.findIndex((op) => op.op === "setVariable");
+        if (variableOpIndex !== -1 &&
+            ctx.registry.getAllNotifications().get(slug)?.variables !== undefined) {
+            return validationFailure({
+                path: `ops.${variableOpIndex}`,
+                code: "variables_declared_by_feature",
+                i18nKey: "templateResolver.errors.patch.variablesDeclaredByFeature",
+                params: { slug },
+            });
+        }
+        const applied = applyDocumentOps({
+            doc: parseDocumentJson(loaded.content),
+            meta: loaded.meta,
+            variableSchema: loaded.variableSchema,
+            kind,
+            ops,
+        });
+        if (!applied.ok)
+            return writeFailure(new ValidationError({ fields: applied.issues }));
+        const content = serializeDocumentJson(applied.doc);
+        const draftOf = (draftContent, meta, variableSchema) => validateTemplateDraft(ctx, event.user, {
+            slug,
+            kind,
+            contentFormat: "html",
+            content: draftContent,
+            meta,
+            variableSchema,
+            locale,
+            scope: "tenant",
+        });
+        const before = await draftOf(loaded.content, loaded.meta, loaded.variableSchema);
+        const after = await draftOf(content, applied.meta, applied.variableSchema);
+        const alreadyMissing = new Set(before.response.missingRequired);
+        const removed = after.response.missingRequired.filter((name) => !alreadyMissing.has(name));
+        if (removed.length > 0) {
+            return validationFailure({
+                path: "ops",
+                code: "required_placeholder_removed",
+                i18nKey: "templateResolver.errors.patch.requiredPlaceholderRemoved",
+                params: { names: removed },
+            });
+        }
+        return writeTemplateRow({
+            ctx,
+            user: event.user,
+            tenantId: event.user.tenantId,
+            scope: "tenant",
+            status: "draft",
+            variables: resolveTemplateVariables(ctx.registry, slug, applied.variableSchema),
+            payload: {
+                slug,
+                kind,
+                locale,
+                content,
+                contentFormat: "html",
+                variableSchema: applied.variableSchema,
+                meta: applied.meta,
+                title: loaded.title,
+                folder: loaded.folder,
+                parentTemplateId: loaded.parentTemplateId,
+            },
+            expectedVersion: loaded.base.scope === "tenant" ? loaded.base.version : null,
+        });
+    },
+});

package/dist/template-resolver/handlers/preview.query.d.ts

@@ -9,4 +9,5 @@ export declare const previewQuery: import("@cosmicdrift/kumiko-types/define-hand
     content: z.ZodOptional<z.ZodString>;
     meta: z.ZodOptional<z.ZodUnknown>;
     variableSchema: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>, import("../template-preview.ts").TemplatePreview, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/template-resolver/handlers/preview.query.js

@@ -12,9 +12,10 @@ export const previewQuery = defineQueryHandler({
         content: z.string().max(200_000).optional(),
         meta: z.unknown().optional(),
         variableSchema: z.record(z.string(), z.unknown()).default({}),
+        variables: z.record(z.string(), z.unknown()).optional(),
     }),
     access: { roles: ["TenantAdmin", "SystemAdmin"] },
-    description: "Renders a template draft, or the stored template when no content is given, with sample values taken from the declared variable examples, without saving or sending anything: returns the mail subject, html and plain text with its inline images (a PDF template returns its body and layout regions instead), the sample values used, and checks for unresolved images, missing plain text, mail size and unused required placeholders; a draft that fails the write rules is rejected with the same problems as a save.",
+    description: "Renders a template draft, or the stored template when no content is given, with sample values taken from the declared variable examples (values passed in variables replace them and are checked against the variable schema), without saving or sending anything: returns the mail subject, html and plain text with its inline images (a PDF template returns its body and layout regions instead), the sample values used, and checks for unresolved images, missing plain text, mail size and unused required placeholders; a draft that fails the write rules is rejected with the same problems as a save.",
     handler: async (query, ctx) => {
         const outcome = await renderTemplatePreview(ctx, query.user, query.payload);
         if (!outcome.ok)

package/dist/template-resolver/handlers/send-test.write.d.ts

@@ -5,6 +5,7 @@ export declare const sendTestWrite: import("@cosmicdrift/kumiko-types/define-han
     content: z.ZodOptional<z.ZodString>;
     meta: z.ZodOptional<z.ZodUnknown>;
     variableSchema: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     includeAttachments: z.ZodDefault<z.ZodBoolean>;
     prefixSubject: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>, {

package/dist/template-resolver/handlers/send-test.write.js

@@ -31,12 +31,13 @@ export const sendTestWrite = defineWriteHandler({
         content: z.string().max(200_000).optional(),
         meta: z.unknown().optional(),
         variableSchema: z.record(z.string(), z.unknown()).default({}),
+        variables: z.record(z.string(), z.unknown()).optional(),
         includeAttachments: z.boolean().default(true),
         prefixSubject: z.boolean().default(true),
     }),
     access: { roles: ["TenantAdmin", "SystemAdmin"] },
     rateLimit: { per: "user+handler", ...TEST_MAIL_RATE_LIMIT },
-    description: "Sends the rendered preview of a mail template draft, or of the stored template when no content is given, to the calling user's own address with the subject prefixed by [TEST] unless prefixSubject is false, carrying the inline images and, unless includeAttachments is false, the files attached to the template; there is no recipient input, the sample values come from the declared variable examples, and a draft that fails the write rules is rejected without sending.",
+    description: "Sends the rendered preview of a mail template draft, or of the stored template when no content is given, to the calling user's own address with the subject prefixed by [TEST] unless prefixSubject is false, carrying the inline images and, unless includeAttachments is false, the files attached to the template; there is no recipient input, the sample values come from the declared variable examples unless variables replaces them (checked against the variable schema), and a draft that fails the write rules is rejected without sending.",
     handler: async (event, ctx) => {
         const { includeAttachments, prefixSubject, ...previewPayload } = event.payload;
         const outcome = await renderTemplatePreview(ctx, event.user, {

package/dist/template-resolver/handlers/template-write.d.ts

@@ -30,6 +30,8 @@ export type TemplateRowWrite = {
     readonly status: "draft" | "active";
     readonly variables: TemplateVariables;
     readonly payload: TemplateRowPayload;
+    /** The row version the edit was made against; null means no own row may exist yet. */
+    readonly expectedVersion?: number | null;
 };
 export declare function refuseTenantScopeUnderSystemTenant(scope: TemplateWriteScope, tenantId: string): WriteResult<never> | null;
 export declare function refuseSystemOnlyTenantOverride(registry: Registry, scope: TemplateWriteScope, slug: string, kind: string): WriteFailure | null;

package/dist/template-resolver/handlers/template-write.js

@@ -1,6 +1,6 @@
 import { fetchOne } from "@cosmicdrift/kumiko-framework/db";
 import { SYSTEM_TENANT_ID, } from "@cosmicdrift/kumiko-framework/engine";
-import { AccessDeniedError, ValidationError, writeFailure, } from "@cosmicdrift/kumiko-framework/errors";
+import { AccessDeniedError, ValidationError, VersionConflictError, writeFailure, } from "@cosmicdrift/kumiko-framework/errors";
 import { requireForTenant } from "../../shared/index.js";
 import { TemplateResolverErrors } from "../qualified-names.js";
 import { templateResourcesTable } from "../table.js";
@@ -67,6 +67,15 @@ function updateChanges(existing, status, fields) {
         }
         : { draft };
 }
+function versionConflictFor(expectedVersion, existing, slug) {
+    if (expectedVersion === undefined || (existing?.version ?? null) === expectedVersion)
+        return null;
+    return writeFailure(new VersionConflictError({
+        entityId: existing?.id ?? slug,
+        expectedVersion: expectedVersion ?? 0,
+        currentVersion: existing?.version ?? 0,
+    }));
+}
 // Shared by every template write: validate through the one pipeline, then
 // create or update the (tenant, slug, kind, locale) row via the event-store
 // executor. linkedResources is never part of an update; resources are attached
@@ -109,10 +118,13 @@ export async function writeTemplateRow(args) {
         parentTemplateId: payload.parentTemplateId ?? null,
         status,
     };
+    const conflict = versionConflictFor(args.expectedVersion, existing, payload.slug);
+    if (conflict !== null)
+        return conflict;
     if (existing) {
         const result = await executor.update({
             id: existing.id,
-            version: existing.version,
+            version: args.expectedVersion ?? existing.version,
             changes: updateChanges(existing, status, fields),
         }, user, db, { streamTenantId });
         if (!result.isSuccess)

package/dist/template-resolver/handlers/validate.query.d.ts

@@ -12,12 +12,18 @@ type TemplateDraftInput = {
     readonly locale?: string | undefined;
     readonly scope: TemplateWriteScope;
 };
+export declare function knownResourceKeysFor(ctx: HandlerContext, user: SessionUser, where: {
+    readonly slug: string;
+    readonly kind: string;
+    readonly scope: TemplateWriteScope;
+    readonly locale: string | undefined;
+}): Promise<string[]>;
 export declare function validateTemplateDraft(ctx: HandlerContext, user: SessionUser, payload: TemplateDraftInput): Promise<{
     response: {
         canSave: boolean;
         canPublish: boolean;
-        issues: import("@cosmicdrift/kumiko-headless").FieldIssue[];
-        publishIssues: import("@cosmicdrift/kumiko-headless").FieldIssue[];
+        issues: import("@cosmicdrift/kumiko-framework/errors").FieldIssue[];
+        publishIssues: import("@cosmicdrift/kumiko-framework/errors").FieldIssue[];
         used: string[];
         unknown: string[];
         missingRequired: string[];
@@ -58,8 +64,8 @@ export declare const validateQuery: import("@cosmicdrift/kumiko-types/define-han
 }, z.core.$strip>, {
     canSave: boolean;
     canPublish: boolean;
-    issues: import("@cosmicdrift/kumiko-headless").FieldIssue[];
-    publishIssues: import("@cosmicdrift/kumiko-headless").FieldIssue[];
+    issues: import("@cosmicdrift/kumiko-framework/errors").FieldIssue[];
+    publishIssues: import("@cosmicdrift/kumiko-framework/errors").FieldIssue[];
     used: string[];
     unknown: string[];
     missingRequired: string[];

package/dist/template-resolver/handlers/validate.query.js

@@ -18,13 +18,10 @@ async function knownResourceKeys(db, where) {
     });
     return rows.flatMap((row) => imageResourceKeysOf(row.linkedResources));
 }
-// The dry run of the write pipeline; preview feeds on the evaluation, validate returns the response.
-export async function validateTemplateDraft(ctx, user, payload) {
-    const variables = resolveTemplateVariables(ctx.registry, payload.slug, payload.variableSchema);
-    const { slug, kind, locale } = payload;
-    // The dry run must not promise what the caller's write handlers would refuse.
-    const scope = isSystemAdmin(user) ? payload.scope : "tenant";
-    const known = [
+// Image keys the editor may reference: the system rows plus, for a tenant write, the caller's own.
+export async function knownResourceKeysFor(ctx, user, where) {
+    const { slug, kind, scope, locale } = where;
+    return [
         ...(await knownResourceKeys(ctx.db, {
             tenantId: SYSTEM_TENANT_ID,
             slug,
@@ -36,6 +33,14 @@ export async function validateTemplateDraft(ctx, user, payload) {
             ? await knownResourceKeys(ctx.db, { tenantId: user.tenantId, slug, kind, scope, locale })
             : []),
     ];
+}
+// The dry run of the write pipeline; preview feeds on the evaluation, validate returns the response.
+export async function validateTemplateDraft(ctx, user, payload) {
+    const variables = resolveTemplateVariables(ctx.registry, payload.slug, payload.variableSchema);
+    const { slug, kind, locale } = payload;
+    // The dry run must not promise what the caller's write handlers would refuse.
+    const scope = isSystemAdmin(user) ? payload.scope : "tenant";
+    const known = await knownResourceKeysFor(ctx, user, { slug, kind, scope, locale });
     const evaluation = evaluateTemplateWrite({
         kind,
         scope,

package/dist/template-resolver/{web/placeholder-text.js → placeholder-text.js}

@@ -1,4 +1,4 @@
-import { isDocumentReferenceName } from "../document-schema.js";
+import { isDocumentReferenceName } from "./document-schema.js";
 const PLACEHOLDER_TOKEN = /\{\{([^{}]*)\}\}/g;
 // Names the schema refuses stay plain text, so a typo never becomes a chip
 // that the server would reject.

package/dist/template-resolver/qualified-names.d.ts

@@ -17,6 +17,7 @@ export declare const TemplateResolverHandlers: {
     readonly resourceRemove: "template-resolver:write:resource-remove";
     readonly resourceLinkPdf: "template-resolver:write:resource-link-pdf";
     readonly sendTest: "template-resolver:write:send-test";
+    readonly patchDraft: "template-resolver:write:patch-draft";
 };
 export declare const TemplateResolverQueries: {
     readonly findById: "template-resolver:query:find-by-id";
@@ -28,6 +29,7 @@ export declare const TemplateResolverQueries: {
     readonly diffToSystem: "template-resolver:query:diff-to-system";
     readonly validate: "template-resolver:query:validate";
     readonly preview: "template-resolver:query:preview";
+    readonly documentBlocks: "template-resolver:query:document-blocks";
     readonly exportBundle: "template-resolver:query:export-bundle";
     readonly bySlug: "template-resolver:query:by-slug";
     readonly byTenant: "template-resolver:query:by-tenant";

package/dist/template-resolver/qualified-names.js

@@ -19,6 +19,7 @@ export const TemplateResolverHandlers = {
     resourceRemove: "template-resolver:write:resource-remove",
     resourceLinkPdf: "template-resolver:write:resource-link-pdf",
     sendTest: "template-resolver:write:send-test",
+    patchDraft: "template-resolver:write:patch-draft",
 };
 export const TemplateResolverQueries = {
     findById: "template-resolver:query:find-by-id",
@@ -30,6 +31,7 @@ export const TemplateResolverQueries = {
     diffToSystem: "template-resolver:query:diff-to-system",
     validate: "template-resolver:query:validate",
     preview: "template-resolver:query:preview",
+    documentBlocks: "template-resolver:query:document-blocks",
     exportBundle: "template-resolver:query:export-bundle",
     // Public pair — anonymous-reachable, kind pinned to text-block.
     bySlug: "template-resolver:query:by-slug",

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

@@ -15,6 +15,7 @@ export type SeedSystemTemplateOptions = {
      *  system admin uploaded through resource-upload. */
     readonly linkedResources?: Record<string, string>;
     readonly meta?: unknown;
+    readonly title?: string;
     readonly parentTemplateId?: string | null;
     readonly by?: SessionUser;
     readonly ifExists?: SeedIfExists;

package/dist/template-resolver/seeding.js

@@ -81,7 +81,7 @@ export async function seedSystemTemplate(db, opts) {
         variableSchema,
         ...(linkedResources !== undefined && { linkedResources }),
         meta,
-        title: null,
+        title: opts.title ?? null,
         folder: null,
         scope: "system",
         parentTemplateId,
@@ -171,6 +171,7 @@ export async function seedSystemTemplateBundle(db, bundle, opts = {}) {
             contentFormat: bundle.contentFormat,
             variableSchema: bundle.variableSchema ?? {},
             meta: entry.meta,
+            ...(entry.title !== undefined ? { title: entry.title } : {}),
             ...(opts.by !== undefined ? { by: opts.by } : {}),
             ...(opts.ifExists !== undefined ? { ifExists: opts.ifExists } : {}),
         });