@cosmicdrift/kumiko-bundled-features 0.363.0 → 0.364.0

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

@@ -1,27 +1,40 @@
+import { type HandlerContext } from "@cosmicdrift/kumiko-framework/engine";
 import * as z from "zod";
+import type { TemplateResourceRow } from "../table.js";
 type TemplateStatus = "active" | "archived";
+export type StatusTarget = "own" | "system";
+export declare function writeAccessFor(target: StatusTarget): {
+    roles: string[];
+};
+export declare function loadTargetRow(ctx: HandlerContext, target: StatusTarget, user: {
+    readonly tenantId: string;
+}, id: string): Promise<{
+    db: import("@cosmicdrift/kumiko-types/tenant-db-types").TenantDb;
+    scoped: import("@cosmicdrift/kumiko-types/handlers").TenantWriteTarget | null;
+    row: TemplateResourceRow | null;
+}>;
 export declare const archiveWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<string, z.ZodObject<{
     id: z.ZodString;
 }, z.core.$strip>, {
     id: string;
     status: TemplateStatus;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
 export declare const publishWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<string, z.ZodObject<{
     id: z.ZodString;
 }, z.core.$strip>, {
     id: string;
     status: TemplateStatus;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
 export declare const archiveSystemWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<string, z.ZodObject<{
     id: z.ZodString;
 }, z.core.$strip>, {
     id: string;
     status: TemplateStatus;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
 export declare const publishSystemWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<string, z.ZodObject<{
     id: z.ZodString;
 }, z.core.$strip>, {
     id: string;
     status: TemplateStatus;
-}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
 export {};

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

@@ -4,6 +4,7 @@ import { NotFoundError, ValidationError, writeFailure, } from "@cosmicdrift/kumi
 import * as z from "zod";
 import { requireForTenant } from "../../shared/index.js";
 import { templateResourcesTable } from "../table.js";
+import { activationChanges, parseTemplateDraft, toWorkingRow } from "../template-draft.js";
 import { executor } from "./shared.js";
 import { publishGateIssues } from "./template-gates.js";
 function isRowOfTarget(row, target, callerTenantId) {
@@ -11,36 +12,51 @@ function isRowOfTarget(row, target, callerTenantId) {
         ? row.tenantId === SYSTEM_TENANT_ID && row.scope === "system"
         : row.tenantId === callerTenantId && row.scope === "tenant";
 }
-function createStatusUpdateHandler(name, target, status, description, gate) {
+export function writeAccessFor(target) {
+    return { roles: target === "system" ? ["SystemAdmin"] : ["TenantAdmin", "SystemAdmin"] };
+}
+// The tenant db also reads system rows; the row's own tenant must match the
+// target or the executor would append to a foreign event stream.
+export async function loadTargetRow(ctx, target, user, id) {
+    const scoped = target === "system" ? requireForTenant(ctx, SYSTEM_TENANT_ID) : null;
+    const db = scoped?.db ?? ctx.db;
+    const row = await fetchOne(db, templateResourcesTable, { id });
+    return { db, scoped, row: row && isRowOfTarget(row, target, user.tenantId) ? row : null };
+}
+// Publishing promotes an open draft (gated as the version that goes live); a row
+// without one is activated as stored. Archiving leaves the draft standing.
+function planStatusChange(ctx, row, status) {
+    if (status === "archived")
+        return { ok: true, changes: { status } };
+    const issues = publishGateIssues(ctx.registry, toWorkingRow(row, row.tenantId));
+    if (issues.length > 0) {
+        return { ok: false, failure: writeFailure(new ValidationError({ fields: [...issues] })) };
+    }
+    return { ok: true, changes: { ...parseTemplateDraft(row.draft), ...activationChanges(row) } };
+}
+function createStatusUpdateHandler(name, target, status, description) {
     return defineWriteHandler({
         name,
         schema: z.object({ id: z.string().min(1) }),
-        access: { roles: target === "system" ? ["SystemAdmin"] : ["TenantAdmin", "SystemAdmin"] },
+        access: writeAccessFor(target),
         // A system template change reaches every tenant without an override.
         ...(target === "system" ? { agent: { risk: "high" } } : {}),
         description,
         handler: async (event, ctx) => {
-            const scoped = target === "system" ? requireForTenant(ctx, SYSTEM_TENANT_ID) : null;
-            const db = scoped?.db ?? ctx.db;
-            // The tenant db also reads system rows; the row's own tenant must match
-            // the target or the executor would append to a foreign event stream.
-            const existing = await fetchOne(db, templateResourcesTable, {
-                id: event.payload.id,
-            });
-            if (!existing || !isRowOfTarget(existing, target, event.user.tenantId)) {
+            const { db, scoped, row } = await loadTargetRow(ctx, target, event.user, event.payload.id);
+            if (!row)
                 return writeFailure(new NotFoundError("template-resource", event.payload.id));
-            }
-            const issues = gate?.(ctx.registry, existing) ?? [];
-            if (issues.length > 0)
-                return writeFailure(new ValidationError({ fields: [...issues] }));
-            const result = await executor.update({ id: existing.id, version: existing.version, changes: { status } }, event.user, db, scoped ? { streamTenantId: scoped.streamTenantId } : undefined);
+            const plan = planStatusChange(ctx, row, status);
+            if (!plan.ok)
+                return plan.failure;
+            const result = await executor.update({ id: row.id, version: row.version, changes: plan.changes }, event.user, db, scoped ? { streamTenantId: scoped.streamTenantId } : undefined);
             if (!result.isSuccess)
                 return result;
-            return { isSuccess: true, data: { id: String(existing.id), status } };
+            return { isSuccess: true, data: { id: String(row.id), status } };
         },
     });
 }
-export const archiveWrite = createStatusUpdateHandler("archive", "own", "archived", "Sets one template resource of the caller's tenant to archived so the resolver stops serving it while the row and its content survive; use it to retire a template reversibly instead of deleting it.");
-export const publishWrite = createStatusUpdateHandler("publish", "own", "active", "Sets one template resource of the caller's tenant to active so the resolver starts serving it; use it to release a draft written by upsert-tenant, or to bring an archived template back; a mail template with unknown placeholders or unused required variables is refused.", publishGateIssues);
+export const archiveWrite = createStatusUpdateHandler("archive", "own", "archived", "Sets one template resource of the caller's tenant to archived so the resolver stops serving it while the row and its content survive; use it to retire a template reversibly instead of deleting it. An open draft stays.");
+export const publishWrite = createStatusUpdateHandler("publish", "own", "active", "Sets one template resource of the caller's tenant to active so the resolver starts serving it; use it to release a draft written by upsert-tenant (a draft saved beside an active version replaces it), or to bring an archived template back; a version with unknown placeholders or unused required variables is refused and the served version stays.");
 export const archiveSystemWrite = createStatusUpdateHandler("archive-system", "system", "archived", "Sets one system-default template to archived so the resolver stops serving it to every tenant that has no override; SystemAdmin only, reversible with publish-system.");
-export const publishSystemWrite = createStatusUpdateHandler("publish-system", "system", "active", "Sets one system-default template to active so the resolver serves it again to every tenant that has no override; SystemAdmin only, a mail template with unknown placeholders or unused required variables is refused.", publishGateIssues);
+export const publishSystemWrite = createStatusUpdateHandler("publish-system", "system", "active", "Sets one system-default template to active so the resolver serves it again to every tenant that has no override; an open draft beside the active version replaces it; SystemAdmin only, a version with unknown placeholders or unused required variables is refused.");

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

@@ -21,4 +21,4 @@ export declare const upsertSystemWrite: import("@cosmicdrift/kumiko-types/define
     parentTemplateId: import("zod").ZodOptional<import("zod").ZodString>;
     title: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
     folder: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-}, import("zod/v4/core").$strip>, import("./template-write.js").WrittenTemplateRow, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;
+}, import("zod/v4/core").$strip>, import("./template-write.js").WrittenTemplateRow, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;

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

@@ -27,4 +27,4 @@ export declare const upsertTenantWrite: import("@cosmicdrift/kumiko-types/define
         active: "active";
         draft: "draft";
     }>>;
-}, z.core.$strip>, import("./template-write.js").WrittenTemplateRow, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;
+}, z.core.$strip>, import("./template-write.js").WrittenTemplateRow, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;

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

@@ -15,7 +15,7 @@ export const upsertTenantWrite = defineWriteHandler({
         status: z.enum(["draft", "active"]).default("draft"),
     }),
     access: { roles: ["TenantAdmin", "SystemAdmin"] },
-    description: "Creates or overwrites a tenant-scoped template override with its variable schema, landing as a draft that only publish makes live; it refuses a system-tenant target, which is what upsert-system is for.",
+    description: "Creates or overwrites a tenant-scoped template override with its variable schema, landing as a draft that only publish makes live (over an active override the draft is stored beside it, the active version keeps being served until publish); it refuses a system-tenant target, which is what upsert-system is for.",
     handler: async (event, ctx) => {
         // @cast-boundary engine-payload — override aus Zod-parsed string,
         // event.user.tenantId schon TenantId-branded; union als TenantId casten

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

@@ -1,15 +1,24 @@
+import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
 import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
 import * as z from "zod";
 import { TEMPLATE_KINDS } from "../constants.js";
+import { templateResourcesTable } from "../table.js";
 import { templateSlugSchema } from "../template-meta.js";
 import { collectTemplateUsage } from "../template-usage.js";
+import { effectiveMailLayoutSlugs } from "./overview.query.js";
+const MAIL_ROW_LIMIT = 5000;
 export const usageQuery = defineQueryHandler({
     name: "usage",
     schema: z.object({ slug: templateSlugSchema, kind: z.enum(TEMPLATE_KINDS) }),
     access: { roles: ["TenantAdmin", "SystemAdmin"] },
-    description: "Lists the code-registered notifications that use one template: a mail template is used by the notification whose qualified name is its slug, a mail layout by every mail notification that names it in its meta or falls back to the default layout; use it to show what a change to a template affects.",
+    description: "Lists the code-registered notifications that use one template: a mail template is used by the notification whose qualified name is its slug and that has a code template, a mail layout by every mail notification whose effective template (own override, else system) names it, or whose code meta does when no stored template exists, or that falls back to the default layout; use it to show what a change to a template affects.",
     handler: async (query, ctx) => {
         const { slug, kind } = query.payload;
-        return { usedBy: collectTemplateUsage(ctx.registry, slug, kind) };
+        if (kind !== "mail-layout")
+            return { usedBy: collectTemplateUsage(ctx.registry, slug, kind) };
+        const mailRows = await selectMany(ctx.db, templateResourcesTable, { kind: "mail" }, { limit: MAIL_ROW_LIMIT });
+        return {
+            usedBy: collectTemplateUsage(ctx.registry, slug, kind, effectiveMailLayoutSlugs(mailRows)),
+        };
     },
 });

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

@@ -1,12 +1,13 @@
 export { createTemplateResolverApi, type ResolveRequest, requireTemplateResolver, TemplateNotFoundError, type TemplateResolverApi, type TemplateResource, } from "./api.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 { 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, DocumentRepeatRow, DocumentResource, DocumentTable, DocumentTableCell, DocumentTableHeader, DocumentTableRow, DocumentTextAlign, type DocumentTextAlignment, DocumentVariable, documentExtensions, isAllowedDocumentLinkHref, isDocumentPlaceholderHref, isDocumentReferenceName, isDocumentResourceKey, } from "./document-schema.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";
@@ -15,7 +16,7 @@ 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 { 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";

package/dist/template-resolver/index.js

@@ -1,10 +1,11 @@
 export { createTemplateResolverApi, requireTemplateResolver, TemplateNotFoundError, } from "./api.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 { 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, DocumentRepeatRow, DocumentResource, DocumentTable, DocumentTableCell, DocumentTableHeader, DocumentTableRow, DocumentTextAlign, DocumentVariable, documentExtensions, isAllowedDocumentLinkHref, isDocumentPlaceholderHref, isDocumentReferenceName, isDocumentResourceKey, } from "./document-schema.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";
@@ -13,7 +14,7 @@ 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 { 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";

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/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/qualified-names.d.ts

@@ -6,6 +6,8 @@ export declare const TemplateResolverHandlers: {
     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";
@@ -37,10 +39,12 @@ 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";

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

@@ -8,6 +8,8 @@ export const TemplateResolverHandlers = {
     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",
@@ -48,10 +50,12 @@ 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",

package/dist/template-resolver/seeding.js

@@ -18,6 +18,7 @@ import { executor } from "./handlers/shared.js";
 import { evaluateTemplateWrite } from "./handlers/template-gates.js";
 import { TEMPLATE_RESOLVER_FEATURE } from "./qualified-names.js";
 import { templateResourcesTable } from "./table.js";
+import { activeStampChanges, servedStampChanges } from "./template-draft.js";
 import { templateSlugSchema } from "./template-meta.js";
 import { variablesFromSchema } from "./template-validation.js";
 /** Drop projection orphans (no events anywhere) so boot seeds can recreate. */
@@ -97,7 +98,11 @@ export async function seedSystemTemplate(db, opts) {
             (linkedResources === undefined || current?.linkedResources === linkedResources)) {
             return { id: String(row.id) };
         }
-        const result = await executor.update({ id: row.id, version: row.version, changes: rowFields }, by, tdb);
+        const result = await executor.update({
+            id: row.id,
+            version: row.version,
+            changes: { ...rowFields, ...activeStampChanges(row) },
+        }, by, tdb);
         if (!result.isSuccess) {
             throw new Error(`seedSystemTemplate update failed: ${JSON.stringify(result)}`);
         }
@@ -107,7 +112,13 @@ export async function seedSystemTemplate(db, opts) {
         existing,
         ifExists: opts.ifExists,
         create: async () => {
-            const result = await executor.create({ ...rowFields, linkedResources: linkedResources ?? "{}", tenantId }, by, tdb);
+            const result = await executor.create({
+                ...rowFields,
+                ...activeStampChanges(null),
+                draft: null,
+                linkedResources: linkedResources ?? "{}",
+                tenantId,
+            }, by, tdb);
             if (!result.isSuccess) {
                 // Parallel boot pods can both delete the orphan and race on create —
                 // unique on (tenantId, slug, kind, locale) → resolve winner and update.
@@ -235,7 +246,13 @@ export async function seedTextBlock(db, opts) {
         const result = await executor.update({
             id: row.id,
             version: row.version,
-            changes: { title: fields.title, content: fields.content, folder: fields.folder },
+            changes: {
+                title: fields.title,
+                content: fields.content,
+                folder: fields.folder,
+                // A re-seed must not revive an archived block; only a served one gets a new served version.
+                ...(current?.status === "active" && servedStampChanges(row)),
+            },
         }, by, tdb);
         if (!result.isSuccess) {
             throw new Error(`seedTextBlock update failed: ${JSON.stringify(result)}`);
@@ -246,7 +263,7 @@ export async function seedTextBlock(db, opts) {
         existing,
         ifExists: opts.ifExists,
         create: async () => {
-            const result = await executor.create({ ...fields, tenantId: opts.tenantId }, by, tdb);
+            const result = await executor.create({ ...fields, ...activeStampChanges(null), draft: null, tenantId: opts.tenantId }, by, tdb);
             if (!result.isSuccess) {
                 if (result.error?.code === "unique_violation") {
                     const again = await fetchOne(db, templateResourcesTable, {

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

@@ -55,7 +55,7 @@ export async function storeTemplateResource(args) {
     }
     const created = await createFileRefFromBytes({
         db,
-        files: fileContextForTenant(ctx, tenantId),
+        files: fileContextForTenant(ctx, ctx.user.tenantId, tenantId),
         registry: ctx.registry,
         user: { ...user, tenantId },
     }, {
@@ -145,7 +145,7 @@ async function createAttachmentFileRef(args) {
     const { db } = requireForTenant(ctx, tenantId);
     const created = await createFileRefFromBytes({
         db,
-        files: fileContextForTenant(ctx, tenantId),
+        files: fileContextForTenant(ctx, ctx.user.tenantId, tenantId),
         registry: ctx.registry,
         user: { ...user, tenantId },
     }, {

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

@@ -277,6 +277,56 @@ export declare const templateResourceEntity: import("@cosmicdrift/kumiko-types/f
     } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
         required: true;
     };
+    draft: {
+        readonly type: "longText";
+        readonly description?: string;
+        readonly maxLength?: number;
+        readonly required?: boolean;
+        readonly encrypted?: boolean;
+        readonly sensitive?: boolean;
+        readonly readAsInstruction?: boolean;
+        readonly default?: string;
+        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
+        readonly multiline?: boolean | {
+            readonly rows?: number;
+        };
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+        required: false;
+    };
+    activeVersion: {
+        readonly type: "number";
+        readonly description?: string;
+        readonly required?: boolean;
+        readonly sortable?: boolean;
+        readonly filterable?: boolean;
+        readonly sensitive?: boolean;
+        readonly default?: number;
+        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
+        readonly min?: number;
+        readonly max?: number;
+        readonly integer?: boolean;
+        readonly unit?: string | {
+            readonly field: string;
+        };
+        readonly grouping?: boolean;
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+        required: false;
+    };
+    activeSince: {
+        readonly type: "timestamp";
+        readonly description?: string;
+        readonly required?: boolean;
+        readonly sortable?: boolean;
+        readonly filterable?: boolean;
+        readonly sensitive?: boolean;
+        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
+        readonly locatedBy?: string;
+        readonly min?: string;
+        readonly max?: string;
+        readonly locale?: string;
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+        required: false;
+    };
 }, "tenant">;
 export declare const templateResourcesTable: import("@cosmicdrift/kumiko-framework/db").EntityTable<import("@cosmicdrift/kumiko-types/fields").EntityDefinition<{
     slug: {
@@ -556,6 +606,56 @@ export declare const templateResourcesTable: import("@cosmicdrift/kumiko-framewo
     } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
         required: true;
     };
+    draft: {
+        readonly type: "longText";
+        readonly description?: string;
+        readonly maxLength?: number;
+        readonly required?: boolean;
+        readonly encrypted?: boolean;
+        readonly sensitive?: boolean;
+        readonly readAsInstruction?: boolean;
+        readonly default?: string;
+        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
+        readonly multiline?: boolean | {
+            readonly rows?: number;
+        };
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+        required: false;
+    };
+    activeVersion: {
+        readonly type: "number";
+        readonly description?: string;
+        readonly required?: boolean;
+        readonly sortable?: boolean;
+        readonly filterable?: boolean;
+        readonly sensitive?: boolean;
+        readonly default?: number;
+        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
+        readonly min?: number;
+        readonly max?: number;
+        readonly integer?: boolean;
+        readonly unit?: string | {
+            readonly field: string;
+        };
+        readonly grouping?: boolean;
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+        required: false;
+    };
+    activeSince: {
+        readonly type: "timestamp";
+        readonly description?: string;
+        readonly required?: boolean;
+        readonly sortable?: boolean;
+        readonly filterable?: boolean;
+        readonly sensitive?: boolean;
+        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
+        readonly locatedBy?: string;
+        readonly min?: string;
+        readonly max?: string;
+        readonly locale?: string;
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+        required: false;
+    };
 }, "tenant">>;
 export type EntityAuditColumns = {
     readonly insertedAt: Temporal.Instant;
@@ -580,4 +680,7 @@ export type TemplateResourceRow = {
     readonly scope: string;
     readonly parentTemplateId: string | null;
     readonly status: string;
+    readonly draft: string | null;
+    readonly activeVersion: number | null;
+    readonly activeSince: Temporal.Instant | null;
 } & EntityAuditColumns;

package/dist/template-resolver/table.js

@@ -1,5 +1,5 @@
 import { buildEntityTable } from "@cosmicdrift/kumiko-framework/db";
-import { createEntity, createLongTextField, createSelectField, createTextField, } from "@cosmicdrift/kumiko-framework/engine";
+import { createEntity, createLongTextField, createNumberField, createSelectField, createTextField, createTimestampField, } from "@cosmicdrift/kumiko-framework/engine";
 import { CONTENT_FORMATS, TEMPLATE_KINDS, TEMPLATE_SCOPES, TEMPLATE_STATUSES, } from "./constants.js";
 // Stored v1 events name the kind "mail-html", which is now "mail".
 const renameMailHtmlKind = {
@@ -10,7 +10,9 @@ const renameMailHtmlKind = {
 // TemplateResource — strukturierte Template-Definition mit Tenant-
 // Override-Hierarchie, Locale-Fallback und Resource-Linking via
 // file-foundation. Pro (tenantId, slug, kind, locale) genau eine Row;
-// scope/status/version differenzieren Lifecycle.
+// scope/status/version differenzieren Lifecycle. Der Entwurf neben einer
+// aktiven Fassung liegt in `draft`; die Hauptfelder bleiben die ausgelieferte
+// Fassung.
 //
 // `variableSchema` + `linkedResources` sind JSON-Strings in longText
 // (Pattern aus compliance-profiles — kein dedizierter jsonbField im
@@ -44,6 +46,11 @@ export const templateResourceEntity = createEntity({
         scope: createSelectField({ required: true, options: [...TEMPLATE_SCOPES] }),
         parentTemplateId: createTextField({ personal: false, reason: "technical_reference" }),
         status: createSelectField({ required: true, options: [...TEMPLATE_STATUSES] }),
+        // JSON of the unpublished edit beside the active version (see template-draft.ts).
+        draft: createLongTextField({ personal: false, reason: "is_business_data" }),
+        // `version` counts every save including drafts; these two describe the served version.
+        activeVersion: createNumberField({ integer: true, min: 1 }),
+        activeSince: createTimestampField({}),
     },
     indexes: [
         {

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

@@ -0,0 +1,51 @@
+import { Temporal } from "@cosmicdrift/kumiko-types/temporal";
+import { type ContentFormat } from "./constants.js";
+import type { TemplateResourceRow } from "./table.js";
+export type TemplateDraft = {
+    readonly content: string | null;
+    readonly contentFormat: ContentFormat;
+    readonly variableSchema: string;
+    readonly meta: string | null;
+    readonly title: string | null;
+    readonly folder: string | null;
+    readonly parentTemplateId: string | null;
+};
+export declare function parseTemplateDraft(raw: string | null): TemplateDraft | null;
+export declare function serializeTemplateDraft(draft: TemplateDraft): string;
+export declare function activeVersionOf(row: TemplateResourceRow): number;
+export declare function servedVersionOf(row: TemplateResourceRow): number;
+export declare function activeSinceOf(row: TemplateResourceRow): Temporal.Instant;
+export type ActiveInfo = {
+    readonly version: number;
+    readonly since: Temporal.Instant;
+};
+export type WorkingRow = TemplateResourceRow & {
+    readonly active: ActiveInfo | null;
+};
+export declare function isHiddenSystemDraft(user: {
+    readonly roles: readonly string[];
+}, row: Pick<TemplateResourceRow, "scope" | "status">): boolean;
+export declare function draftViewerTenantId(user: {
+    readonly tenantId: string;
+    readonly roles: readonly string[];
+}, row: TemplateResourceRow): string;
+export declare function toWorkingRow(row: TemplateResourceRow, viewerTenantId: string): WorkingRow;
+export declare function servedStampChanges(row: {
+    readonly version: number;
+} | null): {
+    activeVersion: number;
+    activeSince: globalThis.Temporal.Instant;
+};
+export declare function activeStampChanges(row: {
+    readonly version: number;
+} | null): {
+    activeVersion: number;
+    activeSince: globalThis.Temporal.Instant;
+    status: string;
+};
+export declare function activationChanges(row: TemplateResourceRow | null): {
+    activeVersion: number;
+    activeSince: globalThis.Temporal.Instant;
+    status: string;
+    draft: null;
+};