@cosmicdrift/kumiko-bundled-features 0.362.0 → 0.363.0

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

@@ -0,0 +1,20 @@
+import type { HandlerContext, SessionUser, TenantId, WriteResult } from "@cosmicdrift/kumiko-framework/engine";
+import { type FieldIssue } from "@cosmicdrift/kumiko-framework/errors";
+import type { TemplateWriteScope } from "../layout-regions.js";
+import type { TemplateBundle } from "../template-bundle.js";
+export declare function targetExistsIssue(locale: string): FieldIssue;
+type BundleImport = {
+    readonly ctx: HandlerContext;
+    readonly user: SessionUser;
+    readonly tenantId: TenantId;
+    readonly scope: TemplateWriteScope;
+    readonly bundle: TemplateBundle;
+    readonly overwrite: boolean;
+};
+type BundleImportStatus = "draft" | "active";
+export declare function importTemplateBundle(args: BundleImport & {
+    readonly status: BundleImportStatus;
+}): Promise<WriteResult<{
+    ids: Record<string, string>;
+}>>;
+export {};

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

@@ -0,0 +1,147 @@
+import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
+import { ValidationError, writeFailure, } from "@cosmicdrift/kumiko-framework/errors";
+import { requireForTenant } from "../../shared/index.js";
+import { attachmentLimitFailure, attachmentNeedsMailTemplate, readTemplateResourceMaxBytes, storeBundleAttachment, storeTemplateResource, } from "../store-template-resource.js";
+import { templateResourcesTable } from "../table.js";
+import { attachTemplateResources } from "../template-resources.js";
+import { resolveTemplateVariables } from "../template-validation.js";
+import { MAX_FILE_ATTACHMENTS_PER_TEMPLATE } from "./resource-shared.js";
+import { evaluateTemplateWrite } from "./template-gates.js";
+import { refuseTenantScopeUnderSystemTenant, writeTemplateRow, } from "./template-write.js";
+export function targetExistsIssue(locale) {
+    return {
+        path: "locale",
+        code: "target_exists",
+        i18nKey: "templateResolver.errors.template.targetExists",
+        params: { detail: locale },
+    };
+}
+async function collectBundleIssues(args, status) {
+    const { ctx, tenantId, scope, bundle, overwrite } = args;
+    const { db } = requireForTenant(ctx, tenantId);
+    const variables = resolveTemplateVariables(ctx.registry, bundle.slug, bundle.variableSchema ?? {});
+    const issues = [];
+    for (const [locale, entry] of Object.entries(bundle.locales)) {
+        const evaluated = evaluateTemplateWrite({
+            kind: bundle.kind,
+            scope,
+            contentFormat: bundle.contentFormat,
+            content: entry.body,
+            rawMeta: entry.meta,
+            variables,
+        });
+        const found = evaluated.ok
+            ? status === "active"
+                ? evaluated.publishIssues
+                : []
+            : evaluated.issues;
+        issues.push(...found.map((issue) => ({ ...issue, path: `locales.${locale}.${issue.path}` })));
+        if (!overwrite) {
+            const existing = await fetchOne(db, templateResourcesTable, {
+                tenantId,
+                slug: bundle.slug,
+                kind: bundle.kind,
+                locale,
+            });
+            if (existing)
+                issues.push(targetExistsIssue(locale));
+        }
+    }
+    return issues;
+}
+async function storeBundleResources(args) {
+    const linked = {};
+    const pdfLinks = Object.entries(args.bundle.pdfAttachments);
+    const attachmentCount = Object.values(args.bundle.resources).filter((resource) => resource.purpose === "attachment")
+        .length + pdfLinks.length;
+    if (attachmentCount > 0 && args.bundle.kind !== "mail")
+        return attachmentNeedsMailTemplate();
+    if (attachmentCount > MAX_FILE_ATTACHMENTS_PER_TEMPLATE)
+        return attachmentLimitFailure();
+    // The document template is not looked up: a bundle may carry it later than the mail.
+    for (const [key, link] of pdfLinks)
+        linked[key] = { kind: "rendered-pdf", ...link };
+    const maxBytes = await readTemplateResourceMaxBytes(args.ctx.config, args.ctx.registry);
+    // A bundle is untrusted input like an upload: the same re-encoding decides the stored
+    // content type, so a declared image/png can't smuggle SVG or HTML into a mail or PDF.
+    for (const [key, resource] of Object.entries(args.bundle.resources)) {
+        const bytes = Uint8Array.from(Buffer.from(resource.base64, "base64"));
+        if (resource.purpose === "attachment") {
+            const attachment = await storeBundleAttachment({
+                ctx: args.ctx,
+                user: args.user,
+                tenantId: args.tenantId,
+                bytes,
+                maxBytes,
+                key,
+                fileName: resource.fileName,
+            });
+            if (!attachment.isSuccess)
+                return attachment;
+            linked[key] = attachment.data;
+            continue;
+        }
+        const stored = await storeTemplateResource({
+            ctx: args.ctx,
+            user: args.user,
+            tenantId: args.tenantId,
+            bytes,
+            maxBytes,
+            key,
+        });
+        if (!stored.isSuccess)
+            return stored;
+        linked[key] = stored.data.fileRefId;
+    }
+    return { isSuccess: true, data: linked };
+}
+// Validates every locale first, stores the resource files, then writes one row
+// per locale, so a bad locale never leaves files or half a bundle behind. An image
+// that fails re-encoding stops the import before any row is written; files stored
+// for the resources before it stay as unlinked FileRefs, like a replaced upload.
+export async function importTemplateBundle(args) {
+    const refused = refuseTenantScopeUnderSystemTenant(args.scope, args.tenantId);
+    if (refused !== null)
+        return refused;
+    const issues = await collectBundleIssues(args, args.status);
+    if (issues.length > 0)
+        return writeFailure(new ValidationError({ fields: [...issues] }));
+    const linked = await storeBundleResources(args);
+    if (!linked.isSuccess)
+        return linked;
+    const variableSchema = args.bundle.variableSchema ?? {};
+    const variables = resolveTemplateVariables(args.ctx.registry, args.bundle.slug, variableSchema);
+    const ids = {};
+    for (const [locale, entry] of Object.entries(args.bundle.locales)) {
+        const payload = {
+            slug: args.bundle.slug,
+            kind: args.bundle.kind,
+            locale,
+            content: entry.body,
+            contentFormat: args.bundle.contentFormat,
+            variableSchema,
+            meta: entry.meta,
+        };
+        const written = await writeTemplateRow({
+            ctx: args.ctx,
+            user: args.user,
+            tenantId: args.tenantId,
+            scope: args.scope,
+            status: args.status,
+            variables,
+            payload,
+        });
+        if (!written.isSuccess)
+            return written;
+        const attached = await attachTemplateResources(args.ctx, {
+            user: args.user,
+            tenantId: args.tenantId,
+            templateId: written.data.id,
+            resources: linked.data,
+        });
+        if (!attached.isSuccess)
+            return attached;
+        ids[locale] = written.data.id;
+    }
+    return { isSuccess: true, data: { ids } };
+}

package/dist/template-resolver/handlers/collection-set.write.js

@@ -1,7 +1,10 @@
 import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
 import { defineWriteHandler, } from "@cosmicdrift/kumiko-framework/engine";
+import { ValidationError, writeFailure } from "@cosmicdrift/kumiko-framework/errors";
 import * as z from "zod";
 import { requireForTenant } from "../../shared/index.js";
+import { COLLECTION_REFUSED_KINDS } from "../constants.js";
+import { documentViolationsToFieldIssues, sanitizeTemplateBody } from "../document-sanitizer.js";
 import { collectionStore, DEFAULT_COLLECTION_ACCESS, } from "./collection-shared.js";
 import { contentFormatSchema, folderSchema, localeSchema, slugSchema } from "./shared.js";
 // Upsert inside one collection. Mirrors set.write for text-blocks, but the
@@ -30,6 +33,18 @@ export function makeCollectionSetWrite(collection) {
             ? `Creates or overwrites the caller's own "${collection.id}" entry at a slug and locale, live on save with no draft stage; it always writes the acting user's entry, never another user's.`
             : `Creates or overwrites the tenant-wide "${collection.id}" entry at a slug and locale, live on save with no draft stage; the change is visible to everyone who may reach this shared collection.`,
         handler: async (event, ctx) => {
+            if (COLLECTION_REFUSED_KINDS.includes(collection.kind)) {
+                return writeFailure(new ValidationError({
+                    fields: [
+                        {
+                            path: "kind",
+                            code: "kind_not_allowed",
+                            i18nKey: "templateResolver.errors.collection.kindNotAllowed",
+                            params: { detail: collection.kind },
+                        },
+                    ],
+                }));
+            }
             const override = event.payload.tenantIdOverride;
             // @cast-boundary engine-payload — override is a zod-validated string, the
             // user's own tenantId is already TenantId-branded.
@@ -39,6 +54,14 @@ export function makeCollectionSetWrite(collection) {
             // writing into another tenant still writes their own entry, never
             // someone else's signature.
             const owner = store.scopeOf(event.user);
+            const body = sanitizeTemplateBody({
+                kind: collection.kind,
+                contentFormat: event.payload.contentFormat,
+                content: event.payload.content,
+            });
+            if (!body.ok) {
+                return writeFailure(new ValidationError({ fields: documentViolationsToFieldIssues(body.violations) }));
+            }
             const existing = await fetchOne(db, store.table, {
                 tenantId,
                 slug: event.payload.slug,
@@ -55,7 +78,7 @@ export function makeCollectionSetWrite(collection) {
                     // the template upserts put on the row.
                     changes: {
                         title: event.payload.title,
-                        content: event.payload.content,
+                        content: body.content,
                         contentFormat: event.payload.contentFormat,
                         folder: event.payload.folder ?? null,
                     },
@@ -73,7 +96,7 @@ export function makeCollectionSetWrite(collection) {
                 kind: collection.kind,
                 locale: event.payload.locale,
                 title: event.payload.title,
-                content: event.payload.content,
+                content: body.content,
                 contentFormat: event.payload.contentFormat,
                 folder: event.payload.folder ?? null,
                 ...store.createDefaults(tenantId),

package/dist/template-resolver/handlers/copy-locale.write.d.ts

@@ -0,0 +1,19 @@
+import * as z from "zod";
+export declare const copyLocaleWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<"copy-locale", 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";
+    }>;
+    fromLocale: z.ZodString;
+    toLocale: z.ZodString;
+    overwrite: z.ZodDefault<z.ZodBoolean>;
+    scope: z.ZodDefault<z.ZodEnum<{
+        system: "system";
+        tenant: "tenant";
+    }>>;
+}, z.core.$strip>, import("./template-write.js").WrittenTemplateRow, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/template-resolver/handlers/copy-locale.write.js

@@ -0,0 +1,116 @@
+import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
+import { defineWriteHandler, SYSTEM_TENANT_ID, } from "@cosmicdrift/kumiko-framework/engine";
+import { AccessDeniedError, NotFoundError, ValidationError, writeFailure, } from "@cosmicdrift/kumiko-framework/errors";
+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 { TemplateResolverErrors } from "../qualified-names.js";
+import { templateResourcesTable } from "../table.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";
+import { parseStoredJson, storedRecord } from "./template-gates.js";
+import { refuseTenantScopeUnderSystemTenant, writeTemplateRow } from "./template-write.js";
+function readDbFor(ctx, scope) {
+    return scope === "system" ? requireForTenant(ctx, SYSTEM_TENANT_ID).db : ctx.db;
+}
+// A tenant copy may start from the system default; a system copy only from system rows.
+async function findCopySource(ctx, where) {
+    const { scope, tenantId, slug, kind, locale } = where;
+    const readDb = readDbFor(ctx, scope);
+    const own = await fetchOne(readDb, templateResourcesTable, {
+        tenantId,
+        slug,
+        kind,
+        locale,
+    });
+    if (own || scope === "system")
+        return own;
+    return fetchOne(readDb, templateResourcesTable, {
+        tenantId: SYSTEM_TENANT_ID,
+        slug,
+        kind,
+        locale,
+        status: "active",
+    });
+}
+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 readDb = readDbFor(ctx, scope);
+        const source = await findCopySource(ctx, { scope, tenantId, slug, kind, locale: fromLocale });
+        if (!source || !isOneOf(CONTENT_FORMATS, source.contentFormat)) {
+            return writeFailure(new NotFoundError("template-resource", `${slug}/${fromLocale}`));
+        }
+        if (!overwrite) {
+            const target = await fetchOne(readDb, templateResourcesTable, {
+                tenantId,
+                slug,
+                kind,
+                locale: toLocale,
+            });
+            if (target) {
+                return writeFailure(new ValidationError({ fields: [targetExistsIssue(toLocale)] }));
+            }
+        }
+        const variableSchema = storedRecord(source.variableSchema);
+        const written = await writeTemplateRow({
+            ctx,
+            user: event.user,
+            tenantId,
+            scope,
+            status: "draft",
+            variables: resolveTemplateVariables(ctx.registry, slug, variableSchema),
+            payload: {
+                slug,
+                kind,
+                locale: toLocale,
+                content: source.content,
+                contentFormat: source.contentFormat,
+                variableSchema,
+                meta: parseStoredJson(source.meta),
+                title: source.title,
+                folder: source.folder,
+            },
+        });
+        if (!written.isSuccess)
+            return written;
+        // A system source carries no files of its own: its resource keys are known to the tenant row anyway.
+        if (source.tenantId === tenantId) {
+            const attached = await attachTemplateResources(ctx, {
+                user: event.user,
+                tenantId,
+                templateId: written.data.id,
+                resources: parseLinkedResourceEntries(source.linkedResources),
+            });
+            if (!attached.isSuccess)
+                return attached;
+        }
+        return written;
+    },
+});

package/dist/template-resolver/handlers/diff-to-system.query.d.ts

@@ -0,0 +1,22 @@
+import * as z from "zod";
+export declare const diffToSystemQuery: import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"diff-to-system", z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>, {
+    tenant: {
+        templateId: string;
+        templateVersion: number;
+        contentFormat: string;
+    };
+    system: {
+        templateId: string;
+        templateVersion: number;
+        contentFormat: string;
+    };
+    identical: boolean;
+    blocks: import("../template-diff.js").TemplateDiffBlock[];
+    meta: {
+        key: string;
+        tenant: unknown;
+        system: unknown;
+    }[];
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/template-resolver/handlers/diff-to-system.query.js

@@ -0,0 +1,64 @@
+import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
+import { defineQueryHandler, SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
+import { NotFoundError } from "@cosmicdrift/kumiko-framework/errors";
+import * as z from "zod";
+import { templateResourcesTable } from "../table.js";
+import { diffTemplateBlocks, splitTemplateBlocks } from "../template-diff.js";
+function parseStoredMeta(raw) {
+    if (raw === null)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? Object.fromEntries(Object.entries(parsed))
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function diffMeta(system, tenant) {
+    const keys = [...new Set([...Object.keys(system), ...Object.keys(tenant)])].sort();
+    return keys
+        .filter((key) => JSON.stringify(system[key]) !== JSON.stringify(tenant[key]))
+        .map((key) => ({ key, tenant: tenant[key], system: system[key] }));
+}
+export const diffToSystemQuery = defineQueryHandler({
+    name: "diff-to-system",
+    schema: z.object({ id: z.string().min(1) }),
+    access: { roles: ["TenantAdmin", "SystemAdmin"] },
+    description: "Compares one tenant override with the system template of the same slug, kind and locale block by block and lists the changed meta settings; use it to show what an override changes before resetting it to the system version.",
+    handler: async (query, ctx) => {
+        const tenantRow = await fetchOne(ctx.db, templateResourcesTable, {
+            id: query.payload.id,
+        });
+        if (!tenantRow || tenantRow.tenantId !== query.user.tenantId || tenantRow.scope !== "tenant") {
+            throw new NotFoundError("template-resource", query.payload.id);
+        }
+        const systemRow = await fetchOne(ctx.db, templateResourcesTable, {
+            tenantId: SYSTEM_TENANT_ID,
+            slug: tenantRow.slug,
+            kind: tenantRow.kind,
+            locale: tenantRow.locale,
+        });
+        if (!systemRow)
+            throw new NotFoundError("template-resource", tenantRow.slug);
+        const blocks = diffTemplateBlocks(splitTemplateBlocks(systemRow.content ?? "", systemRow.contentFormat), splitTemplateBlocks(tenantRow.content ?? "", tenantRow.contentFormat));
+        const meta = diffMeta(parseStoredMeta(systemRow.meta), parseStoredMeta(tenantRow.meta));
+        return {
+            tenant: {
+                templateId: String(tenantRow.id),
+                templateVersion: tenantRow.version,
+                contentFormat: tenantRow.contentFormat,
+            },
+            system: {
+                templateId: String(systemRow.id),
+                templateVersion: systemRow.version,
+                contentFormat: systemRow.contentFormat,
+            },
+            identical: meta.length === 0 && blocks.every((block) => block.change === "same"),
+            blocks,
+            meta,
+        };
+    },
+});

package/dist/template-resolver/handlers/export-bundle.query.d.ts

@@ -0,0 +1,35 @@
+import * as z from "zod";
+export declare const exportBundleQuery: import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"export-bundle", 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";
+    }>;
+    scope: z.ZodDefault<z.ZodEnum<{
+        system: "system";
+        tenant: "tenant";
+    }>>;
+}, z.core.$strip>, {
+    slug: string;
+    kind: "ai-prompt" | "document-pdf" | "image-snapshot" | "mail" | "mail-layout" | "pdf-layout";
+    contentFormat: string;
+    variableSchema: Readonly<Record<string, unknown>>;
+    locales: Record<string, {
+        body: string;
+        meta?: unknown;
+    }>;
+    resources: Record<string, {
+        fileName: string;
+        contentType: string;
+        base64: string;
+        purpose?: "attachment" | undefined;
+    }>;
+    pdfAttachments: Record<string, {
+        templateSlug: string;
+        fileName: string;
+    }>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/template-resolver/handlers/export-bundle.query.js

@@ -0,0 +1,68 @@
+import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
+import { defineQueryHandler, SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
+import { NotFoundError } from "@cosmicdrift/kumiko-framework/errors";
+import * as z from "zod";
+import { isFileAttachmentEntry, isPdfAttachmentLink, parseLinkedResourceEntries, } from "../linked-resources.js";
+import { templateResourcesTable } from "../table.js";
+import { readTemplateResource } from "../template-resources.js";
+import { kindSchema, templateSlugSchema } from "./shared.js";
+import { parseStoredJson, storedRecord } from "./template-gates.js";
+export const exportBundleQuery = defineQueryHandler({
+    name: "export-bundle",
+    schema: z.object({
+        slug: templateSlugSchema,
+        kind: kindSchema,
+        scope: z.enum(["tenant", "system"]).default("tenant"),
+    }),
+    access: { roles: ["TenantAdmin", "SystemAdmin"] },
+    description: "Exports every locale of one template (the caller's own rows, or the active system rows) together with its linked resource files as a self-contained bundle that import-bundle can read back, for example to move a template between tenants or environments.",
+    handler: async (query, ctx) => {
+        const { slug, kind, scope } = query.payload;
+        const found = await selectMany(ctx.db, templateResourcesTable, scope === "system"
+            ? { tenantId: SYSTEM_TENANT_ID, slug, kind, scope: "system", status: "active" }
+            : { tenantId: query.user.tenantId, slug, kind, scope: "tenant" });
+        const rows = found
+            .filter((row) => row.status !== "archived")
+            .sort((a, b) => a.locale.localeCompare(b.locale));
+        const first = rows[0];
+        if (!first)
+            throw new NotFoundError("template-resource", slug);
+        const locales = {};
+        const entryByKey = new Map();
+        for (const row of rows) {
+            const meta = parseStoredJson(row.meta);
+            locales[row.locale] = { body: row.content ?? "", ...(meta === undefined ? {} : { meta }) };
+            for (const [key, entry] of Object.entries(parseLinkedResourceEntries(row.linkedResources))) {
+                if (!entryByKey.has(key))
+                    entryByKey.set(key, entry);
+            }
+        }
+        const resources = {};
+        const pdfAttachments = {};
+        for (const [key, entry] of entryByKey) {
+            if (isPdfAttachmentLink(entry)) {
+                pdfAttachments[key] = { templateSlug: entry.templateSlug, fileName: entry.fileName };
+                continue;
+            }
+            const attachment = isFileAttachmentEntry(entry);
+            const file = await readTemplateResource({ db: ctx.db, files: ctx.files, user: query.user }, attachment ? entry.fileRefId : entry);
+            if (!file)
+                throw new NotFoundError("template-resource-file", key);
+            resources[key] = {
+                fileName: attachment ? entry.fileName : file.fileName,
+                contentType: file.contentType,
+                base64: Buffer.from(file.bytes).toString("base64"),
+                ...(attachment && { purpose: "attachment" }),
+            };
+        }
+        return {
+            slug,
+            kind,
+            contentFormat: first.contentFormat,
+            variableSchema: storedRecord(first.variableSchema),
+            locales,
+            resources,
+            pdfAttachments,
+        };
+    },
+});

package/dist/template-resolver/handlers/find-by-id.query.d.ts

@@ -12,6 +12,7 @@ export declare const findByIdQuery: import("@cosmicdrift/kumiko-types/define-han
     contentFormat: string;
     variableSchema: string | null;
     linkedResources: string | null;
+    meta: string | null;
     scope: string;
     parentTemplateId: string | null;
     status: string;

package/dist/template-resolver/handlers/find-by-id.query.js

@@ -5,7 +5,7 @@ import { templateResourcesTable } from "../table.js";
 // Admin-Lookup für UI-Edit-Flow. Returnt das raw Template inkl. draft/
 // archived Status. Tenant-Isolation: User sieht nur Templates des
 // eigenen Tenants oder SYSTEM_TENANT (system-defaults sind public-
-// readable). SystemAdmin sieht alle. Anonymous bleibt aus — Public-
+// readable); ctx.db is tenant-scoped for every role, so the check below is defense in depth. Anonymous bleibt aus — Public-
 // Read geht über resolveTemplate aus der API, nicht hier.
 export const findByIdQuery = defineQueryHandler({
     name: "find-by-id",
@@ -18,10 +18,9 @@ export const findByIdQuery = defineQueryHandler({
         });
         if (!row)
             return null;
-        const isSystemAdmin = query.user.roles.includes("SystemAdmin");
         const isOwnTenant = row.tenantId === query.user.tenantId;
         const isSystemTemplate = row.scope === "system";
-        if (!isSystemAdmin && !isOwnTenant && !isSystemTemplate)
+        if (!isOwnTenant && !isSystemTemplate)
             return null;
         return {
             id: String(row.id),
@@ -34,6 +33,7 @@ export const findByIdQuery = defineQueryHandler({
             contentFormat: row.contentFormat,
             variableSchema: row.variableSchema,
             linkedResources: row.linkedResources,
+            meta: row.meta,
             scope: row.scope,
             parentTemplateId: row.parentTemplateId,
             status: row.status,

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

@@ -0,0 +1,39 @@
+import * as z from "zod";
+export declare const importBundleSystemWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<"import-bundle-system", z.ZodObject<{
+    bundle: 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>;
+}, z.core.$strip>, {
+    ids: Record<string, string>;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;