@cosmicdrift/kumiko-bundled-features 0.362.0 → 0.363.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,23 @@
 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_PAGE_FORMATS, 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, DocumentRepeatRow, 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 { 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 MailTemplateMeta, type PdfTemplateMeta, parseTemplateMeta, pdfAttachmentFileNamePatternSchema, 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,21 @@
 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_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, DocumentRepeatRow, 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 { 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, 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-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/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,29 @@ 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 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";
 };
@@ -21,4 +39,16 @@ export declare const TemplateResolverErrors: {
     readonly systemAdminRequired: "system_admin_required";
     readonly alreadyActive: "template_already_active";
     readonly alreadyArchived: "template_already_archived";
+    readonly targetExists: "target_exists";
+    readonly systemResourcesNeedSystemTenant: "system_resources_need_system_tenant";
+    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,29 @@ 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",
+    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",
@@ -32,4 +50,16 @@ export const TemplateResolverErrors = {
     systemAdminRequired: "system_admin_required",
     alreadyActive: "template_already_active",
     alreadyArchived: "template_already_archived",
+    targetExists: "target_exists",
+    systemResourcesNeedSystemTenant: "system_resources_need_system_tenant",
+    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>;

package/dist/template-resolver/record-mapping.js

@@ -0,0 +1,21 @@
+function readPath(row, path) {
+    let current = row;
+    for (const segment of path.split(".")) {
+        if (typeof current !== "object" || current === null || !Object.hasOwn(current, segment)) {
+            return undefined;
+        }
+        current = Object.getOwnPropertyDescriptor(current, segment)?.value;
+    }
+    return current;
+}
+// Variables whose path is missing on the row are left out, so the template
+// renders them empty instead of printing "undefined".
+export function mapRecordToVariables(mapping, row) {
+    const variables = {};
+    for (const [variable, path] of Object.entries(mapping.map)) {
+        const value = readPath(row, path);
+        if (value !== undefined)
+            variables[variable] = value;
+    }
+    return variables;
+}

package/dist/template-resolver/resource-image.d.ts

@@ -0,0 +1,15 @@
+declare const CONTENT_TYPE_BY_FORMAT: {
+    readonly png: "image/png";
+    readonly jpeg: "image/jpeg";
+    readonly gif: "image/gif";
+    readonly webp: "image/webp";
+};
+type ResourceImageFormat = keyof typeof CONTENT_TYPE_BY_FORMAT;
+export type NormalizedResourceImage = {
+    readonly data: Uint8Array;
+    readonly contentType: (typeof CONTENT_TYPE_BY_FORMAT)[ResourceImageFormat];
+    readonly width: number;
+    readonly height: number;
+};
+export declare function normalizeResourceImage(data: Uint8Array): Promise<NormalizedResourceImage>;
+export {};

package/dist/template-resolver/resource-image.js

@@ -0,0 +1,34 @@
+import { assertNotSvg, SHARP_INPUT_OPTIONS } from "../shared/index.js";
+const MAX_RESOURCE_WIDTH = 1200;
+const CONTENT_TYPE_BY_FORMAT = {
+    png: "image/png",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+};
+function isResourceImageFormat(format) {
+    return format !== undefined && Object.hasOwn(CONTENT_TYPE_BY_FORMAT, format);
+}
+// Re-encodes an uploaded image: the stored content type comes from the decoded format, never
+// from the client, and re-encoding drops metadata and anything appended to the file.
+// sharp is imported lazily because every app loads template-resolver, few of them need an image decoder.
+export async function normalizeResourceImage(data) {
+    const { default: sharp } = await import("sharp");
+    const metadata = await sharp(data, SHARP_INPUT_OPTIONS).metadata();
+    assertNotSvg(metadata.format);
+    if (!isResourceImageFormat(metadata.format)) {
+        throw new Error(`unsupported image format "${metadata.format ?? "unknown"}"`);
+    }
+    const format = metadata.format;
+    const pipeline = sharp(data, SHARP_INPUT_OPTIONS)
+        .rotate()
+        .resize({ width: MAX_RESOURCE_WIDTH, withoutEnlargement: true })
+        .toFormat(format);
+    const { data: output, info } = await pipeline.toBuffer({ resolveWithObject: true });
+    return {
+        data: new Uint8Array(output),
+        contentType: CONTENT_TYPE_BY_FORMAT[format],
+        width: info.width,
+        height: info.height,
+    };
+}