@cosmicdrift/kumiko-bundled-features 0.362.0 → 0.364.0

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

@@ -0,0 +1,418 @@
+import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
+import { NotFoundError, UnprocessableError, ValidationError, } from "@cosmicdrift/kumiko-framework/errors";
+import { fileRefsTable } from "@cosmicdrift/kumiko-framework/files";
+import { escapeHtml } from "@cosmicdrift/kumiko-headless";
+import { createEmailAttachmentReader, createTemplateMailRenderer } from "../delivery/index.js";
+import { fileContextForTenant } from "../file-foundation/index.js";
+import { collectRendererPlugins, createRendererFoundationApi, RendererError, } from "../renderer-foundation/index.js";
+import { createTemplateResolverApi, TemplateNotFoundError } from "./api.js";
+import { collectDocumentResourceKeys } from "./compile-document-body.js";
+import { DEFAULT_MAIL_LAYOUT_SLUG, MAIL_PREVIEW_MAX_BYTES, SYSTEM_TENANT_ID, } from "./constants.js";
+import { parseStoredJson } from "./handlers/template-gates.js";
+import { validateTemplateDraft } from "./handlers/validate.query.js";
+import { readLayoutRegions, sanitizeLayoutHtml, } from "./layout-regions.js";
+import { parseLinkedResourceEntries } from "./linked-resources.js";
+import { buildDisplayHtml } from "./preview-display-html.js";
+import { TemplateResolverErrors } from "./qualified-names.js";
+import { templateResourcesTable } from "./table.js";
+import { isMailTemplateMeta, parseTemplateMeta, readPdfTemplateMeta, } from "./template-meta.js";
+const SAMPLE_LINK = "https://example.com";
+const SAMPLE_DATE = "2026-01-15";
+const SAMPLE_LIST_ROWS = 3;
+const DEFAULT_PDF_LAYOUT_SLUG = "default";
+function sampleScalar(name, def) {
+    if (def.example !== undefined)
+        return def.example;
+    switch (def.type) {
+        case "text":
+            return `[${def.label ?? name}]`;
+        case "richText":
+            return `<p>[${escapeHtml(def.label ?? name)}]</p>`;
+        case "link":
+            return SAMPLE_LINK;
+        case "money":
+            return 0;
+        case "date":
+            return SAMPLE_DATE;
+    }
+}
+function sampleRow(item, given = {}) {
+    const row = {};
+    for (const [name, def] of Object.entries(item))
+        row[name] = sampleScalar(name, def);
+    return { ...row, ...given };
+}
+function sampleList(def) {
+    const rows = (def.example ?? [])
+        .slice(0, SAMPLE_LIST_ROWS)
+        .map((given) => sampleRow(def.item, given));
+    while (rows.length < SAMPLE_LIST_ROWS)
+        rows.push(sampleRow(def.item));
+    return rows;
+}
+// Declared examples win; the fallbacks are deterministic so a preview never differs between calls.
+export function sampleValuesFor(variables) {
+    const values = {};
+    for (const [name, def] of Object.entries(variables)) {
+        values[name] = def.type === "list" ? sampleList(def) : sampleScalar(name, def);
+    }
+    return values;
+}
+const utf8Bytes = (value) => new TextEncoder().encode(value).length;
+const failed = (error) => ({ ok: false, error });
+async function loadStoredDraft(ctx, user, input) {
+    try {
+        return await createTemplateResolverApi(ctx.db).resolveTemplate({
+            tenantId: user.tenantId,
+            slug: input.slug,
+            kind: input.kind,
+            locale: input.locale,
+        });
+    }
+    catch (e) {
+        if (e instanceof TemplateNotFoundError)
+            return null;
+        throw e;
+    }
+}
+async function describeAttachments(ctx, refs) {
+    const fileRefIds = refs.flatMap((ref) => (ref.kind === "rendered-pdf" ? [] : [ref.fileRefId]));
+    const rows = fileRefIds.length === 0
+        ? []
+        : await selectMany(ctx.db, fileRefsTable, {
+            id: fileRefIds,
+        });
+    const sizeById = new Map(rows.map((row) => [row.id, Number(row.size)]));
+    // An inline image is named by its content id because the stored file name is personal data and
+    // may be ciphertext; a file attachment carries the name the admin gave it.
+    const attachments = refs.map((ref) => previewAttachmentOf(ref, sizeById));
+    // A fileRef without a row has no known size: it is reported, not counted as 0 bytes.
+    const missing = refs.flatMap((ref, index) => ref.kind !== "rendered-pdf" && !sizeById.has(ref.fileRefId)
+        ? [attachments[index]?.name ?? ""]
+        : []);
+    return { attachments, missing };
+}
+function previewAttachmentOf(ref, sizeById) {
+    switch (ref.kind) {
+        case "inline":
+            return {
+                kind: "inline",
+                cid: ref.cid,
+                name: ref.cid,
+                sizeBytes: sizeById.get(ref.fileRefId) ?? 0,
+            };
+        case "file":
+            return { kind: "file", name: ref.fileName, sizeBytes: sizeById.get(ref.fileRefId) ?? 0 };
+        case "rendered-pdf":
+            return { kind: "rendered-pdf", name: ref.fileName, templateSlug: ref.templateSlug };
+    }
+}
+// Part headers and multipart boundary lines around one attachment in the MIME message.
+export const MIME_PART_OVERHEAD_BYTES = 512;
+// The provider cap applies to the encoded message: attachments travel base64-encoded.
+export function encodedAttachmentBytes(rawBytes) {
+    return Math.ceil(rawBytes / 3) * 4 + MIME_PART_OVERHEAD_BYTES;
+}
+const attachmentSizeOf = (attachment) => attachment.kind === "rendered-pdf" ? 0 : encodedAttachmentBytes(attachment.sizeBytes);
+export function estimateMailBytes(args) {
+    return (utf8Bytes(args.html) +
+        utf8Bytes(args.text) +
+        args.attachments.reduce((sum, attachment) => sum + attachmentSizeOf(attachment), 0));
+}
+// The row an editor is working on, whatever its status: the stored template only resolves when
+// active, so a draft would otherwise lose the images and attachments uploaded to it.
+async function loadEditedRowResources(ctx, user, input) {
+    const rows = await selectMany(ctx.db, templateResourcesTable, { tenantId: user.tenantId, slug: input.slug, kind: "mail", locale: input.locale }, { limit: 1 });
+    const row = rows[0];
+    return row === undefined ? undefined : parseLinkedResourceEntries(row.linkedResources);
+}
+async function resolvePdfLayout(ctx, user, slug, locale) {
+    const api = createTemplateResolverApi(ctx.db);
+    const find = async (tenantId) => {
+        try {
+            return await api.resolveLayout({ tenantId, slug, kind: "pdf-layout", locale });
+        }
+        catch (e) {
+            if (e instanceof TemplateNotFoundError)
+                return null;
+            throw e;
+        }
+    };
+    let layout = await find(user.tenantId);
+    let html = layout?.content ?? "";
+    if (layout !== null && layout.scope !== "system") {
+        // Re-checked like the mail renderer does: a tenant row that predates the write gate must not pass.
+        const sanitized = sanitizeLayoutHtml(html);
+        if (sanitized.ok)
+            html = sanitized.html;
+        else {
+            layout = await find(SYSTEM_TENANT_ID);
+            html = layout?.content ?? "";
+        }
+    }
+    if (layout === null)
+        return null;
+    return { slug, scope: layout.scope, html, regions: readLayoutRegions(html) };
+}
+function missingResourceCheck(missing) {
+    return {
+        code: "resources_resolved",
+        ok: missing.length === 0,
+        i18nKey: "templateResolver.checks.resourcesResolved",
+        params: { missing },
+    };
+}
+function requiredPlaceholdersCheck(missing) {
+    return {
+        code: "required_placeholders",
+        ok: missing.length === 0,
+        i18nKey: "templateResolver.checks.requiredPlaceholders",
+        params: { missing },
+    };
+}
+function toRenderFailure(e) {
+    if (!(e instanceof RendererError))
+        throw e;
+    return failed(new UnprocessableError(TemplateResolverErrors.previewRenderFailed, {
+        i18nKey: "templateResolver.errors.preview.renderFailed",
+        details: { code: e.code },
+    }));
+}
+// Only a plugin that prints documents can show the filled-in page; without one the editor
+// still gets the body and the raw layout, just without placeholder values.
+function documentPreviewPlugin(ctx, tenantId) {
+    try {
+        const plugin = createRendererFoundationApi(collectRendererPlugins(ctx.registry)).createRendererForTenant({ tenantId, kind: "document-pdf" });
+        return plugin.previewDocument === undefined ? null : plugin;
+    }
+    catch (e) {
+        if (e instanceof RendererError && e.code === "no_plugin_for_kind")
+            return null;
+        throw e;
+    }
+}
+async function renderDocumentPreview(ctx, user, args) {
+    const { input, content, meta, validation, sampleValues } = args;
+    const pdfMeta = meta.ok ? readPdfTemplateMeta(meta.meta) : null;
+    const requiredCheck = requiredPlaceholdersCheck(validation.missingRequired);
+    const plugin = documentPreviewPlugin(ctx, user.tenantId);
+    if (plugin?.previewDocument === undefined) {
+        return {
+            ok: true,
+            mailAttachments: [],
+            sender: {},
+            preview: {
+                kind: "document-pdf",
+                subject: null,
+                previewText: null,
+                html: content,
+                text: null,
+                attachments: [],
+                layout: await resolvePdfLayout(ctx, user, pdfMeta?.layoutSlug ?? DEFAULT_PDF_LAYOUT_SLUG, input.locale),
+                sampleValues,
+                checks: [missingResourceCheck(validation.warnings.map((w) => w.detail)), requiredCheck],
+                validation,
+            },
+        };
+    }
+    let document;
+    try {
+        document = await plugin.previewDocument({
+            slug: input.slug,
+            locale: input.locale,
+            variables: sampleValues,
+            draft: { content, meta: pdfMeta, variableSchema: args.variableSchema },
+        }, {
+            db: ctx.db,
+            registry: ctx.registry,
+            tenantId: user.tenantId,
+            ...(ctx.config !== undefined && { config: ctx.config }),
+            filesForTenant: (fileTenantId) => fileContextForTenant(ctx, ctx.user.tenantId, fileTenantId),
+        });
+    }
+    catch (e) {
+        return toRenderFailure(e);
+    }
+    const layout = document.layout;
+    return {
+        ok: true,
+        mailAttachments: [],
+        sender: {},
+        preview: {
+            kind: "document-pdf",
+            subject: null,
+            previewText: null,
+            html: document.bodyHtml,
+            text: null,
+            attachments: [],
+            layout: layout === null
+                ? null
+                : {
+                    slug: layout.slug,
+                    scope: layout.scope,
+                    html: `${layout.headerHtml}${layout.signatureHtml}${layout.footerHtml}`,
+                    regions: {
+                        header: layout.headerHtml,
+                        signature: layout.signatureHtml,
+                        footer: layout.footerHtml,
+                    },
+                },
+            sampleValues,
+            checks: [missingResourceCheck(document.missingResourceKeys), requiredCheck],
+            validation,
+        },
+    };
+}
+// The caller derives `scope` once from the role (SystemAdmin edits the system row), so the write
+// gates and the print see the same row: a failing draft is rejected with the same problems as a save.
+export async function evaluateDocumentDraft(ctx, user, scope, draft) {
+    const { response, evaluation } = await validateTemplateDraft(ctx, user, {
+        slug: draft.slug,
+        kind: "document-pdf",
+        contentFormat: "html",
+        content: draft.content,
+        meta: draft.meta,
+        variableSchema: draft.variableSchema,
+        locale: draft.locale,
+        scope,
+    });
+    if (!evaluation.ok) {
+        return { ok: false, error: new ValidationError({ fields: [...evaluation.issues] }) };
+    }
+    const meta = parseTemplateMeta("document-pdf", parseStoredJson(evaluation.metaJson));
+    return {
+        ok: true,
+        content: evaluation.content ?? "",
+        meta: meta.ok ? readPdfTemplateMeta(meta.meta) : null,
+        variableSchema: draft.variableSchema,
+        sampleValues: sampleValuesFor(response.variables),
+    };
+}
+// The posted draft when it carries content, else the stored template; null when none is stored.
+async function resolveDraftSource(ctx, user, input) {
+    if (input.content !== undefined) {
+        return { content: input.content, meta: input.meta, variableSchema: input.variableSchema };
+    }
+    const stored = await loadStoredDraft(ctx, user, input);
+    if (stored === null)
+        return null;
+    return { content: stored.content, meta: stored.meta, variableSchema: stored.variableSchema };
+}
+async function renderMailPreview(ctx, user, args) {
+    const { input, content, meta, validation, sampleValues, variableSchema: draftVariableSchema, } = args;
+    if (!meta.ok || !isMailTemplateMeta(meta.meta)) {
+        return failed(new UnprocessableError(TemplateResolverErrors.previewRenderFailed, {
+            i18nKey: "templateResolver.errors.preview.renderFailed",
+            details: { code: "invalid_meta" },
+        }));
+    }
+    const mailMeta = meta.meta;
+    const editedResources = input.content === undefined ? undefined : await loadEditedRowResources(ctx, user, input);
+    let rendered;
+    try {
+        rendered = await createTemplateMailRenderer(ctx.db, ctx.registry, user.tenantId, ctx.config)({
+            slug: input.slug,
+            locale: input.locale,
+            variables: sampleValues,
+            draft: {
+                content,
+                meta: mailMeta,
+                variableSchema: draftVariableSchema,
+                ...(editedResources !== undefined && { linkedResources: editedResources }),
+            },
+        });
+    }
+    catch (e) {
+        return toRenderFailure(e);
+    }
+    const mailAttachments = rendered.attachments ?? [];
+    const inline = mailAttachments.filter((ref) => ref.kind === "inline");
+    const { attachments, missing: missingAttachments } = await describeAttachments(ctx, mailAttachments);
+    const displayHtml = await buildDisplayHtml(rendered.html, inline, createEmailAttachmentReader(ctx.db, ctx.registry, user.tenantId, ctx.config, (tenantId) => fileContextForTenant(ctx, ctx.user.tenantId, tenantId)));
+    const resolvedCids = new Set(inline.map((ref) => ref.cid));
+    const unresolved = collectDocumentResourceKeys(content).filter((key) => !resolvedCids.has(key));
+    const totalBytes = estimateMailBytes({ html: rendered.html, text: rendered.text, attachments });
+    return {
+        ok: true,
+        mailAttachments,
+        sender: {
+            ...(rendered.fromName !== undefined && { fromName: rendered.fromName }),
+            ...(rendered.replyTo !== undefined && { replyTo: rendered.replyTo }),
+        },
+        preview: {
+            kind: "mail",
+            subject: rendered.subject,
+            previewText: rendered.previewText ?? null,
+            html: rendered.html,
+            displayHtml,
+            text: rendered.text,
+            attachments,
+            layout: null,
+            mailLayout: rendered.layout === undefined
+                ? null
+                : {
+                    slug: mailMeta.layoutSlug ?? DEFAULT_MAIL_LAYOUT_SLUG,
+                    scope: rendered.layout.scope,
+                    version: rendered.layout.templateVersion,
+                },
+            sampleValues,
+            checks: [
+                missingResourceCheck([...unresolved, ...missingAttachments]),
+                {
+                    code: "text_present",
+                    ok: rendered.text.trim() !== "",
+                    i18nKey: "templateResolver.checks.textPresent",
+                },
+                {
+                    code: "size_under_cap",
+                    ok: totalBytes <= MAIL_PREVIEW_MAX_BYTES,
+                    i18nKey: "templateResolver.checks.sizeUnderCap",
+                    params: { totalBytes, maxBytes: MAIL_PREVIEW_MAX_BYTES },
+                },
+                requiredPlaceholdersCheck(validation.missingRequired),
+            ],
+            validation,
+        },
+    };
+}
+// Renders a draft (or, without content, the stored template) with sample values, going through
+// the same write gates and the same mail renderer as a real send. Nothing is stored or sent.
+export async function renderTemplatePreview(ctx, user, input) {
+    const draftSource = await resolveDraftSource(ctx, user, input);
+    if (draftSource === null)
+        return failed(new NotFoundError("template-resource", input.slug));
+    const { content: draftContent, meta: draftMeta, variableSchema: draftVariableSchema, } = draftSource;
+    const { response: validation, evaluation } = await validateTemplateDraft(ctx, user, {
+        slug: input.slug,
+        kind: input.kind,
+        contentFormat: "html",
+        content: draftContent,
+        meta: draftMeta,
+        variableSchema: draftVariableSchema,
+        locale: input.locale,
+        scope: "tenant",
+    });
+    if (!evaluation.ok)
+        return failed(new ValidationError({ fields: [...evaluation.issues] }));
+    const content = evaluation.content ?? "";
+    const meta = parseTemplateMeta(input.kind, parseStoredJson(evaluation.metaJson));
+    const sampleValues = sampleValuesFor(validation.variables);
+    if (input.kind === "document-pdf") {
+        return renderDocumentPreview(ctx, user, {
+            input,
+            content,
+            meta,
+            variableSchema: draftVariableSchema,
+            sampleValues,
+            validation,
+        });
+    }
+    return renderMailPreview(ctx, user, {
+        input,
+        content,
+        meta,
+        variableSchema: draftVariableSchema,
+        sampleValues,
+        validation,
+    });
+}

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

@@ -0,0 +1,19 @@
+import type { HandlerContext, SessionUser, TenantId, WriteResult } from "@cosmicdrift/kumiko-framework/engine";
+import type { LinkedResourceEntry } from "./linked-resources.js";
+export type TemplateResourceFile = {
+    readonly fileName: string;
+    readonly contentType: string;
+    readonly bytes: Uint8Array;
+};
+export declare function readTemplateResource(ctx: Pick<HandlerContext, "db" | "files" | "user">, fileRefId: string): Promise<TemplateResourceFile | null>;
+export declare function duplicateLinkedResourceFiles(ctx: HandlerContext, args: {
+    readonly user: SessionUser;
+    readonly tenantId: TenantId;
+    readonly resources: Readonly<Record<string, LinkedResourceEntry>>;
+}): Promise<WriteResult<Record<string, LinkedResourceEntry>>>;
+export declare function attachTemplateResources(ctx: Pick<HandlerContext, "forTenant">, args: {
+    readonly user: SessionUser;
+    readonly tenantId: TenantId;
+    readonly templateId: string;
+    readonly resources: Readonly<Record<string, LinkedResourceEntry>>;
+}): Promise<WriteResult<null>>;

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

@@ -0,0 +1,73 @@
+import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
+import { NotFoundError, writeFailure } from "@cosmicdrift/kumiko-framework/errors";
+import { createFileRefFromBytes, fileRefsTable } from "@cosmicdrift/kumiko-framework/files";
+import { fileContextForTenant } from "../file-foundation/index.js";
+import { requireForTenant } from "../shared/index.js";
+import { executor } from "./handlers/shared.js";
+import { templateResourcesTable } from "./table.js";
+// Reads the file behind a template resource. Null when the fileRef is unknown
+// to the caller's tenant or has no bytes.
+export async function readTemplateResource(ctx, fileRefId) {
+    if (!ctx.files)
+        return null;
+    const row = await fetchOne(ctx.db, fileRefsTable, {
+        id: fileRefId,
+        isDeleted: false,
+    });
+    if (!row)
+        return null;
+    const handle = ctx.files.refFromFileRef(row);
+    if (!(await handle.exists()))
+        return null;
+    return { fileName: row.fileName, contentType: row.mimeType, bytes: await handle.read() };
+}
+// Gives the target tenant its own copy of every file behind the entries, so a template that was
+// copied from the system default keeps working once the tenant exports it or measures its
+// attachments. Rendered-PDF links carry no file and pass through. An entry whose source file is
+// gone is left out: it could not be resolved at render time either.
+export async function duplicateLinkedResourceFiles(ctx, args) {
+    const { user, tenantId } = args;
+    const { db } = requireForTenant(ctx, tenantId);
+    const copies = {};
+    for (const [key, entry] of Object.entries(args.resources)) {
+        if (typeof entry !== "string" && entry.kind === "rendered-pdf") {
+            copies[key] = entry;
+            continue;
+        }
+        const sourceFileRefId = typeof entry === "string" ? entry : entry.fileRefId;
+        const file = await readTemplateResource(ctx, sourceFileRefId);
+        // skip: the source file is gone, there is nothing to copy
+        if (file === null)
+            continue;
+        const created = await createFileRefFromBytes({
+            db,
+            files: fileContextForTenant(ctx, ctx.user.tenantId, tenantId),
+            registry: ctx.registry,
+            user: { ...user, tenantId },
+        }, { fileName: file.fileName, mimeType: file.contentType, data: file.bytes });
+        if (!created.isSuccess)
+            return created;
+        copies[key] =
+            typeof entry === "string" ? created.data.id : { ...entry, fileRefId: created.data.id };
+    }
+    return { isSuccess: true, data: copies };
+}
+// Replaces the whole key map of one row with files that are already stored (bundle import,
+// copy-locale). Single keys go through storeTemplateResource and resource-remove.
+export async function attachTemplateResources(ctx, args) {
+    if (Object.keys(args.resources).length === 0)
+        return { isSuccess: true, data: null };
+    const { db, streamTenantId } = requireForTenant(ctx, args.tenantId);
+    const row = await fetchOne(db, templateResourcesTable, {
+        id: args.templateId,
+        tenantId: args.tenantId,
+    });
+    if (!row)
+        return writeFailure(new NotFoundError("template-resource", args.templateId));
+    const result = await executor.update({
+        id: row.id,
+        version: row.version,
+        changes: { linkedResources: JSON.stringify(args.resources) },
+    }, args.user, db, { streamTenantId });
+    return result.isSuccess ? { isSuccess: true, data: null } : result;
+}

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

@@ -0,0 +1,16 @@
+import { type Registry } from "@cosmicdrift/kumiko-framework/engine";
+import { type TemplateKind } from "./constants.js";
+type UsageRole = "template" | "layout";
+export type TemplateUsageEntry = {
+    readonly qualifiedName: string;
+    readonly feature: string;
+    readonly notification: string;
+    readonly trigger: string | null;
+    readonly role: UsageRole;
+};
+/** Layout slug of the effective stored mail template, by notification qualified
+ *  name and locale. The renderer reads the layout from the stored row's meta,
+ *  so it wins over the code-registered notification meta. */
+export type EffectiveMailLayoutSlugs = ReadonlyMap<string, ReadonlyMap<string, string>>;
+export declare function collectTemplateUsage(registry: Registry, slug: string, kind: TemplateKind, effectiveLayouts?: EffectiveMailLayoutSlugs): TemplateUsageEntry[];
+export {};

package/dist/template-resolver/template-usage.js

@@ -0,0 +1,35 @@
+import { parseQn, } from "@cosmicdrift/kumiko-framework/engine";
+import { DEFAULT_MAIL_LAYOUT_SLUG } from "./constants.js";
+function layoutSlugsOf(qualifiedName, notification, effectiveLayouts) {
+    const stored = effectiveLayouts.get(qualifiedName);
+    const locales = new Set([
+        ...Object.keys(notification.template ?? {}),
+        ...Object.keys(notification.meta ?? {}),
+        ...(stored?.keys() ?? []),
+    ]);
+    return [...locales].map((locale) => stored?.get(locale) ?? notification.meta?.[locale]?.layoutSlug ?? DEFAULT_MAIL_LAYOUT_SLUG);
+}
+export function collectTemplateUsage(registry, slug, kind, effectiveLayouts = new Map()) {
+    const usedBy = [];
+    if (kind === "mail" || kind === "mail-layout") {
+        for (const [qualifiedName, notification] of registry.getAllNotifications()) {
+            const role = kind === "mail" ? "template" : "layout";
+            // Notifications without a code template are not rendered through the resolver.
+            const isUsed = kind === "mail"
+                ? qualifiedName === slug && notification.template !== undefined
+                : layoutSlugsOf(qualifiedName, notification, effectiveLayouts).includes(slug);
+            if (!isUsed)
+                continue;
+            const parsed = parseQn(qualifiedName);
+            usedBy.push({
+                qualifiedName,
+                feature: parsed.scope,
+                notification: parsed.name,
+                trigger: notification.trigger?.on ?? null,
+                role,
+            });
+        }
+    }
+    usedBy.sort((a, b) => a.qualifiedName.localeCompare(b.qualifiedName));
+    return usedBy;
+}

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

@@ -0,0 +1,22 @@
+import type { Registry, TemplateVariables } from "@cosmicdrift/kumiko-framework/engine";
+import type { TemplateMeta } from "./template-meta.js";
+export declare const SYSTEM_PLACEHOLDERS: ReadonlySet<string>;
+export declare function systemPlaceholdersFor(kind: string): ReadonlySet<string>;
+export type TemplateValidation = {
+    readonly unknown: readonly string[];
+    readonly missingRequired: readonly string[];
+    readonly used: readonly string[];
+    /** data-resource keys with no uploaded file; a warning, never a blocker. */
+    readonly unknownResources: readonly string[];
+};
+export declare function resolveTemplateVariables(registry: Registry, slug: string, variableSchema: Readonly<Record<string, unknown>>): TemplateVariables;
+export declare function variablesFromSchema(variableSchema: Readonly<Record<string, unknown>>): TemplateVariables;
+export declare function validateTemplatePlaceholders(input: {
+    readonly kind: string;
+    readonly body: string;
+    readonly meta: TemplateMeta | null;
+    readonly variables: TemplateVariables;
+    /** data-resource keys with an uploaded file besides the built-in `logo`. */
+    readonly resourceKeys?: readonly string[];
+}): TemplateValidation;
+export declare function hasPlaceholderProblems(validation: TemplateValidation): boolean;