@cosmicdrift/kumiko-bundled-features 0.362.0 → 0.364.0

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

@@ -26,26 +26,29 @@ export declare const templateResourceEntity: import("@cosmicdrift/kumiko-types/f
     kind: {
         readonly type: "select";
         readonly description?: string;
-        readonly options: readonly ["notification", "mail-html", "document-pdf", "image-snapshot", "text-block", "ai-prompt"];
+        readonly options: readonly ["mail", "document-pdf", "image-snapshot", "notification", "text-block", "snippet", "ai-prompt", "mail-layout", "pdf-layout"];
         readonly required?: boolean;
         readonly sortable?: boolean;
         readonly filterable?: boolean;
         readonly sensitive?: boolean;
-        readonly default?: "ai-prompt" | "document-pdf" | "image-snapshot" | "mail-html" | "notification" | "text-block" | undefined;
+        readonly default?: "ai-prompt" | "document-pdf" | "image-snapshot" | "mail" | "mail-layout" | "notification" | "pdf-layout" | "snippet" | "text-block" | undefined;
         readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
         readonly display?: "radio" | "dropdown";
         readonly optionTones?: {
             readonly "ai-prompt"?: "bad" | "neutral" | "ok" | "warn" | undefined;
             readonly "document-pdf"?: "bad" | "neutral" | "ok" | "warn" | undefined;
             readonly "image-snapshot"?: "bad" | "neutral" | "ok" | "warn" | undefined;
-            readonly "mail-html"?: "bad" | "neutral" | "ok" | "warn" | undefined;
+            readonly mail?: "bad" | "neutral" | "ok" | "warn" | undefined;
+            readonly "mail-layout"?: "bad" | "neutral" | "ok" | "warn" | undefined;
             readonly notification?: "bad" | "neutral" | "ok" | "warn" | undefined;
+            readonly "pdf-layout"?: "bad" | "neutral" | "ok" | "warn" | undefined;
+            readonly snippet?: "bad" | "neutral" | "ok" | "warn" | undefined;
             readonly "text-block"?: "bad" | "neutral" | "ok" | "warn" | undefined;
         } | undefined;
         readonly optionsQuery?: string;
         readonly optionsQueryPayload?: import("@cosmicdrift/kumiko-types/fields").OptionsQueryPayload;
         readonly optionsAvailabilityQuery?: string;
-        readonly conditionalOptions?: readonly import("@cosmicdrift/kumiko-types/fields").SelectConditionalOptions<"ai-prompt" | "document-pdf" | "image-snapshot" | "mail-html" | "notification" | "text-block">[] | undefined;
+        readonly conditionalOptions?: readonly import("@cosmicdrift/kumiko-types/fields").SelectConditionalOptions<"ai-prompt" | "document-pdf" | "image-snapshot" | "mail" | "mail-layout" | "notification" | "pdf-layout" | "snippet" | "text-block">[] | undefined;
     } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
         required: true;
     };
@@ -190,6 +193,22 @@ export declare const templateResourceEntity: import("@cosmicdrift/kumiko-types/f
     } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
         required: false;
     };
+    meta: {
+        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;
+    };
     scope: {
         readonly type: "select";
         readonly description?: string;
@@ -258,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: {
@@ -286,26 +355,29 @@ export declare const templateResourcesTable: import("@cosmicdrift/kumiko-framewo
     kind: {
         readonly type: "select";
         readonly description?: string;
-        readonly options: readonly ["notification", "mail-html", "document-pdf", "image-snapshot", "text-block", "ai-prompt"];
+        readonly options: readonly ["mail", "document-pdf", "image-snapshot", "notification", "text-block", "snippet", "ai-prompt", "mail-layout", "pdf-layout"];
         readonly required?: boolean;
         readonly sortable?: boolean;
         readonly filterable?: boolean;
         readonly sensitive?: boolean;
-        readonly default?: "ai-prompt" | "document-pdf" | "image-snapshot" | "mail-html" | "notification" | "text-block" | undefined;
+        readonly default?: "ai-prompt" | "document-pdf" | "image-snapshot" | "mail" | "mail-layout" | "notification" | "pdf-layout" | "snippet" | "text-block" | undefined;
         readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
         readonly display?: "radio" | "dropdown";
         readonly optionTones?: {
             readonly "ai-prompt"?: "bad" | "neutral" | "ok" | "warn" | undefined;
             readonly "document-pdf"?: "bad" | "neutral" | "ok" | "warn" | undefined;
             readonly "image-snapshot"?: "bad" | "neutral" | "ok" | "warn" | undefined;
-            readonly "mail-html"?: "bad" | "neutral" | "ok" | "warn" | undefined;
+            readonly mail?: "bad" | "neutral" | "ok" | "warn" | undefined;
+            readonly "mail-layout"?: "bad" | "neutral" | "ok" | "warn" | undefined;
             readonly notification?: "bad" | "neutral" | "ok" | "warn" | undefined;
+            readonly "pdf-layout"?: "bad" | "neutral" | "ok" | "warn" | undefined;
+            readonly snippet?: "bad" | "neutral" | "ok" | "warn" | undefined;
             readonly "text-block"?: "bad" | "neutral" | "ok" | "warn" | undefined;
         } | undefined;
         readonly optionsQuery?: string;
         readonly optionsQueryPayload?: import("@cosmicdrift/kumiko-types/fields").OptionsQueryPayload;
         readonly optionsAvailabilityQuery?: string;
-        readonly conditionalOptions?: readonly import("@cosmicdrift/kumiko-types/fields").SelectConditionalOptions<"ai-prompt" | "document-pdf" | "image-snapshot" | "mail-html" | "notification" | "text-block">[] | undefined;
+        readonly conditionalOptions?: readonly import("@cosmicdrift/kumiko-types/fields").SelectConditionalOptions<"ai-prompt" | "document-pdf" | "image-snapshot" | "mail" | "mail-layout" | "notification" | "pdf-layout" | "snippet" | "text-block">[] | undefined;
     } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
         required: true;
     };
@@ -450,6 +522,22 @@ export declare const templateResourcesTable: import("@cosmicdrift/kumiko-framewo
     } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
         required: false;
     };
+    meta: {
+        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;
+    };
     scope: {
         readonly type: "select";
         readonly description?: string;
@@ -518,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;
@@ -538,7 +676,11 @@ export type TemplateResourceRow = {
     readonly contentFormat: string;
     readonly variableSchema: string | null;
     readonly linkedResources: string | null;
+    readonly meta: string | null;
     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,10 +1,18 @@
 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 = {
+    fromVersion: 1,
+    toVersion: 2,
+    transform: (fields) => (fields["kind"] === "mail-html" ? { ...fields, kind: "mail" } : fields),
+};
 // 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
@@ -32,9 +40,17 @@ export const templateResourceEntity = createEntity({
         contentFormat: createSelectField({ required: true, options: [...CONTENT_FORMATS] }),
         variableSchema: createLongTextField({ personal: false, reason: "technical_reference" }),
         linkedResources: createLongTextField({ personal: false, reason: "technical_reference" }),
+        // Per-kind JSON (mail: subject, preview text, layout slug, ...), validated
+        // against template-meta.ts on write. Authored by TenantAdmin/Operator.
+        meta: createLongTextField({ personal: false, reason: "is_business_data" }),
         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: [
         {
@@ -43,5 +59,7 @@ export const templateResourceEntity = createEntity({
             name: "read_template_resources_unique",
         },
     ],
+    eventVersion: 2,
+    eventMigrations: [renameMailHtmlKind],
 });
 export const templateResourcesTable = buildEntityTable("template-resource", templateResourceEntity);

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

@@ -0,0 +1,36 @@
+import * as z from "zod";
+export declare const templateBundleSchema: z.ZodObject<{
+    slug: z.ZodString;
+    kind: z.ZodEnum<{
+        "ai-prompt": "ai-prompt";
+        "document-pdf": "document-pdf";
+        "image-snapshot": "image-snapshot";
+        mail: "mail";
+        "mail-layout": "mail-layout";
+        "pdf-layout": "pdf-layout";
+    }>;
+    contentFormat: z.ZodEnum<{
+        html: "html";
+        markdown: "markdown";
+        mjml: "mjml";
+        plain: "plain";
+    }>;
+    variableSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    locales: z.ZodRecord<z.ZodString, z.ZodObject<{
+        body: z.ZodString;
+        meta: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    resources: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        fileName: z.ZodString;
+        contentType: z.ZodString;
+        base64: z.ZodString;
+        purpose: z.ZodOptional<z.ZodEnum<{
+            attachment: "attachment";
+        }>>;
+    }, z.core.$strict>>>;
+    pdfAttachments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        templateSlug: z.ZodString;
+        fileName: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type TemplateBundle = z.infer<typeof templateBundleSchema>;

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

@@ -0,0 +1,60 @@
+import * as z from "zod";
+import { CONTENT_FORMATS, UPSERT_KINDS } from "./constants.js";
+import { isDocumentResourceKey } from "./document-schema.js";
+import { templatePdfAttachmentLinkSchema } from "./linked-resources.js";
+import { templateSlugSchema } from "./template-meta.js";
+const MAX_RESOURCES = 20;
+const MAX_RESOURCE_BYTES = 2 * 1024 * 1024;
+const MAX_BASE64_LENGTH = Math.ceil(MAX_RESOURCE_BYTES / 3) * 4;
+const STRICT_BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+const CONTENT_TYPE = /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/i;
+const UNSAFE_FILE_NAME_CHARACTERS = /[/\\";]|\p{Cc}/u;
+const bundleLocaleSchema = z
+    .string()
+    .min(2)
+    .max(8)
+    .regex(/^[a-z]{2}(-[a-z]{2})?$/i, "locale must be ISO 639-1 (e.g. de, en, en-us)");
+const bundleFileNameSchema = z
+    .string()
+    .min(1)
+    .max(200)
+    .refine((name) => !UNSAFE_FILE_NAME_CHARACTERS.test(name) && !name.includes(".."), {
+    message: 'file name must not contain / \\ " ; control characters or ".."',
+});
+const bundleResourceSchema = z
+    .object({
+    fileName: bundleFileNameSchema,
+    contentType: z.string().max(100).regex(CONTENT_TYPE, "content type must be type/subtype"),
+    base64: z.string().max(MAX_BASE64_LENGTH).regex(STRICT_BASE64, "base64 is not valid"),
+    // Absent means an image the body embeds; "attachment" is a file attached to the mail.
+    purpose: z.enum(["attachment"]).optional(),
+})
+    .strict();
+const pdfAttachmentLinkBodySchema = templatePdfAttachmentLinkSchema.omit({ kind: true });
+const bundleLocaleEntrySchema = z
+    .object({ body: z.string().max(200_000), meta: z.unknown().optional() })
+    .strict();
+export const templateBundleSchema = z
+    .object({
+    slug: templateSlugSchema,
+    kind: z.enum(UPSERT_KINDS),
+    contentFormat: z.enum(CONTENT_FORMATS),
+    variableSchema: z.record(z.string(), z.unknown()).optional(),
+    locales: z
+        .record(bundleLocaleSchema, bundleLocaleEntrySchema)
+        .refine((locales) => Object.keys(locales).length >= 1, {
+        message: "a bundle needs at least one locale",
+    }),
+    resources: z
+        .record(z.string().refine(isDocumentResourceKey, { message: "not a valid resource key" }), bundleResourceSchema)
+        .refine((resources) => Object.keys(resources).length <= MAX_RESOURCES, {
+        message: `a bundle holds at most ${MAX_RESOURCES} resources`,
+    })
+        .default({}),
+    // PDFs rendered from document templates at send time; nothing to store, so no bytes.
+    pdfAttachments: z
+        .record(z.string().refine(isDocumentResourceKey, { message: "not a valid resource key" }), pdfAttachmentLinkBodySchema)
+        .default({}),
+})
+    .strict()
+    .refine((bundle) => Object.keys(bundle.pdfAttachments).every((key) => !(key in bundle.resources)), { message: "a key is used by a resource and a PDF attachment", path: ["pdfAttachments"] });

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

@@ -0,0 +1,7 @@
+export type TemplateDiffChange = "same" | "added" | "removed";
+export type TemplateDiffBlock = {
+    readonly change: TemplateDiffChange;
+    readonly content: string;
+};
+export declare function splitTemplateBlocks(content: string, contentFormat: string): string[];
+export declare function diffTemplateBlocks(system: readonly string[], tenant: readonly string[]): TemplateDiffBlock[];

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

@@ -0,0 +1,68 @@
+import { withParsedDocument } from "./document-sanitizer.js";
+// Beyond this the quadratic LCS table is not worth it for a preview.
+const MAX_LCS_CELLS = 1_000_000;
+function splitHtmlBlocks(content) {
+    return withParsedDocument(content, (body) => {
+        const blocks = [];
+        for (const node of Array.from(body.childNodes)) {
+            const markup = "outerHTML" in node && typeof node.outerHTML === "string" ? node.outerHTML : "";
+            const text = markup === "" ? (node.textContent ?? "").trim() : markup;
+            if (text !== "")
+                blocks.push(text);
+        }
+        return blocks;
+    });
+}
+export function splitTemplateBlocks(content, contentFormat) {
+    if (contentFormat === "html")
+        return splitHtmlBlocks(content);
+    return content
+        .split(/\r?\n[ \t]*\r?\n/)
+        .map((block) => block.trim())
+        .filter((block) => block !== "");
+}
+// "removed" = only in the system template, "added" = only in the tenant version.
+export function diffTemplateBlocks(system, tenant) {
+    if (system.length * tenant.length > MAX_LCS_CELLS) {
+        return [
+            ...system.map((content) => ({ change: "removed", content })),
+            ...tenant.map((content) => ({ change: "added", content })),
+        ];
+    }
+    const rows = system.length;
+    const cols = tenant.length;
+    const width = cols + 1;
+    // lengths[i * width + j] = LCS length of system[i..] and tenant[j..]
+    const lengths = new Uint32Array((rows + 1) * width);
+    const lengthAt = (i, j) => lengths[i * width + j] ?? 0;
+    for (let i = rows - 1; i >= 0; i--) {
+        for (let j = cols - 1; j >= 0; j--) {
+            lengths[i * width + j] =
+                system[i] === tenant[j]
+                    ? lengthAt(i + 1, j + 1) + 1
+                    : Math.max(lengthAt(i + 1, j), lengthAt(i, j + 1));
+        }
+    }
+    const result = [];
+    let i = 0;
+    let j = 0;
+    while (i < rows || j < cols) {
+        const systemBlock = system[i];
+        const tenantBlock = tenant[j];
+        if (systemBlock !== undefined && systemBlock === tenantBlock) {
+            result.push({ change: "same", content: systemBlock });
+            i++;
+            j++;
+        }
+        else if (systemBlock !== undefined &&
+            (tenantBlock === undefined || lengthAt(i + 1, j) >= lengthAt(i, j + 1))) {
+            result.push({ change: "removed", content: systemBlock });
+            i++;
+        }
+        else if (tenantBlock !== undefined) {
+            result.push({ change: "added", content: tenantBlock });
+            j++;
+        }
+    }
+    return result;
+}

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;
+};

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

@@ -0,0 +1,72 @@
+import { Temporal } from "@cosmicdrift/kumiko-types/temporal";
+import * as z from "zod";
+import { CONTENT_FORMATS } from "./constants.js";
+const templateDraftSchema = z.object({
+    content: z.string().nullable(),
+    contentFormat: z.enum(CONTENT_FORMATS),
+    variableSchema: z.string(),
+    meta: z.string().nullable(),
+    title: z.string().nullable(),
+    folder: z.string().nullable(),
+    parentTemplateId: z.string().nullable(),
+});
+export function parseTemplateDraft(raw) {
+    if (raw === null)
+        return null;
+    try {
+        const parsed = templateDraftSchema.safeParse(JSON.parse(raw));
+        return parsed.success ? parsed.data : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function serializeTemplateDraft(draft) {
+    return JSON.stringify(draft);
+}
+export function activeVersionOf(row) {
+    return row.activeVersion ?? row.version;
+}
+// `version` also counts draft saves, so only a row without a served version shows it as its number.
+export function servedVersionOf(row) {
+    return row.status === "active" ? activeVersionOf(row) : row.version;
+}
+export function activeSinceOf(row) {
+    return row.activeSince ?? row.modifiedAt ?? row.insertedAt;
+}
+// A SystemAdmin edits system rows, so for them those rows count as their own.
+function isSystemAdmin(user) {
+    return user.roles.includes("SystemAdmin");
+}
+// A system row that was never served keeps its draft in the main fields, so only a SystemAdmin may read it.
+export function isHiddenSystemDraft(user, row) {
+    return row.scope === "system" && row.status === "draft" && !isSystemAdmin(user);
+}
+export function draftViewerTenantId(user, row) {
+    return row.scope === "system" && isSystemAdmin(user) ? row.tenantId : user.tenantId;
+}
+// The version an editor works on: the open draft if there is one, else the stored row.
+// A draft is only shown to the tenant that owns the row, never through a system row.
+export function toWorkingRow(row, viewerTenantId) {
+    const active = row.status === "active" ? { version: activeVersionOf(row), since: activeSinceOf(row) } : null;
+    const draft = row.tenantId === viewerTenantId ? parseTemplateDraft(row.draft) : null;
+    // Saves and discards of drafts raise row.version; an editor without a draft shows the served number.
+    if (draft === null)
+        return { ...row, version: active?.version ?? row.version, active };
+    return { ...row, ...draft, status: "draft", active };
+}
+// Event changes that turn a row into a served one. Every value is explicit so a
+// rebuild reproduces the row without deriving anything.
+export function servedStampChanges(row) {
+    return {
+        activeVersion: row === null ? 1 : row.version + 1,
+        activeSince: Temporal.Now.instant(),
+    };
+}
+export function activeStampChanges(row) {
+    return { status: "active", ...servedStampChanges(row) };
+}
+// Publishing also consumes the open draft.
+export function activationChanges(row) {
+    return { ...activeStampChanges(row), draft: null };
+}