@cosmicdrift/kumiko-bundled-features 0.362.0 → 0.364.0

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

@@ -0,0 +1,80 @@
+import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
+import { defineQueryHandler, SYSTEM_TENANT_ID, } from "@cosmicdrift/kumiko-framework/engine";
+import * as z from "zod";
+import { imageResourceKeysOf } from "../linked-resources.js";
+import { templateResourcesTable } from "../table.js";
+import { resolveTemplateVariables, systemPlaceholdersFor } from "../template-validation.js";
+import { contentFormatSchema, kindSchema, localeSchema, templateSlugSchema } from "./shared.js";
+import { evaluateTemplateWrite } from "./template-gates.js";
+async function knownResourceKeys(db, where) {
+    const rows = await selectMany(db, templateResourcesTable, {
+        tenantId: where.tenantId,
+        slug: where.slug,
+        kind: where.kind,
+        scope: where.scope,
+        ...(where.locale === undefined ? {} : { locale: where.locale }),
+        ...(where.scope === "system" ? { status: "active" } : {}),
+    });
+    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, scope, locale } = payload;
+    const known = [
+        ...(await knownResourceKeys(ctx.db, {
+            tenantId: SYSTEM_TENANT_ID,
+            slug,
+            kind,
+            scope: "system",
+            locale,
+        })),
+        ...(scope === "tenant"
+            ? await knownResourceKeys(ctx.db, { tenantId: user.tenantId, slug, kind, scope, locale })
+            : []),
+    ];
+    const evaluation = evaluateTemplateWrite({
+        kind,
+        scope,
+        contentFormat: payload.contentFormat,
+        content: payload.content,
+        rawMeta: payload.meta,
+        variables,
+        resourceKeys: known,
+    });
+    const validation = evaluation.validation;
+    const response = {
+        canSave: evaluation.ok,
+        canPublish: evaluation.ok && evaluation.publishIssues.length === 0,
+        issues: evaluation.ok ? [] : [...evaluation.issues],
+        publishIssues: evaluation.ok ? [...evaluation.publishIssues] : [],
+        used: [...(validation?.used ?? [])],
+        unknown: [...(validation?.unknown ?? [])],
+        missingRequired: [...(validation?.missingRequired ?? [])],
+        warnings: (validation?.unknownResources ?? []).map((key) => ({
+            code: "resource_not_uploaded",
+            detail: key,
+            i18nKey: "templateResolver.warnings.resourceNotUploaded",
+        })),
+        variables,
+        systemPlaceholders: [...systemPlaceholdersFor(kind)].sort(),
+    };
+    return { response, evaluation };
+}
+export const validateQuery = defineQueryHandler({
+    name: "validate",
+    schema: z.object({
+        slug: templateSlugSchema,
+        kind: kindSchema,
+        contentFormat: contentFormatSchema,
+        content: z.string().max(200_000),
+        meta: z.unknown().optional(),
+        variableSchema: z.record(z.string(), z.unknown()).default({}),
+        /** Narrows the known resource keys to one locale's rows. */
+        locale: localeSchema.optional(),
+        scope: z.enum(["tenant", "system"]).default("tenant"),
+    }),
+    access: { roles: ["TenantAdmin", "SystemAdmin"] },
+    description: "Dry-runs the write pipeline for a template draft without saving: reports whether it can be saved or published, the sanitizer and placeholder problems, which placeholders it uses, which are unknown, which required variables are missing, and the variables and system placeholders available for the kind; use it to give an editor live feedback.",
+    handler: async (query, ctx) => (await validateTemplateDraft(ctx, query.user, query.payload)).response,
+});

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

@@ -1,6 +1,24 @@
 export { createTemplateResolverApi, type ResolveRequest, requireTemplateResolver, TemplateNotFoundError, type TemplateResolverApi, type TemplateResource, } from "./api.js";
-export { CONTENT_FORMATS, type ContentFormat, FALLBACK_LOCALE, NON_RENDER_KINDS, type NonRenderKind, RENDER_KINDS, type RenderKind, SYSTEM_TENANT_ID, TEMPLATE_KINDS, TEMPLATE_SCOPES, TEMPLATE_STATUSES, TEXT_BLOCK_KIND, type TemplateKind, type TemplateScope, type TemplateStatus, UPSERT_KINDS, type UpsertKind, } from "./constants.js";
+export { type CompileDocumentBodyOptions, collectDocumentResourceKeys, compileDocumentBodyToHandlebars, toResourceDataUri, } from "./compile-document-body.js";
+export { CONTENT_FORMATS, type ContentFormat, DEFAULT_MAIL_LAYOUT_SLUG, DOCUMENT_HTML_KINDS, type DocumentHtmlKind, FALLBACK_LOCALE, NON_RENDER_KINDS, type NonRenderKind, PDF_DEFAULT_MARGIN_MM, PDF_FOOTER_MARGIN_MM, PDF_HEADER_MARGIN_MM, PDF_ORIENTATIONS, PDF_PAGE_FORMATS, type PdfOrientation, type PdfPageFormat, RENDER_KINDS, type RenderKind, SYSTEM_TENANT_ID, TEMPLATE_KINDS, TEMPLATE_SCOPES, TEMPLATE_STATUSES, TEXT_BLOCK_KIND, type TemplateKind, type TemplateScope, type TemplateStatus, UPSERT_KINDS, type UpsertKind, } from "./constants.js";
+export { type DocumentViolation, type DocumentViolationCode, documentViolationsToFieldIssues, type SanitizeBodyResult, type SanitizeHtmlResult, sanitizeDocumentHtml, sanitizeTemplateBody, } from "./document-sanitizer.js";
+export { DOCUMENT_NODE_NAMES, DOCUMENT_TEXT_ALIGNMENTS, DocumentButton, DocumentDivider, DocumentLink, DocumentPageBreak, DocumentResource, DocumentTable, DocumentTableCell, DocumentTableHeader, DocumentTableRow, DocumentTextAlign, type DocumentTextAlignment, DocumentVariable, documentExtensions, isAllowedDocumentLinkHref, isDocumentPlaceholderHref, isDocumentReferenceName, isDocumentResourceKey, } from "./document-schema.js";
 export { createTemplateResolverFeature } from "./feature.js";
+export type { LayoutSourceResponse, LayoutSourceRow } from "./handlers/layout-source.query.js";
+export type { OverviewKindGroup, OverviewOrigin, OverviewResponse, OverviewRow, OverviewUsage, } from "./handlers/overview.query.js";
+export { localeSchema } from "./handlers/shared.js";
+export { isHexColor, type MailLayoutAppearance, mailLayoutAppearance, } from "./layout-appearance.js";
+export { type LayoutRegions, readLayoutRegions, type SanitizeLayoutResult, sanitizeLayoutHtml, } from "./layout-regions.js";
+export { fileAttachmentsOf, imageLinksOf, type LinkedResourceEntry, parseLinkedResourceEntries, pdfAttachmentLinksOf, type TemplatePdfAttachmentLink, templatePdfAttachmentLinkSchema, } from "./linked-resources.js";
+export { prepareDocumentForPrint } from "./print-document.js";
 export { TEMPLATE_RESOLVER_FEATURE, TemplateResolverErrors, TemplateResolverHandlers, TemplateResolverQueries, } from "./qualified-names.js";
+export { mapRecordToVariables } from "./record-mapping.js";
+export { readTemplateResourceMaxBytes, type StoredTemplateResource, storeTemplateResource, } from "./store-template-resource.js";
 export { type TemplateResourceRow, templateResourceEntity, templateResourcesTable, } from "./table.js";
+export { type TemplateBundle, templateBundleSchema } from "./template-bundle.js";
+export { isMailTemplateMeta, type LayoutTemplateMeta, MAIL_CATEGORIES, type MailCategory, type MailLayoutMeta, type MailTemplateMeta, type PdfTemplateMeta, parseTemplateMeta, pdfAttachmentFileNamePatternSchema, readMailLayoutMeta, readPdfTemplateMeta, type TemplateMeta, type TemplateMetaIssue, type TemplateMetaResult, templateSlugSchema, } from "./template-meta.js";
+export { type DocumentDraftOutcome, evaluateDocumentDraft } from "./template-preview.js";
+export { readTemplateResource, type TemplateResourceFile } from "./template-resources.js";
+export { collectTemplateUsage, type TemplateUsageEntry } from "./template-usage.js";
+export { hasPlaceholderProblems, resolveTemplateVariables, SYSTEM_PLACEHOLDERS, systemPlaceholdersFor, type TemplateValidation, validateTemplatePlaceholders, } from "./template-validation.js";
 export { type UserContentEntryRow, userContentEntriesTable, userContentEntryEntity, } from "./user-content-table.js";

package/dist/template-resolver/index.js

@@ -1,6 +1,22 @@
 export { createTemplateResolverApi, requireTemplateResolver, TemplateNotFoundError, } from "./api.js";
-export { CONTENT_FORMATS, FALLBACK_LOCALE, NON_RENDER_KINDS, RENDER_KINDS, SYSTEM_TENANT_ID, TEMPLATE_KINDS, TEMPLATE_SCOPES, TEMPLATE_STATUSES, TEXT_BLOCK_KIND, UPSERT_KINDS, } from "./constants.js";
+export { collectDocumentResourceKeys, compileDocumentBodyToHandlebars, toResourceDataUri, } from "./compile-document-body.js";
+export { CONTENT_FORMATS, DEFAULT_MAIL_LAYOUT_SLUG, DOCUMENT_HTML_KINDS, FALLBACK_LOCALE, NON_RENDER_KINDS, PDF_DEFAULT_MARGIN_MM, PDF_FOOTER_MARGIN_MM, PDF_HEADER_MARGIN_MM, PDF_ORIENTATIONS, PDF_PAGE_FORMATS, RENDER_KINDS, SYSTEM_TENANT_ID, TEMPLATE_KINDS, TEMPLATE_SCOPES, TEMPLATE_STATUSES, TEXT_BLOCK_KIND, UPSERT_KINDS, } from "./constants.js";
+export { documentViolationsToFieldIssues, sanitizeDocumentHtml, sanitizeTemplateBody, } from "./document-sanitizer.js";
+export { DOCUMENT_NODE_NAMES, DOCUMENT_TEXT_ALIGNMENTS, DocumentButton, DocumentDivider, DocumentLink, DocumentPageBreak, DocumentResource, DocumentTable, DocumentTableCell, DocumentTableHeader, DocumentTableRow, DocumentTextAlign, DocumentVariable, documentExtensions, isAllowedDocumentLinkHref, isDocumentPlaceholderHref, isDocumentReferenceName, isDocumentResourceKey, } from "./document-schema.js";
 export { createTemplateResolverFeature } from "./feature.js";
+export { localeSchema } from "./handlers/shared.js";
+export { isHexColor, mailLayoutAppearance, } from "./layout-appearance.js";
+export { readLayoutRegions, sanitizeLayoutHtml, } from "./layout-regions.js";
+export { fileAttachmentsOf, imageLinksOf, parseLinkedResourceEntries, pdfAttachmentLinksOf, templatePdfAttachmentLinkSchema, } from "./linked-resources.js";
+export { prepareDocumentForPrint } from "./print-document.js";
 export { TEMPLATE_RESOLVER_FEATURE, TemplateResolverErrors, TemplateResolverHandlers, TemplateResolverQueries, } from "./qualified-names.js";
+export { mapRecordToVariables } from "./record-mapping.js";
+export { readTemplateResourceMaxBytes, storeTemplateResource, } from "./store-template-resource.js";
 export { templateResourceEntity, templateResourcesTable, } from "./table.js";
+export { templateBundleSchema } from "./template-bundle.js";
+export { isMailTemplateMeta, MAIL_CATEGORIES, parseTemplateMeta, pdfAttachmentFileNamePatternSchema, readMailLayoutMeta, readPdfTemplateMeta, templateSlugSchema, } from "./template-meta.js";
+export { evaluateDocumentDraft } from "./template-preview.js";
+export { readTemplateResource } from "./template-resources.js";
+export { collectTemplateUsage } from "./template-usage.js";
+export { hasPlaceholderProblems, resolveTemplateVariables, SYSTEM_PLACEHOLDERS, systemPlaceholdersFor, validateTemplatePlaceholders, } from "./template-validation.js";
 export { userContentEntriesTable, userContentEntryEntity, } from "./user-content-table.js";

package/dist/template-resolver/layout-appearance.d.ts

@@ -0,0 +1,10 @@
+import { type MailLayoutMeta } from "./template-meta.js";
+export type MailLayoutAppearance = {
+    readonly width: number;
+    readonly fontFamily: string;
+    readonly outerBackground: string;
+    readonly accentLine: boolean;
+    readonly buttonStyle: string;
+};
+export declare function isHexColor(value: string): boolean;
+export declare function mailLayoutAppearance(meta: MailLayoutMeta | unknown): MailLayoutAppearance;

package/dist/template-resolver/layout-appearance.js

@@ -0,0 +1,26 @@
+import { HEX_COLOR_PATTERN } from "./constants.js";
+import { readMailLayoutMeta } from "./template-meta.js";
+const FONT_FAMILIES = {
+    sans: "Arial, Helvetica, sans-serif",
+    serif: "Georgia, 'Times New Roman', serif",
+};
+const BUTTON_COLOR = "#1f5468";
+const BUTTON_BASE = "display:inline-block;padding:10px 20px;font-weight:600;text-decoration:none";
+const BUTTON_STYLES = {
+    "filled-rounded": `${BUTTON_BASE};border-radius:6px;background-color:${BUTTON_COLOR};color:#ffffff`,
+    "filled-square": `${BUTTON_BASE};background-color:${BUTTON_COLOR};color:#ffffff`,
+    outline: `${BUTTON_BASE};border:2px solid ${BUTTON_COLOR};border-radius:6px;color:${BUTTON_COLOR}`,
+};
+export function isHexColor(value) {
+    return HEX_COLOR_PATTERN.test(value);
+}
+export function mailLayoutAppearance(meta) {
+    const parsed = readMailLayoutMeta(meta);
+    return {
+        width: parsed.width ?? 600,
+        fontFamily: FONT_FAMILIES[parsed.font ?? "sans"],
+        outerBackground: parsed.outerBackground ?? "#f5f5f5",
+        accentLine: (parsed.accentLine ?? "none") === "branding",
+        buttonStyle: BUTTON_STYLES[parsed.buttonStyle ?? "filled-rounded"],
+    };
+}

package/dist/template-resolver/layout-regions.d.ts

@@ -0,0 +1,23 @@
+import type { ContentFormat } from "./constants.js";
+import { type DocumentViolation, type SanitizeBodyResult } from "./document-sanitizer.js";
+export type LayoutRegions = {
+    readonly header: string;
+    readonly signature: string;
+    readonly footer: string;
+};
+export type SanitizeLayoutResult = {
+    readonly ok: true;
+    readonly html: string;
+} | {
+    readonly ok: false;
+    readonly violations: readonly DocumentViolation[];
+};
+export declare function sanitizeLayoutHtml(html: string): SanitizeLayoutResult;
+export declare function readLayoutRegions(html: string): LayoutRegions;
+export type TemplateWriteScope = "system" | "tenant";
+export declare function sanitizeTemplateWriteBody(input: {
+    readonly kind: string;
+    readonly scope: TemplateWriteScope;
+    readonly contentFormat: ContentFormat;
+    readonly content: string | null;
+}): SanitizeBodyResult;

package/dist/template-resolver/layout-regions.js

@@ -0,0 +1,125 @@
+// Server-only (happy-dom). A structured layout is the editable frame around a
+// mail or PDF body: header, signature and footer regions plus one empty
+// content slot. Everything else is rejected so a layout can never carry markup
+// the renderer did not plan for.
+import { sanitizeDocumentHtml, sanitizeTemplateBody, violation, withParsedDocument, } from "./document-sanitizer.js";
+const REGION_ATTRIBUTES = ["data-header", "data-content", "data-signature", "data-footer"];
+const MAIL_LAYOUT_CONTENT_SLOT = /\{\{\{\s*content\s*\}\}\}/g;
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+function regionAttributeOf(element) {
+    if (element.tagName.toLowerCase() !== "div")
+        return null;
+    const present = REGION_ATTRIBUTES.filter((name) => element.hasAttribute(name));
+    return present.length === 1 ? (present[0] ?? null) : null;
+}
+function parseRegions(html) {
+    return withParsedDocument(html, (body) => {
+        const innerHtml = {};
+        const violations = [];
+        let contentIsEmpty = true;
+        const invalid = (detail, message) => violations.push(violation("layout_invalid_structure", detail, message));
+        for (const node of Array.from(body.childNodes)) {
+            if (node.nodeType === ELEMENT_NODE)
+                continue;
+            if (node.nodeType !== TEXT_NODE || (node.textContent ?? "").trim() !== "") {
+                invalid("text", "Text and comments outside the layout regions are not allowed");
+            }
+        }
+        for (const element of Array.from(body.children)) {
+            const region = regionAttributeOf(element);
+            if (region === null) {
+                invalid(element.tagName.toLowerCase(), "Only <div data-header>, <div data-content>, <div data-signature> and <div data-footer> are allowed at the top level");
+                continue;
+            }
+            if (innerHtml[region] !== undefined) {
+                invalid(region, `Layout region ${region} may appear only once`);
+                continue;
+            }
+            innerHtml[region] = element.innerHTML;
+            if (region === "data-content") {
+                contentIsEmpty = element.children.length === 0 && (element.textContent ?? "").trim() === "";
+            }
+        }
+        return { innerHtml, contentIsEmpty, violations };
+    });
+}
+export function sanitizeLayoutHtml(html) {
+    const parsed = parseRegions(html);
+    const violations = [...parsed.violations];
+    if (parsed.innerHtml["data-content"] === undefined) {
+        violations.push(violation("layout_missing_content_slot", "data-content", "A layout needs exactly one empty <div data-content></div> where the body is placed"));
+    }
+    else if (!parsed.contentIsEmpty) {
+        violations.push(violation("layout_invalid_structure", "data-content", "The data-content region must be empty"));
+    }
+    const cleanedHtml = {};
+    for (const name of ["data-header", "data-signature", "data-footer"]) {
+        const inner = parsed.innerHtml[name];
+        if (inner === undefined || inner.trim() === "")
+            continue;
+        const result = sanitizeDocumentHtml(inner);
+        if (result.ok)
+            cleanedHtml[name] = result.html;
+        else
+            violations.push(...result.violations);
+    }
+    if (violations.length > 0)
+        return { ok: false, violations };
+    const part = (name) => {
+        const regionHtml = cleanedHtml[name];
+        return regionHtml === undefined ? "" : `<div ${name}>${regionHtml}</div>`;
+    };
+    return {
+        ok: true,
+        html: [
+            part("data-header"),
+            "<div data-content></div>",
+            part("data-signature"),
+            part("data-footer"),
+        ].join(""),
+    };
+}
+export function readLayoutRegions(html) {
+    const { innerHtml } = parseRegions(html);
+    return {
+        header: innerHtml["data-header"] ?? "",
+        signature: innerHtml["data-signature"] ?? "",
+        footer: innerHtml["data-footer"] ?? "",
+    };
+}
+function rejected(violationItem) {
+    return { ok: false, violations: [violationItem] };
+}
+function sanitizeMailLayout(scope, contentFormat, content) {
+    if (contentFormat === "html")
+        return fromLayoutResult(sanitizeLayoutHtml(content));
+    if (contentFormat !== "mjml") {
+        return rejected(violation("layout_requires_mjml_format", contentFormat, `Templates of kind mail-layout require contentFormat mjml or html, got "${contentFormat}"`));
+    }
+    if (scope !== "system") {
+        return rejected(violation("layout_source_system_only", "mjml", "Only system layouts may use mjml source; tenant layouts use the structured html format"));
+    }
+    if ((content.match(MAIL_LAYOUT_CONTENT_SLOT) ?? []).length !== 1) {
+        return rejected(violation("layout_missing_content_slot", "{{{content}}}", "A mjml layout must contain {{{content}}} exactly once"));
+    }
+    return { ok: true, content };
+}
+function fromLayoutResult(result) {
+    return result.ok ? { ok: true, content: result.html } : result;
+}
+// One entry for every write path: layout kinds follow the scope-dependent
+// layout rules, everything else the plain document sanitizer.
+export function sanitizeTemplateWriteBody(input) {
+    const { kind, scope, contentFormat, content } = input;
+    if (kind === "mail-layout" && content !== null) {
+        return sanitizeMailLayout(scope, contentFormat, content);
+    }
+    if (kind === "pdf-layout" && content !== null) {
+        if (contentFormat !== "html") {
+            return rejected(violation("document_requires_html_format", contentFormat, `Templates of kind pdf-layout require contentFormat html, got "${contentFormat}"`));
+        }
+        return fromLayoutResult(sanitizeLayoutHtml(content));
+    }
+    return sanitizeTemplateBody({ kind, contentFormat, content });
+}

package/dist/template-resolver/linked-resources.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod";
+import type { FileAttachmentRef } from "../renderer-foundation/index.js";
+export declare const templatePdfAttachmentLinkSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"rendered-pdf">;
+    templateSlug: z.ZodString;
+    fileName: z.ZodString;
+}, z.core.$strict>;
+export type TemplatePdfAttachmentLink = z.infer<typeof templatePdfAttachmentLinkSchema>;
+export type LinkedResourceEntry = string | FileAttachmentRef | TemplatePdfAttachmentLink;
+export declare function isFileAttachmentEntry(entry: LinkedResourceEntry): entry is FileAttachmentRef;
+export declare function isPdfAttachmentLink(entry: LinkedResourceEntry): entry is TemplatePdfAttachmentLink;
+export declare function parseLinkedResourceEntries(raw: string | null): Record<string, LinkedResourceEntry>;
+export declare function imageLinksOf(entries: Readonly<Record<string, LinkedResourceEntry>>): Record<string, string>;
+export declare function fileAttachmentsOf(entries: Readonly<Record<string, LinkedResourceEntry>>): FileAttachmentRef[];
+export declare function pdfAttachmentLinksOf(entries: Readonly<Record<string, LinkedResourceEntry>>): TemplatePdfAttachmentLink[];
+export declare function attachmentEntriesOf(entries: Readonly<Record<string, LinkedResourceEntry>>): [string, FileAttachmentRef | TemplatePdfAttachmentLink][];
+export declare function imageResourceKeysOf(raw: string | null): string[];

package/dist/template-resolver/linked-resources.js

@@ -0,0 +1,75 @@
+import { isPlainObject } from "@cosmicdrift/kumiko-types/type-guards";
+import * as z from "zod";
+import { pdfAttachmentFileNamePatternSchema, templateSlugSchema } from "./template-meta.js";
+export const templatePdfAttachmentLinkSchema = z
+    .object({
+    kind: z.literal("rendered-pdf"),
+    templateSlug: templateSlugSchema,
+    fileName: pdfAttachmentFileNamePatternSchema,
+})
+    .strict();
+export function isFileAttachmentEntry(entry) {
+    return typeof entry !== "string" && entry.kind === "file";
+}
+export function isPdfAttachmentLink(entry) {
+    return typeof entry !== "string" && entry.kind === "rendered-pdf";
+}
+function toLinkedResourceEntry(raw) {
+    if (typeof raw === "string")
+        return raw;
+    if (!isPlainObject(raw))
+        return null;
+    if (raw["kind"] === "rendered-pdf") {
+        const link = templatePdfAttachmentLinkSchema.safeParse(raw);
+        return link.success ? link.data : null;
+    }
+    const { fileRefId, fileName } = raw;
+    if (raw["kind"] !== "file" || typeof fileRefId !== "string" || typeof fileName !== "string") {
+        return null;
+    }
+    return { kind: "file", fileRefId, fileName };
+}
+export function parseLinkedResourceEntries(raw) {
+    if (!raw)
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+    if (!isPlainObject(parsed))
+        return {};
+    const entries = {};
+    for (const [key, value] of Object.entries(parsed)) {
+        const entry = toLinkedResourceEntry(value);
+        if (entry !== null)
+            entries[key] = entry;
+    }
+    return entries;
+}
+export function imageLinksOf(entries) {
+    const images = {};
+    for (const [key, entry] of Object.entries(entries)) {
+        if (typeof entry === "string")
+            images[key] = entry;
+    }
+    return images;
+}
+export function fileAttachmentsOf(entries) {
+    return Object.entries(entries)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .flatMap(([, entry]) => (isFileAttachmentEntry(entry) ? [entry] : []));
+}
+export function pdfAttachmentLinksOf(entries) {
+    return Object.entries(entries)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .flatMap(([, entry]) => (isPdfAttachmentLink(entry) ? [entry] : []));
+}
+export function attachmentEntriesOf(entries) {
+    return Object.entries(entries).flatMap(([key, entry]) => typeof entry === "string" ? [] : [[key, entry]]);
+}
+export function imageResourceKeysOf(raw) {
+    return Object.keys(imageLinksOf(parseLinkedResourceEntries(raw)));
+}

package/dist/template-resolver/pdf-constants.d.ts

@@ -0,0 +1,7 @@
+export declare const PDF_PAGE_FORMATS: readonly ["A4", "Letter"];
+export type PdfPageFormat = (typeof PDF_PAGE_FORMATS)[number];
+export declare const PDF_ORIENTATIONS: readonly ["portrait", "landscape"];
+export type PdfOrientation = (typeof PDF_ORIENTATIONS)[number];
+export declare const PDF_DEFAULT_MARGIN_MM = 15;
+export declare const PDF_HEADER_MARGIN_MM = 30;
+export declare const PDF_FOOTER_MARGIN_MM = 20;

package/dist/template-resolver/pdf-constants.js

@@ -0,0 +1,8 @@
+// @runtime client
+// No imports: web/ re-exports these, and constants.ts pulls in the framework engine.
+export const PDF_PAGE_FORMATS = ["A4", "Letter"];
+export const PDF_ORIENTATIONS = ["portrait", "landscape"];
+// Page margins in mm; the header/footer values apply when the layout contributes that region and the template sets no margin itself.
+export const PDF_DEFAULT_MARGIN_MM = 15;
+export const PDF_HEADER_MARGIN_MM = 30;
+export const PDF_FOOTER_MARGIN_MM = 20;

package/dist/template-resolver/preview-display-html.d.ts

@@ -0,0 +1,7 @@
+import type { InlineAttachmentRef } from "../renderer-foundation/index.js";
+export declare const PREVIEW_IMAGE_BUDGET_BYTES: number;
+export type PreviewAttachmentReader = (ref: InlineAttachmentRef) => Promise<{
+    readonly content: Uint8Array;
+    readonly contentType: string;
+} | null>;
+export declare function buildDisplayHtml(html: string, inline: readonly InlineAttachmentRef[], readAttachment: PreviewAttachmentReader): Promise<string>;

package/dist/template-resolver/preview-display-html.js

@@ -0,0 +1,27 @@
+export const PREVIEW_IMAGE_BUDGET_BYTES = 5 * 1024 * 1024;
+const DISPLAYABLE_IMAGE_TYPES = new Set([
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp",
+]);
+// The preview shows images the mail client would resolve by Content-ID; a browser cannot, so each
+// resolved image becomes a data URI. `html` itself stays untouched because the send path needs the cids.
+export async function buildDisplayHtml(html, inline, readAttachment) {
+    let displayHtml = html;
+    let usedBytes = 0;
+    for (const ref of inline) {
+        const needle = `src="cid:${ref.cid}"`;
+        if (!displayHtml.includes(needle))
+            continue;
+        const found = await readAttachment(ref);
+        if (found === null || !DISPLAYABLE_IMAGE_TYPES.has(found.contentType))
+            continue;
+        if (usedBytes + found.content.length > PREVIEW_IMAGE_BUDGET_BYTES)
+            continue;
+        usedBytes += found.content.length;
+        const dataUri = `src="data:${found.contentType};base64,${Buffer.from(found.content).toString("base64")}"`;
+        displayHtml = displayHtml.replaceAll(needle, () => dataUri);
+    }
+    return displayHtml;
+}

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

@@ -0,0 +1 @@
+export declare function prepareDocumentForPrint(html: string): string;

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

@@ -0,0 +1,55 @@
+// Server-only (happy-dom). Prepares a rendered document body for the browser
+// that prints it: repeating table headers become real <thead> rows, and
+// everything that would make the browser fetch something external is removed.
+import { withParsedDocument } from "./document-sanitizer.js";
+const REPEAT_HEADER_ATTRIBUTE = "data-repeat-header";
+const FETCHING_ELEMENTS = "script, link, iframe, object, embed, video, audio, source, meta, base, style";
+const FETCHING_ATTRIBUTES = ["src", "srcset", "poster", "background", "data"];
+// Anchors only navigate; on svg image/use/feImage an href fetches.
+const HREF_ATTRIBUTES = ["href", "xlink:href"];
+const EXTERNAL_STYLE_REFERENCE = /url\(|@import/i;
+function isEmbeddedValue(value) {
+    return value.trim().toLowerCase().startsWith("data:");
+}
+function moveRepeatHeadersIntoThead(table) {
+    const rows = Array.from(table.querySelectorAll("tr")).filter((row) => row.closest("table") === table);
+    const leading = [];
+    for (const row of rows) {
+        if (!row.hasAttribute(REPEAT_HEADER_ATTRIBUTE))
+            break;
+        leading.push(row);
+    }
+    // skip: a table without leading repeat-header rows keeps its structure as written
+    if (leading.length === 0)
+        return;
+    const thead = table.ownerDocument.createElement("thead");
+    for (const row of leading) {
+        row.removeAttribute(REPEAT_HEADER_ATTRIBUTE);
+        thead.appendChild(row);
+    }
+    table.insertBefore(thead, table.firstChild);
+}
+export function prepareDocumentForPrint(html) {
+    return withParsedDocument(html, (body) => {
+        for (const table of Array.from(body.querySelectorAll("table"))) {
+            moveRepeatHeadersIntoThead(table);
+        }
+        for (const element of Array.from(body.querySelectorAll(FETCHING_ELEMENTS)))
+            element.remove();
+        for (const element of Array.from(body.querySelectorAll("*"))) {
+            for (const name of FETCHING_ATTRIBUTES) {
+                const value = element.getAttribute(name);
+                if (value !== null && !isEmbeddedValue(value))
+                    element.removeAttribute(name);
+            }
+            if (element.tagName.toLowerCase() !== "a") {
+                for (const name of HREF_ATTRIBUTES)
+                    element.removeAttribute(name);
+            }
+            const style = element.getAttribute("style");
+            if (style !== null && EXTERNAL_STYLE_REFERENCE.test(style))
+                element.removeAttribute("style");
+        }
+        return body.innerHTML;
+    });
+}

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

@@ -4,11 +4,31 @@ export declare const TemplateResolverHandlers: {
     readonly upsertTenant: "template-resolver:write:upsert-tenant";
     readonly publish: "template-resolver:write:publish";
     readonly archive: "template-resolver:write:archive";
+    readonly publishSystem: "template-resolver:write:publish-system";
+    readonly archiveSystem: "template-resolver:write:archive-system";
+    readonly discardDraft: "template-resolver:write:discard-draft";
+    readonly discardDraftSystem: "template-resolver:write:discard-draft-system";
+    readonly resetToSystem: "template-resolver:write:reset-to-system";
     readonly set: "template-resolver:write:set";
+    readonly importBundle: "template-resolver:write:import-bundle";
+    readonly importBundleSystem: "template-resolver:write:import-bundle-system";
+    readonly copyLocale: "template-resolver:write:copy-locale";
+    readonly resourceUpload: "template-resolver:write:resource-upload";
+    readonly resourceRemove: "template-resolver:write:resource-remove";
+    readonly resourceLinkPdf: "template-resolver:write:resource-link-pdf";
+    readonly sendTest: "template-resolver:write:send-test";
 };
 export declare const TemplateResolverQueries: {
     readonly findById: "template-resolver:query:find-by-id";
     readonly list: "template-resolver:query:list";
+    readonly usage: "template-resolver:query:usage";
+    readonly overview: "template-resolver:query:overview";
+    readonly layoutSource: "template-resolver:query:layout-source";
+    readonly tenantOverrides: "template-resolver:query:tenant-overrides";
+    readonly diffToSystem: "template-resolver:query:diff-to-system";
+    readonly validate: "template-resolver:query:validate";
+    readonly preview: "template-resolver:query:preview";
+    readonly exportBundle: "template-resolver:query:export-bundle";
     readonly bySlug: "template-resolver:query:by-slug";
     readonly byTenant: "template-resolver:query:by-tenant";
 };
@@ -19,6 +39,20 @@ export declare const TemplateResolverErrors: {
     readonly invalidSlug: "invalid_slug";
     readonly invalidLocale: "invalid_locale";
     readonly systemAdminRequired: "system_admin_required";
+    readonly noDraft: "no_draft";
     readonly alreadyActive: "template_already_active";
     readonly alreadyArchived: "template_already_archived";
+    readonly targetExists: "target_exists";
+    readonly systemResourcesNeedSystemTenant: "system_resources_need_system_tenant";
+    readonly bundleLocalesDiffer: "bundle_locales_differ";
+    readonly resourceTooLarge: "template_resource_too_large";
+    readonly resourceUnsupportedImage: "template_resource_unsupported_image";
+    readonly attachmentUnsupportedType: "template_attachment_unsupported_type";
+    readonly attachmentLimit: "template_attachment_limit";
+    readonly attachmentInvalid: "template_attachment_invalid";
+    readonly attachmentPdfTemplateMissing: "template_attachment_pdf_template_missing";
+    readonly previewRenderFailed: "template_preview_render_failed";
+    readonly testMailNoChannel: "template_test_mail_no_channel";
+    readonly testMailNoAddress: "template_test_mail_no_address";
+    readonly testMailFailed: "template_test_mail_failed";
 };

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

@@ -6,11 +6,31 @@ export const TemplateResolverHandlers = {
     upsertTenant: "template-resolver:write:upsert-tenant",
     publish: "template-resolver:write:publish",
     archive: "template-resolver:write:archive",
+    publishSystem: "template-resolver:write:publish-system",
+    archiveSystem: "template-resolver:write:archive-system",
+    discardDraft: "template-resolver:write:discard-draft",
+    discardDraftSystem: "template-resolver:write:discard-draft-system",
+    resetToSystem: "template-resolver:write:reset-to-system",
     set: "template-resolver:write:set",
+    importBundle: "template-resolver:write:import-bundle",
+    importBundleSystem: "template-resolver:write:import-bundle-system",
+    copyLocale: "template-resolver:write:copy-locale",
+    resourceUpload: "template-resolver:write:resource-upload",
+    resourceRemove: "template-resolver:write:resource-remove",
+    resourceLinkPdf: "template-resolver:write:resource-link-pdf",
+    sendTest: "template-resolver:write:send-test",
 };
 export const TemplateResolverQueries = {
     findById: "template-resolver:query:find-by-id",
     list: "template-resolver:query:list",
+    usage: "template-resolver:query:usage",
+    overview: "template-resolver:query:overview",
+    layoutSource: "template-resolver:query:layout-source",
+    tenantOverrides: "template-resolver:query:tenant-overrides",
+    diffToSystem: "template-resolver:query:diff-to-system",
+    validate: "template-resolver:query:validate",
+    preview: "template-resolver:query:preview",
+    exportBundle: "template-resolver:query:export-bundle",
     // Public pair — anonymous-reachable, kind pinned to text-block.
     bySlug: "template-resolver:query:by-slug",
     byTenant: "template-resolver:query:by-tenant",
@@ -30,6 +50,20 @@ export const TemplateResolverErrors = {
     invalidSlug: "invalid_slug",
     invalidLocale: "invalid_locale",
     systemAdminRequired: "system_admin_required",
+    noDraft: "no_draft",
     alreadyActive: "template_already_active",
     alreadyArchived: "template_already_archived",
+    targetExists: "target_exists",
+    systemResourcesNeedSystemTenant: "system_resources_need_system_tenant",
+    bundleLocalesDiffer: "bundle_locales_differ",
+    resourceTooLarge: "template_resource_too_large",
+    resourceUnsupportedImage: "template_resource_unsupported_image",
+    attachmentUnsupportedType: "template_attachment_unsupported_type",
+    attachmentLimit: "template_attachment_limit",
+    attachmentInvalid: "template_attachment_invalid",
+    attachmentPdfTemplateMissing: "template_attachment_pdf_template_missing",
+    previewRenderFailed: "template_preview_render_failed",
+    testMailNoChannel: "template_test_mail_no_channel",
+    testMailNoAddress: "template_test_mail_no_address",
+    testMailFailed: "template_test_mail_failed",
 };

package/dist/template-resolver/record-mapping.d.ts

@@ -0,0 +1,2 @@
+import type { NotificationRecordMapping } from "@cosmicdrift/kumiko-framework/engine";
+export declare function mapRecordToVariables(mapping: NotificationRecordMapping, row: Readonly<Record<string, unknown>>): Record<string, unknown>;