@cosmicdrift/kumiko-samples 0.364.0 → 0.365.0

package/packages/bundled-features/src/template-resolver/handlers/copy-locale.write.ts

@@ -2,7 +2,10 @@ import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
 import {
   defineWriteHandler,
   type HandlerContext,
+  type SessionUser,
   SYSTEM_TENANT_ID,
+  type TenantId,
+  type WriteResult,
 } from "@cosmicdrift/kumiko-framework/engine";
 import {
   AccessDeniedError,
@@ -13,12 +16,16 @@ import {
 import { isOneOf } from "@cosmicdrift/kumiko-types/type-guards";
 import * as z from "zod";
 import { requireForTenant } from "../../shared/index.js";
-import { CONTENT_FORMATS } from "../constants.js";
-import { parseLinkedResourceEntries } from "../linked-resources.js";
+import { CONTENT_FORMATS, type ContentFormat } from "../constants.js";
+import { type LinkedResourceEntry, parseLinkedResourceEntries } from "../linked-resources.js";
 import { TemplateResolverErrors } from "../qualified-names.js";
+import {
+  createLinkedResourceCopies,
+  prepareLinkedResourceCopiesBeforeTransaction,
+} from "../store-template-resource.js";
 import { type TemplateResourceRow, templateResourcesTable } from "../table.js";
-import { toWorkingRow } from "../template-draft.js";
-import { attachTemplateResources, duplicateLinkedResourceFiles } from "../template-resources.js";
+import { toWorkingRow, type WorkingRow } from "../template-draft.js";
+import { attachTemplateResources } from "../template-resources.js";
 import { resolveTemplateVariables } from "../template-validation.js";
 import { targetExistsIssue } from "./bundle-import.js";
 import { kindSchema, localeSchema, templateSlugSchema } from "./shared.js";
@@ -62,58 +69,109 @@ async function findCopySource(
   });
 }
 
-export const copyLocaleWrite = defineWriteHandler({
-  name: "copy-locale",
-  schema: z.object({
-    slug: templateSlugSchema,
-    kind: kindSchema,
-    fromLocale: localeSchema,
-    toLocale: localeSchema,
-    overwrite: z.boolean().default(false),
-    /** "system" copies between system-default rows; SystemAdmin only. */
-    scope: z.enum(["tenant", "system"]).default("tenant"),
-  }),
-  access: { roles: ["TenantAdmin", "SystemAdmin"] },
-  description:
-    "Copies the text of one locale of a template into another locale as a draft override of the caller's tenant, taking the tenant's own row or else the system default as the source; use it as the starting point for a translation. It refuses an existing target unless overwrite is set. With scope system (SystemAdmin only) both source and target are system-default rows and the target lands as a system draft; any other caller gets a 403.",
-  handler: async (event, ctx) => {
-    const { slug, kind, fromLocale, toLocale, overwrite, scope } = event.payload;
-    if (scope === "system" && !event.user.roles.includes("SystemAdmin")) {
-      return writeFailure(
-        new AccessDeniedError({
-          i18nKey: "errors.access.denied",
-          details: { reason: TemplateResolverErrors.systemAdminRequired },
-        }),
-      );
-    }
-    const tenantId = scope === "system" ? SYSTEM_TENANT_ID : event.user.tenantId;
-    const refused = refuseTenantScopeUnderSystemTenant(scope, tenantId);
-    if (refused !== null) return refused;
+const copyLocaleSchema = z.object({
+  slug: templateSlugSchema,
+  kind: kindSchema,
+  fromLocale: localeSchema,
+  toLocale: localeSchema,
+  overwrite: z.boolean().default(false),
+  /** "system" copies between system-default rows; SystemAdmin only. */
+  scope: z.enum(["tenant", "system"]).default("tenant"),
+});
 
-    const readDb = readDbFor(ctx, scope);
-    const storedSource = await findCopySource(ctx, {
-      scope,
+type CopyRequest = {
+  readonly scope: CopyScope;
+  readonly tenantId: TenantId;
+  readonly source: WorkingRow;
+  readonly contentFormat: ContentFormat;
+  readonly sourceResources: Readonly<Record<string, LinkedResourceEntry>>;
+  // A system source's files belong to the system tenant: the tenant gets its own copies so
+  // previews, exports and the tenant's override keep working independent of the system row.
+  readonly sourceIsForeign: boolean;
+};
+
+// Runs before the upload (reject early, store nothing) and again in the transaction on the fresh rows.
+async function checkCopyRequest(
+  ctx: WriteCtx,
+  event: {
+    readonly user: SessionUser;
+    readonly payload: z.infer<typeof copyLocaleSchema>;
+  },
+): Promise<WriteResult<CopyRequest>> {
+  const { slug, kind, fromLocale, toLocale, overwrite, scope } = event.payload;
+  if (scope === "system" && !event.user.roles.includes("SystemAdmin")) {
+    return writeFailure(
+      new AccessDeniedError({
+        i18nKey: "errors.access.denied",
+        details: { reason: TemplateResolverErrors.systemAdminRequired },
+      }),
+    );
+  }
+  const tenantId = scope === "system" ? SYSTEM_TENANT_ID : event.user.tenantId;
+  const refused = refuseTenantScopeUnderSystemTenant(scope, tenantId);
+  if (refused !== null) return refused;
+
+  const readDb = readDbFor(ctx, scope);
+  const storedSource = await findCopySource(ctx, {
+    scope,
+    tenantId,
+    slug,
+    kind,
+    locale: fromLocale,
+  });
+  const source = storedSource && toWorkingRow(storedSource, tenantId);
+  const contentFormat = source?.contentFormat;
+  if (!source || !isOneOf(CONTENT_FORMATS, contentFormat)) {
+    return writeFailure(new NotFoundError("template-resource", `${slug}/${fromLocale}`));
+  }
+
+  if (!overwrite) {
+    const target = await fetchOne<TemplateResourceRow>(readDb, templateResourcesTable, {
       tenantId,
       slug,
       kind,
-      locale: fromLocale,
+      locale: toLocale,
     });
-    const source = storedSource && toWorkingRow(storedSource, tenantId);
-    if (!source || !isOneOf(CONTENT_FORMATS, source.contentFormat)) {
-      return writeFailure(new NotFoundError("template-resource", `${slug}/${fromLocale}`));
+    if (target) {
+      return writeFailure(new ValidationError({ fields: [targetExistsIssue(toLocale)] }));
     }
+  }
+  return {
+    isSuccess: true,
+    data: {
+      scope,
+      tenantId,
+      source,
+      contentFormat,
+      sourceResources: parseLinkedResourceEntries(source.linkedResources),
+      sourceIsForeign: source.tenantId !== tenantId,
+    },
+  };
+}
 
-    if (!overwrite) {
-      const target = await fetchOne<TemplateResourceRow>(readDb, templateResourcesTable, {
-        tenantId,
-        slug,
-        kind,
-        locale: toLocale,
-      });
-      if (target) {
-        return writeFailure(new ValidationError({ fields: [targetExistsIssue(toLocale)] }));
-      }
-    }
+export const copyLocaleWrite = defineWriteHandler({
+  name: "copy-locale",
+  schema: copyLocaleSchema,
+  access: { roles: ["TenantAdmin", "SystemAdmin"] },
+  description:
+    "Copies the text of one locale of a template into another locale as a draft override of the caller's tenant, taking the tenant's own row or else the system default as the source; use it as the starting point for a translation. It refuses an existing target unless overwrite is set. With scope system (SystemAdmin only) both source and target are system-default rows and the target lands as a system draft; any other caller gets a 403.",
+  beforeTransaction: async (event, ctx) => {
+    const request = await checkCopyRequest(ctx, event);
+    if (!request.isSuccess) return request;
+    if (!request.data.sourceIsForeign) return { isSuccess: true, data: [] };
+    return prepareLinkedResourceCopiesBeforeTransaction({
+      ctx,
+      user: event.user,
+      tenantId: request.data.tenantId,
+      resources: request.data.sourceResources,
+    });
+  },
+  handler: async (event, ctx) => {
+    const { slug, kind, toLocale } = event.payload;
+    const request = await checkCopyRequest(ctx, event);
+    if (!request.isSuccess) return request;
+    const { scope, tenantId, source, contentFormat, sourceResources, sourceIsForeign } =
+      request.data;
 
     const variableSchema = storedRecord(source.variableSchema);
     const written = await writeTemplateRow({
@@ -128,7 +186,7 @@ export const copyLocaleWrite = defineWriteHandler({
         kind,
         locale: toLocale,
         content: source.content,
-        contentFormat: source.contentFormat,
+        contentFormat,
         variableSchema,
         meta: parseStoredJson(source.meta),
         title: source.title,
@@ -136,17 +194,9 @@ export const copyLocaleWrite = defineWriteHandler({
       },
     });
     if (!written.isSuccess) return written;
-    const sourceResources = parseLinkedResourceEntries(source.linkedResources);
-    // A system source's files belong to the system tenant: the tenant gets its own copies so
-    // previews, exports and the tenant's override keep working independent of the system row.
-    const resources =
-      source.tenantId === tenantId
-        ? { isSuccess: true as const, data: sourceResources }
-        : await duplicateLinkedResourceFiles(ctx, {
-            user: event.user,
-            tenantId,
-            resources: sourceResources,
-          });
+    const resources = sourceIsForeign
+      ? await createLinkedResourceCopies({ ctx, user: event.user, tenantId }, event.prepared)
+      : { isSuccess: true as const, data: sourceResources };
     if (!resources.isSuccess) return resources;
     const attached = await attachTemplateResources(ctx, {
       user: event.user,

package/packages/bundled-features/src/template-resolver/handlers/diff-to-system.query.ts

@@ -24,6 +24,7 @@ export const diffToSystemQuery = defineQueryHandler({
       slug: tenantRow.slug,
       kind: tenantRow.kind,
       locale: tenantRow.locale,
+      status: "active",
     });
     if (!systemRow || isHiddenSystemDraft(query.user, systemRow))
       throw new NotFoundError("template-resource", tenantRow.slug);

package/packages/bundled-features/src/template-resolver/handlers/import-bundle-system.write.ts

@@ -2,7 +2,7 @@ import { defineWriteHandler, SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framew
 import { ValidationError, writeFailure } from "@cosmicdrift/kumiko-framework/errors";
 import * as z from "zod";
 import { templateBundleSchema } from "../template-bundle.js";
-import { importTemplateBundle } from "./bundle-import.js";
+import { importTemplateBundle, prepareTemplateBundleBeforeTransaction } from "./bundle-import.js";
 
 export const importBundleSystemWrite = defineWriteHandler({
   name: "import-bundle-system",
@@ -12,24 +12,23 @@ export const importBundleSystemWrite = defineWriteHandler({
   agent: { risk: "high" as const },
   description:
     "Imports a template bundle as system-default templates, active straight away and overwriting existing system rows; SystemAdmin only. Bundles with resource files need a caller in the system tenant, because the files are stored in the caller's file space.",
-  handler: (event, ctx) => {
+  beforeTransaction: async (event, ctx) => {
     const { bundle } = event.payload;
+    // Must run before any upload.
     if (Object.keys(bundle.resources).length > 0 && event.user.tenantId !== SYSTEM_TENANT_ID) {
-      return Promise.resolve(
-        writeFailure(
-          new ValidationError({
-            fields: [
-              {
-                path: "bundle.resources",
-                code: "system_resources_need_system_tenant",
-                i18nKey: "templateResolver.errors.template.systemResourcesNeedSystemTenant",
-              },
-            ],
-          }),
-        ),
+      return writeFailure(
+        new ValidationError({
+          fields: [
+            {
+              path: "bundle.resources",
+              code: "system_resources_need_system_tenant",
+              i18nKey: "templateResolver.errors.template.systemResourcesNeedSystemTenant",
+            },
+          ],
+        }),
       );
     }
-    return importTemplateBundle({
+    return prepareTemplateBundleBeforeTransaction({
       ctx,
       user: event.user,
       tenantId: SYSTEM_TENANT_ID,
@@ -39,4 +38,15 @@ export const importBundleSystemWrite = defineWriteHandler({
       overwrite: true,
     });
   },
+  handler: (event, ctx) =>
+    importTemplateBundle({
+      ctx,
+      user: event.user,
+      tenantId: SYSTEM_TENANT_ID,
+      scope: "system",
+      status: "active",
+      bundle: event.payload.bundle,
+      overwrite: true,
+      prepared: event.prepared,
+    }),
 });

package/packages/bundled-features/src/template-resolver/handlers/import-bundle.write.ts

@@ -1,7 +1,7 @@
 import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
 import * as z from "zod";
 import { templateBundleSchema } from "../template-bundle.js";
-import { importTemplateBundle } from "./bundle-import.js";
+import { importTemplateBundle, prepareTemplateBundleBeforeTransaction } from "./bundle-import.js";
 
 export const importBundleWrite = defineWriteHandler({
   name: "import-bundle",
@@ -9,6 +9,16 @@ export const importBundleWrite = defineWriteHandler({
   access: { roles: ["TenantAdmin", "SystemAdmin"] },
   description:
     "Imports a template bundle (all locales plus resource files, as produced by export-bundle) into the caller's tenant as drafts; it refuses a locale that already has an override unless overwrite is set, and publish makes the drafts live.",
+  beforeTransaction: (event, ctx) =>
+    prepareTemplateBundleBeforeTransaction({
+      ctx,
+      user: event.user,
+      tenantId: event.user.tenantId,
+      scope: "tenant",
+      status: "draft",
+      bundle: event.payload.bundle,
+      overwrite: event.payload.overwrite,
+    }),
   handler: (event, ctx) =>
     importTemplateBundle({
       ctx,
@@ -18,5 +28,6 @@ export const importBundleWrite = defineWriteHandler({
       status: "draft",
       bundle: event.payload.bundle,
       overwrite: event.payload.overwrite,
+      prepared: event.prepared,
     }),
 });

package/packages/bundled-features/src/template-resolver/handlers/overview.query.ts

@@ -52,6 +52,8 @@ export type OverviewResponse = {
   readonly rows: readonly OverviewRow[];
   readonly nextCursor: null;
   readonly total: number;
+  /** True when the tenant has more template rows than the overview reads; rows and total are then incomplete. */
+  readonly truncated: boolean;
 };
 
 const SORT_FIELDS = ["title", "slug", "kind", "origin", "status", "modifiedAt"] as const;
@@ -285,12 +287,19 @@ export const overviewQuery = defineQueryHandler({
     "Lists mail, PDF and layout templates as one row per slug and kind for the caller's tenant (optionally only the mails and PDFs using one layout slug): where the effective version comes from (own override or system), its locales, status and version (the served one; `draftVersion` is set when an unpublished draft waits beside it, `activeSince` says since when the served version applies), the system version it overrides, the layout it uses and which notifications or templates use it; use it to browse and filter all templates at a glance.",
   handler: async (query, ctx) => {
     const payload = query.payload;
-    const rows = await selectMany<TemplateResourceRow>(
+    const fetchedRows = await selectMany<TemplateResourceRow>(
       ctx.db,
       templateResourcesTable,
       { kind: { in: [...OVERVIEW_KINDS] } },
-      { limit: OVERVIEW_ROW_LIMIT },
+      { orderBy: { col: "id", direction: "asc" }, limit: OVERVIEW_ROW_LIMIT + 1 },
     );
+    const truncated = fetchedRows.length > OVERVIEW_ROW_LIMIT;
+    const rows = truncated ? fetchedRows.slice(0, OVERVIEW_ROW_LIMIT) : fetchedRows;
+    if (truncated) {
+      ctx.log?.warn("template overview: row limit reached, result is incomplete", {
+        limit: OVERVIEW_ROW_LIMIT,
+      });
+    }
 
     const visibleRows = rows.filter((row) => !isHiddenSystemDraft(query.user, row));
     const { drafts, layoutSlugByDocument } = buildDrafts(
@@ -318,6 +327,7 @@ export const overviewQuery = defineQueryHandler({
       rows: filtered.slice(offset, offset + payload.limit),
       nextCursor: null,
       total: filtered.length,
+      truncated,
     } satisfies OverviewResponse;
   },
 });

package/packages/bundled-features/src/template-resolver/handlers/resource-upload.write.ts

@@ -1,4 +1,8 @@
-import { defineWriteHandler, type WriteResult } from "@cosmicdrift/kumiko-framework/engine";
+import {
+  type BeforeTransactionResult,
+  defineWriteHandler,
+  type WriteResult,
+} from "@cosmicdrift/kumiko-framework/engine";
 import {
   NotFoundError,
   UnprocessableError,
@@ -13,11 +17,14 @@ import {
 import { attachmentFileNameSchema } from "../../shared/index.js";
 import { TemplateResolverErrors } from "../qualified-names.js";
 import {
+  type PreparedTemplateFile,
+  prepareTemplateAttachmentBeforeTransaction,
+  prepareTemplateResourceBeforeTransaction,
   readTemplateResourceMaxBytes,
   type StoredTemplateAttachment,
   type StoredTemplateResource,
-  storeTemplateAttachment,
-  storeTemplateResource,
+  storePreparedTemplateAttachment,
+  storePreparedTemplateResource,
 } from "../store-template-resource.js";
 import { RESOURCE_PURPOSES, resourceKeySchema, resourceTargetTenantId } from "./resource-shared.js";
 
@@ -66,10 +73,7 @@ export const resourceUploadWrite = defineWriteHandler({
   access: { roles: ["TenantAdmin", "SystemAdmin"] },
   description:
     "Turns a file uploaded via POST /api/files (multipart, no entityType) into a template resource. With purpose image (default) the upload is checked against the resource-max-bytes cap, re-encoded to a supported image format and stored as a new file; with templateId and key it is linked into that template under the key, without them only the file is created. With purpose attachment, templateId, key and fileName are required: a PDF, PNG or JPEG is stored unchanged and linked into a mail template as a file attached to every mail sent from it, at most 10 per template. A cap above the files route's maxUploadSize has no effect.",
-  handler: async (
-    event,
-    ctx,
-  ): Promise<WriteResult<StoredTemplateResource | StoredTemplateAttachment>> => {
+  beforeTransaction: async (event, ctx): Promise<BeforeTransactionResult<PreparedTemplateFile>> => {
     const { templateId, key, sourceFileRefId, purpose, fileName } = event.payload;
     const attachmentTarget =
       purpose === "attachment" ? attachmentTargetOf({ templateId, key, fileName }) : null;
@@ -113,7 +117,7 @@ export const resourceUploadWrite = defineWriteHandler({
     // The source upload stays as an unclaimed file: bundled-features cannot reach the fileRef executor to delete it.
     const tenantId = resourceTargetTenantId(event.payload.tenantIdOverride, event.user.tenantId);
     if (attachmentTarget !== null) {
-      return storeTemplateAttachment({
+      return prepareTemplateAttachmentBeforeTransaction({
         ctx,
         user: event.user,
         tenantId,
@@ -122,7 +126,7 @@ export const resourceUploadWrite = defineWriteHandler({
         ...attachmentTarget,
       });
     }
-    return storeTemplateResource({
+    return prepareTemplateResourceBeforeTransaction({
       ctx,
       user: event.user,
       tenantId,
@@ -132,4 +136,39 @@ export const resourceUploadWrite = defineWriteHandler({
       ...(key !== undefined && { key }),
     });
   },
+  handler: async (
+    event,
+    ctx,
+  ): Promise<WriteResult<StoredTemplateResource | StoredTemplateAttachment>> => {
+    const { templateId, key } = event.payload;
+    const tenantId = resourceTargetTenantId(event.payload.tenantIdOverride, event.user.tenantId);
+    const { prepared } = event;
+    if (prepared.kind === "attachment") {
+      // The phase accepts attachments only with a complete target, so these are set.
+      if (templateId === undefined || key === undefined) {
+        return writeFailure(
+          new UnprocessableError(TemplateResolverErrors.attachmentInvalid, {
+            i18nKey: "templateResolver.errors.attachment.invalid",
+            details: { code: "target_required" },
+          }),
+        );
+      }
+      return storePreparedTemplateAttachment({
+        ctx,
+        user: event.user,
+        tenantId,
+        prepared,
+        templateId,
+        key,
+      });
+    }
+    return storePreparedTemplateResource({
+      ctx,
+      user: event.user,
+      tenantId,
+      prepared,
+      ...(templateId !== undefined && { templateId }),
+      ...(key !== undefined && { key }),
+    });
+  },
 });

package/packages/bundled-features/src/template-resolver/handlers/validate.query.ts

@@ -10,6 +10,7 @@ import type { ContentFormat, UpsertKind } from "../constants.js";
 import type { TemplateWriteScope } from "../layout-regions.js";
 import { imageResourceKeysOf } from "../linked-resources.js";
 import { type TemplateResourceRow, templateResourcesTable } from "../table.js";
+import { isSystemAdmin } from "../template-draft.js";
 import { resolveTemplateVariables, systemPlaceholdersFor } from "../template-validation.js";
 import { contentFormatSchema, kindSchema, localeSchema, templateSlugSchema } from "./shared.js";
 import { evaluateTemplateWrite } from "./template-gates.js";
@@ -53,7 +54,9 @@ export async function validateTemplateDraft(
   payload: TemplateDraftInput,
 ) {
   const variables = resolveTemplateVariables(ctx.registry, payload.slug, payload.variableSchema);
-  const { slug, kind, scope, locale } = payload;
+  const { slug, kind, locale } = payload;
+  // The dry run must not promise what the caller's write handlers would refuse.
+  const scope: TemplateWriteScope = isSystemAdmin(user) ? payload.scope : "tenant";
   const known = [
     ...(await knownResourceKeys(ctx.db, {
       tenantId: SYSTEM_TENANT_ID,

package/packages/bundled-features/src/template-resolver/index.ts

@@ -16,6 +16,7 @@ export {
   CONTENT_FORMATS,
   type ContentFormat,
   DEFAULT_MAIL_LAYOUT_SLUG,
+  DEFAULT_PDF_LAYOUT_SLUG,
   DOCUMENT_HTML_KINDS,
   type DocumentHtmlKind,
   FALLBACK_LOCALE,
@@ -110,9 +111,11 @@ export {
 } from "./qualified-names.js";
 export { mapRecordToVariables } from "./record-mapping.js";
 export {
+  type PreparedTemplateImage,
+  prepareTemplateResourceBeforeTransaction,
   readTemplateResourceMaxBytes,
   type StoredTemplateResource,
-  storeTemplateResource,
+  storePreparedTemplateResource,
 } from "./store-template-resource.js";
 export {
   type TemplateResourceRow,
@@ -124,9 +127,11 @@ export {
   isMailTemplateMeta,
   type LayoutTemplateMeta,
   MAIL_CATEGORIES,
+  MAIL_TONES,
   type MailCategory,
   type MailLayoutMeta,
   type MailTemplateMeta,
+  type MailTone,
   type PdfTemplateMeta,
   parseTemplateMeta,
   pdfAttachmentFileNamePatternSchema,

package/packages/bundled-features/src/template-resolver/layout-appearance.ts

@@ -15,26 +15,42 @@ const FONT_FAMILIES = {
   serif: "Georgia, 'Times New Roman', serif",
 } as const;
 
-const BUTTON_COLOR = "#1f5468";
+const DEFAULT_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}`,
-} as const;
+type ButtonStyle = NonNullable<MailLayoutMeta["buttonStyle"]>;
+
+function buttonStyleCss(style: ButtonStyle, color: string): string {
+  switch (style) {
+    case "filled-rounded":
+      return `${BUTTON_BASE};border-radius:6px;background-color:${color};color:#ffffff`;
+    case "filled-square":
+      return `${BUTTON_BASE};background-color:${color};color:#ffffff`;
+    case "outline":
+      return `${BUTTON_BASE};border:2px solid ${color};border-radius:6px;color:${color}`;
+  }
+}
 
 export function isHexColor(value: string): boolean {
   return HEX_COLOR_PATTERN.test(value);
 }
 
-export function mailLayoutAppearance(meta: MailLayoutMeta | unknown): MailLayoutAppearance {
+// The branding accent colors the buttons only where the layout opted into the branding accent line.
+export function mailLayoutAppearance(
+  meta: MailLayoutMeta | unknown,
+  brandingAccentColor?: string,
+): MailLayoutAppearance {
   const parsed = readMailLayoutMeta(meta);
+  const accentLine = (parsed.accentLine ?? "none") === "branding";
+  const buttonColor =
+    accentLine && brandingAccentColor !== undefined && isHexColor(brandingAccentColor)
+      ? brandingAccentColor
+      : DEFAULT_BUTTON_COLOR;
   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"],
+    accentLine,
+    buttonStyle: buttonStyleCss(parsed.buttonStyle ?? "filled-rounded", buttonColor),
   };
 }

package/packages/bundled-features/src/template-resolver/mail-constants.ts

@@ -0,0 +1,4 @@
+// @runtime client
+// No imports: web/ re-exports these, and template-meta.ts pulls in zod and the framework engine.
+export const MAIL_TONES = ["accent", "info", "success", "warning", "danger", "neutral"] as const;
+export type MailTone = (typeof MAIL_TONES)[number];

package/packages/bundled-features/src/template-resolver/resource-image.ts

@@ -1,27 +1,20 @@
-import { assertNotSvg, SHARP_INPUT_OPTIONS } from "../shared/index.js";
+import {
+  assertNotSvg,
+  isResourceImageFormat,
+  RESOURCE_IMAGE_FORMATS,
+  type ResourceImageContentType,
+  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",
-} as const;
-
-type ResourceImageFormat = keyof typeof CONTENT_TYPE_BY_FORMAT;
-
 export type NormalizedResourceImage = {
   readonly data: Uint8Array;
-  readonly contentType: (typeof CONTENT_TYPE_BY_FORMAT)[ResourceImageFormat];
+  readonly contentType: ResourceImageContentType;
   readonly width: number;
   readonly height: number;
 };
 
-function isResourceImageFormat(format: string | undefined): format is ResourceImageFormat {
-  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.
@@ -40,7 +33,7 @@ export async function normalizeResourceImage(data: Uint8Array): Promise<Normaliz
   const { data: output, info } = await pipeline.toBuffer({ resolveWithObject: true });
   return {
     data: new Uint8Array(output),
-    contentType: CONTENT_TYPE_BY_FORMAT[format],
+    contentType: RESOURCE_IMAGE_FORMATS[format].contentType,
     width: info.width,
     height: info.height,
   };

package/packages/bundled-features/src/template-resolver/seeding.ts

@@ -155,6 +155,8 @@ export async function seedSystemTemplate(
       current?.title === rowFields.title &&
       current?.variableSchema === rowFields.variableSchema &&
       current?.meta === rowFields.meta &&
+      current?.status === rowFields.status &&
+      current?.parentTemplateId === rowFields.parentTemplateId &&
       (linkedResources === undefined || current?.linkedResources === linkedResources)
     ) {
       return { id: String(row.id) };