@cosmicdrift/kumiko-samples 0.373.0 → 0.377.0

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

@@ -0,0 +1,48 @@
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { NotFoundError } from "@cosmicdrift/kumiko-framework/errors";
+import * as z from "zod";
+import { DOCUMENT_HTML_KINDS } from "../constants.ts";
+import { documentBlocksForKind } from "../document-blocks.ts";
+import { documentBlocksOf } from "../document-ops.ts";
+import { parseDocumentJson } from "../document-sanitizer.ts";
+import { resolveTemplateVariables } from "../template-validation.ts";
+import { loadDocumentBase } from "./document-base.ts";
+import { localeSchema, templateSlugSchema } from "./shared.ts";
+import { knownResourceKeysFor } from "./validate.query.ts";
+
+export const documentBlocksQuery = defineQueryHandler({
+  name: "document-blocks",
+  schema: z.object({
+    slug: templateSlugSchema,
+    kind: z.enum(DOCUMENT_HTML_KINDS),
+    locale: localeSchema,
+  }),
+  access: { roles: ["TenantAdmin", "SystemAdmin"] },
+  description:
+    "Reads a mail or PDF document template as a list of blocks with stable ids (b0, b1, ...) for structured editing: each block has its type (paragraph, heading, list, table, repeat, image, button, divider, pageBreak, steps), its text with {{name}} placeholders and its settings, plus the meta, the stored and effective variables (variablesDeclaredByFeature is true when a notification declares them, so they cannot be changed), the block types allowed for the kind and the uploaded image keys. It reads the caller's own version (the open draft if there is one), else the served system default; base carries the scope and version that patch-draft expects back.",
+  handler: async (query, ctx) => {
+    const { slug, kind, locale } = query.payload;
+    const loaded = await loadDocumentBase(ctx, query.user, { slug, kind, locale });
+    if (loaded === null) throw new NotFoundError("template-resource", slug);
+    return {
+      slug,
+      kind,
+      locale,
+      base: loaded.base,
+      status: loaded.status,
+      blocks: documentBlocksOf(parseDocumentJson(loaded.content)),
+      meta: loaded.meta,
+      variableSchema: loaded.variableSchema,
+      variables: resolveTemplateVariables(ctx.registry, slug, loaded.variableSchema),
+      variablesDeclaredByFeature:
+        ctx.registry.getAllNotifications().get(slug)?.variables !== undefined,
+      allowedBlocks: documentBlocksForKind(kind),
+      resourceKeys: await knownResourceKeysFor(ctx, query.user, {
+        slug,
+        kind,
+        scope: "tenant",
+        locale,
+      }),
+    };
+  },
+});

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

@@ -66,6 +66,15 @@ function assertLocalesShareFormat(rows: readonly TemplateResourceRow[]): void {
   });
 }
 
+function localeEntryOf(row: TemplateResourceRow): { body: string; meta?: unknown; title?: string } {
+  const meta = parseStoredJson(row.meta);
+  return {
+    body: row.content ?? "",
+    ...(meta === undefined ? {} : { meta }),
+    ...(row.title === null ? {} : { title: row.title }),
+  };
+}
+
 export const exportBundleQuery = defineQueryHandler({
   name: "export-bundle",
   schema: z.object({
@@ -92,11 +101,10 @@ export const exportBundleQuery = defineQueryHandler({
     if (!first) throw new NotFoundError("template-resource", slug);
     assertLocalesShareFormat(rows);
 
-    const locales: Record<string, { body: string; meta?: unknown }> = {};
+    const locales: Record<string, { body: string; meta?: unknown; title?: string }> = {};
     const entryByKey = new Map<string, LinkedResourceEntry>();
     for (const row of rows) {
-      const meta = parseStoredJson(row.meta);
-      locales[row.locale] = { body: row.content ?? "", ...(meta === undefined ? {} : { meta }) };
+      locales[row.locale] = localeEntryOf(row);
       for (const [key, entry] of Object.entries(parseLinkedResourceEntries(row.linkedResources))) {
         if (!entryByKey.has(key)) entryByKey.set(key, entry);
       }

package/packages/bundled-features/src/template-resolver/handlers/patch-draft.write.ts

@@ -0,0 +1,125 @@
+import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
+import {
+  type FieldIssue,
+  NotFoundError,
+  ValidationError,
+  VersionConflictError,
+  writeFailure,
+} from "@cosmicdrift/kumiko-framework/errors";
+import * as z from "zod";
+import { DOCUMENT_HTML_KINDS } from "../constants.ts";
+import { applyDocumentOps, documentOpsSchema } from "../document-ops.ts";
+import { parseDocumentJson, serializeDocumentJson } from "../document-sanitizer.ts";
+import { resolveTemplateVariables } from "../template-validation.ts";
+import { loadDocumentBase } from "./document-base.ts";
+import { localeSchema, templateSlugSchema } from "./shared.ts";
+import { writeTemplateRow } from "./template-write.ts";
+import { validateTemplateDraft } from "./validate.query.ts";
+
+function validationFailure(issue: FieldIssue) {
+  return writeFailure(new ValidationError({ fields: [issue] }));
+}
+
+export const patchDraftWrite = defineWriteHandler({
+  name: "patch-draft",
+  schema: z.object({
+    slug: templateSlugSchema,
+    kind: z.enum(DOCUMENT_HTML_KINDS),
+    locale: localeSchema,
+    base: z.object({
+      scope: z.enum(["tenant", "system"]),
+      version: z.number().int().nonnegative(),
+    }),
+    ops: documentOpsSchema,
+  }),
+  access: { roles: ["TenantAdmin", "SystemAdmin"] },
+  description:
+    "Changes a mail or PDF document template with structured operations instead of a full rewrite and saves the result as the caller's tenant draft (never published, an active version keeps being served until publish): insertBlock after a block id (null = at the start; paragraph, heading, image, button, divider, pageBreak), replaceText inside one block (the text must occur exactly once), removeBlock, setResource on an image block, setMeta (flat merge, null removes a key) and setVariable (adds, replaces or with null removes a variable definition; refused when a notification declares the variables). Block ids and base come from document-blocks and refer to the state that was read; if the template changed since, the call fails with version_conflict and nothing is written. A patch that removes a required placeholder is refused. Returns the written row.",
+  handler: async (event, ctx) => {
+    const { slug, kind, locale, base, ops } = event.payload;
+    const loaded = await loadDocumentBase(ctx, event.user, { slug, kind, locale });
+    if (loaded === null) return writeFailure(new NotFoundError("template-resource", slug));
+    if (loaded.base.scope !== base.scope || loaded.base.version !== base.version) {
+      return writeFailure(
+        new VersionConflictError({
+          entityId: loaded.rowId,
+          expectedVersion: base.version,
+          currentVersion: loaded.base.version,
+        }),
+      );
+    }
+
+    const variableOpIndex = ops.findIndex((op) => op.op === "setVariable");
+    if (
+      variableOpIndex !== -1 &&
+      ctx.registry.getAllNotifications().get(slug)?.variables !== undefined
+    ) {
+      return validationFailure({
+        path: `ops.${variableOpIndex}`,
+        code: "variables_declared_by_feature",
+        i18nKey: "templateResolver.errors.patch.variablesDeclaredByFeature",
+        params: { slug },
+      });
+    }
+
+    const applied = applyDocumentOps({
+      doc: parseDocumentJson(loaded.content),
+      meta: loaded.meta,
+      variableSchema: loaded.variableSchema,
+      kind,
+      ops,
+    });
+    if (!applied.ok) return writeFailure(new ValidationError({ fields: applied.issues }));
+    const content = serializeDocumentJson(applied.doc);
+
+    const draftOf = (
+      draftContent: string,
+      meta: unknown,
+      variableSchema: Record<string, unknown>,
+    ) =>
+      validateTemplateDraft(ctx, event.user, {
+        slug,
+        kind,
+        contentFormat: "html",
+        content: draftContent,
+        meta,
+        variableSchema,
+        locale,
+        scope: "tenant",
+      });
+    const before = await draftOf(loaded.content, loaded.meta, loaded.variableSchema);
+    const after = await draftOf(content, applied.meta, applied.variableSchema);
+    const alreadyMissing = new Set(before.response.missingRequired);
+    const removed = after.response.missingRequired.filter((name) => !alreadyMissing.has(name));
+    if (removed.length > 0) {
+      return validationFailure({
+        path: "ops",
+        code: "required_placeholder_removed",
+        i18nKey: "templateResolver.errors.patch.requiredPlaceholderRemoved",
+        params: { names: removed },
+      });
+    }
+
+    return writeTemplateRow({
+      ctx,
+      user: event.user,
+      tenantId: event.user.tenantId,
+      scope: "tenant",
+      status: "draft",
+      variables: resolveTemplateVariables(ctx.registry, slug, applied.variableSchema),
+      payload: {
+        slug,
+        kind,
+        locale,
+        content,
+        contentFormat: "html",
+        variableSchema: applied.variableSchema,
+        meta: applied.meta,
+        title: loaded.title,
+        folder: loaded.folder,
+        parentTemplateId: loaded.parentTemplateId,
+      },
+      expectedVersion: loaded.base.scope === "tenant" ? loaded.base.version : null,
+    });
+  },
+});

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

@@ -13,10 +13,11 @@ export const previewQuery = defineQueryHandler({
     content: z.string().max(200_000).optional(),
     meta: z.unknown().optional(),
     variableSchema: z.record(z.string(), z.unknown()).default({}),
+    variables: z.record(z.string(), z.unknown()).optional(),
   }),
   access: { roles: ["TenantAdmin", "SystemAdmin"] },
   description:
-    "Renders a template draft, or the stored template when no content is given, with sample values taken from the declared variable examples, without saving or sending anything: returns the mail subject, html and plain text with its inline images (a PDF template returns its body and layout regions instead), the sample values used, and checks for unresolved images, missing plain text, mail size and unused required placeholders; a draft that fails the write rules is rejected with the same problems as a save.",
+    "Renders a template draft, or the stored template when no content is given, with sample values taken from the declared variable examples (values passed in variables replace them and are checked against the variable schema), without saving or sending anything: returns the mail subject, html and plain text with its inline images (a PDF template returns its body and layout regions instead), the sample values used, and checks for unresolved images, missing plain text, mail size and unused required placeholders; a draft that fails the write rules is rejected with the same problems as a save.",
   handler: async (query, ctx) => {
     const outcome = await renderTemplatePreview(ctx, query.user, query.payload);
     if (!outcome.ok) throw outcome.error;

package/packages/bundled-features/src/template-resolver/handlers/send-test.write.ts

@@ -42,13 +42,14 @@ export const sendTestWrite = defineWriteHandler({
     content: z.string().max(200_000).optional(),
     meta: z.unknown().optional(),
     variableSchema: z.record(z.string(), z.unknown()).default({}),
+    variables: z.record(z.string(), z.unknown()).optional(),
     includeAttachments: z.boolean().default(true),
     prefixSubject: z.boolean().default(true),
   }),
   access: { roles: ["TenantAdmin", "SystemAdmin"] },
   rateLimit: { per: "user+handler", ...TEST_MAIL_RATE_LIMIT },
   description:
-    "Sends the rendered preview of a mail template draft, or of the stored template when no content is given, to the calling user's own address with the subject prefixed by [TEST] unless prefixSubject is false, carrying the inline images and, unless includeAttachments is false, the files attached to the template; there is no recipient input, the sample values come from the declared variable examples, and a draft that fails the write rules is rejected without sending.",
+    "Sends the rendered preview of a mail template draft, or of the stored template when no content is given, to the calling user's own address with the subject prefixed by [TEST] unless prefixSubject is false, carrying the inline images and, unless includeAttachments is false, the files attached to the template; there is no recipient input, the sample values come from the declared variable examples unless variables replaces them (checked against the variable schema), and a draft that fails the write rules is rejected without sending.",
   handler: async (event, ctx) => {
     const { includeAttachments, prefixSubject, ...previewPayload } = event.payload;
     const outcome = await renderTemplatePreview(ctx, event.user, {

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

@@ -11,6 +11,7 @@ import {
 import {
   AccessDeniedError,
   ValidationError,
+  VersionConflictError,
   type WriteFailure,
   writeFailure,
 } from "@cosmicdrift/kumiko-framework/errors";
@@ -57,6 +58,8 @@ export type TemplateRowWrite = {
   readonly status: "draft" | "active";
   readonly variables: TemplateVariables;
   readonly payload: TemplateRowPayload;
+  /** The row version the edit was made against; null means no own row may exist yet. */
+  readonly expectedVersion?: number | null;
 };
 
 // The tenant-scope-under-system-tenant ban lives here so no write path can
@@ -151,6 +154,21 @@ function updateChanges(
     : { draft };
 }
 
+function versionConflictFor(
+  expectedVersion: number | null | undefined,
+  existing: TemplateResourceRow | undefined,
+  slug: string,
+): WriteFailure | null {
+  if (expectedVersion === undefined || (existing?.version ?? null) === expectedVersion) return null;
+  return writeFailure(
+    new VersionConflictError({
+      entityId: existing?.id ?? slug,
+      expectedVersion: expectedVersion ?? 0,
+      currentVersion: existing?.version ?? 0,
+    }),
+  );
+}
+
 // Shared by every template write: validate through the one pipeline, then
 // create or update the (tenant, slug, kind, locale) row via the event-store
 // executor. linkedResources is never part of an update; resources are attached
@@ -201,11 +219,14 @@ export async function writeTemplateRow(
     status,
   };
 
+  const conflict = versionConflictFor(args.expectedVersion, existing, payload.slug);
+  if (conflict !== null) return conflict;
+
   if (existing) {
     const result = await executor.update(
       {
         id: existing.id,
-        version: existing.version,
+        version: args.expectedVersion ?? existing.version,
         changes: updateChanges(existing, status, fields),
       },
       user,

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

@@ -47,17 +47,19 @@ type TemplateDraftInput = {
   readonly scope: TemplateWriteScope;
 };
 
-// The dry run of the write pipeline; preview feeds on the evaluation, validate returns the response.
-export async function validateTemplateDraft(
+// Image keys the editor may reference: the system rows plus, for a tenant write, the caller's own.
+export async function knownResourceKeysFor(
   ctx: HandlerContext,
   user: SessionUser,
-  payload: TemplateDraftInput,
-) {
-  const variables = resolveTemplateVariables(ctx.registry, payload.slug, payload.variableSchema);
-  const { slug, kind, locale } = payload;
-  // The dry run must not promise what the caller's write handlers would refuse.
-  const scope: TemplateWriteScope = isSystemAdmin(user) ? payload.scope : "tenant";
-  const known = [
+  where: {
+    readonly slug: string;
+    readonly kind: string;
+    readonly scope: TemplateWriteScope;
+    readonly locale: string | undefined;
+  },
+): Promise<string[]> {
+  const { slug, kind, scope, locale } = where;
+  return [
     ...(await knownResourceKeys(ctx.db, {
       tenantId: SYSTEM_TENANT_ID,
       slug,
@@ -69,6 +71,19 @@ export async function validateTemplateDraft(
       ? await knownResourceKeys(ctx.db, { tenantId: user.tenantId, slug, kind, scope, locale })
       : []),
   ];
+}
+
+// The dry run of the write pipeline; preview feeds on the evaluation, validate returns the response.
+export async function validateTemplateDraft(
+  ctx: HandlerContext,
+  user: SessionUser,
+  payload: TemplateDraftInput,
+) {
+  const variables = resolveTemplateVariables(ctx.registry, payload.slug, payload.variableSchema);
+  const { slug, kind, locale } = payload;
+  // The dry run must not promise what the caller's write handlers would refuse.
+  const scope: TemplateWriteScope = isSystemAdmin(user) ? payload.scope : "tenant";
+  const known = await knownResourceKeysFor(ctx, user, { slug, kind, scope, locale });
   const evaluation = evaluateTemplateWrite({
     kind,
     scope,

package/packages/bundled-features/src/template-resolver/{web/placeholder-text.ts → placeholder-text.ts}

@@ -1,6 +1,6 @@
 // @runtime client
 import type { JSONContent } from "@tiptap/core";
-import { isDocumentReferenceName } from "../document-schema.ts";
+import { isDocumentReferenceName } from "./document-schema.ts";
 
 const PLACEHOLDER_TOKEN = /\{\{([^{}]*)\}\}/g;
 

package/packages/bundled-features/src/template-resolver/qualified-names.ts

@@ -20,6 +20,7 @@ export const TemplateResolverHandlers = {
   resourceRemove: "template-resolver:write:resource-remove",
   resourceLinkPdf: "template-resolver:write:resource-link-pdf",
   sendTest: "template-resolver:write:send-test",
+  patchDraft: "template-resolver:write:patch-draft",
 } as const;
 
 export const TemplateResolverQueries = {
@@ -32,6 +33,7 @@ export const TemplateResolverQueries = {
   diffToSystem: "template-resolver:query:diff-to-system",
   validate: "template-resolver:query:validate",
   preview: "template-resolver:query:preview",
+  documentBlocks: "template-resolver:query:document-blocks",
   exportBundle: "template-resolver:query:export-bundle",
   // Public pair — anonymous-reachable, kind pinned to text-block.
   bySlug: "template-resolver:query:by-slug",

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

@@ -78,6 +78,7 @@ export type SeedSystemTemplateOptions = {
    *  system admin uploaded through resource-upload. */
   readonly linkedResources?: Record<string, string>;
   readonly meta?: unknown;
+  readonly title?: string;
   readonly parentTemplateId?: string | null;
   readonly by?: SessionUser;
   readonly ifExists?: SeedIfExists;
@@ -138,7 +139,7 @@ export async function seedSystemTemplate(
     variableSchema,
     ...(linkedResources !== undefined && { linkedResources }),
     meta,
-    title: null,
+    title: opts.title ?? null,
     folder: null,
     scope: "system" as const,
     parentTemplateId,
@@ -261,6 +262,7 @@ export async function seedSystemTemplateBundle(
       contentFormat: bundle.contentFormat,
       variableSchema: bundle.variableSchema ?? {},
       meta: entry.meta,
+      ...(entry.title !== undefined ? { title: entry.title } : {}),
       ...(opts.by !== undefined ? { by: opts.by } : {}),
       ...(opts.ifExists !== undefined ? { ifExists: opts.ifExists } : {}),
     });

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

@@ -40,7 +40,12 @@ const bundleResourceSchema = z
 const pdfAttachmentLinkBodySchema = templatePdfAttachmentLinkSchema.omit({ kind: true });
 
 const bundleLocaleEntrySchema = z
-  .object({ body: z.string().max(200_000), meta: z.unknown().optional() })
+  .object({
+    body: z.string().max(200_000),
+    meta: z.unknown().optional(),
+    // Shown in the template overview instead of the slug; one per locale, so it is translated.
+    title: z.string().min(1).max(200).optional(),
+  })
   .strict();
 
 export const templateBundleSchema = z

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

@@ -1,20 +1,23 @@
 import { selectMany } from "@cosmicdrift/kumiko-framework/db";
-import type {
-  HandlerContext,
-  SessionUser,
-  TemplateListVariableDef,
-  TemplateScalarVariableDef,
-  TemplateVariables,
+import {
+  type HandlerContext,
+  type SessionUser,
+  type TemplateListVariableDef,
+  type TemplateScalarVariableDef,
+  type TemplateVariables,
+  templateVariablesToZod,
 } from "@cosmicdrift/kumiko-framework/engine";
 import {
   type KumikoError,
   NotFoundError,
   UnprocessableError,
   ValidationError,
+  validationErrorFromZod,
 } from "@cosmicdrift/kumiko-framework/errors";
 import { fileRefsTable } from "@cosmicdrift/kumiko-framework/files";
 import { createI18n } from "@cosmicdrift/kumiko-framework/i18n";
-import { escapeHtml } from "@cosmicdrift/kumiko-headless";
+import { escapeHtml } from "@cosmicdrift/kumiko-renderer/headless";
+import * as z from "zod";
 import { createEmailAttachmentReader, createTemplateMailRenderer } from "../delivery/index.ts";
 import { fileContextForTenant } from "../file-foundation/index.ts";
 import {
@@ -177,6 +180,8 @@ export type TemplatePreviewInput = {
   readonly content?: string | undefined;
   readonly meta?: unknown;
   readonly variableSchema: Readonly<Record<string, unknown>>;
+  /** Replaces the declared example values for the named variables. */
+  readonly variables?: Readonly<Record<string, unknown>> | undefined;
 };
 
 type ValidationResponse = Awaited<ReturnType<typeof validateTemplateDraft>>["response"];
@@ -197,6 +202,7 @@ export type TemplatePreview = {
     readonly scope: TemplateScope;
     readonly version: number;
   } | null;
+  /** The values the preview was actually rendered with: examples plus any overrides. */
   readonly sampleValues: Readonly<Record<string, unknown>>;
   readonly checks: readonly PreviewCheck[];
   readonly validation: ValidationResponse;
@@ -689,7 +695,17 @@ export async function renderTemplatePreview(
 
   const content = evaluation.content ?? "";
   const meta = parseTemplateMeta(input.kind, parseStoredJson(evaluation.metaJson));
-  const sampleValues = sampleValuesFor(validation.variables, labelTextFor(ctx, input.locale));
+  const exampleValues = sampleValuesFor(validation.variables, labelTextFor(ctx, input.locale));
+  let sampleValues = exampleValues;
+  if (input.variables !== undefined) {
+    const overrides = z.object({
+      variables: templateVariablesToZod(validation.variables).partial().strict(),
+    });
+    const checked = overrides.safeParse({ variables: input.variables });
+    if (!checked.success) return failed(validationErrorFromZod(checked.error));
+    // Original values, not the parse result: parsing would strip keys inside list rows.
+    sampleValues = { ...exampleValues, ...input.variables };
+  }
 
   if (input.kind === "document-pdf") {
     return renderDocumentPreview(ctx, user, {

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

@@ -76,7 +76,7 @@ const variableDefSchema = z.union([
 // A stored variableSchema value is either a bare string (legacy "this is a text
 // variable") or a TemplateVariableDef object; anything else is not declared and
 // therefore shows up as an unknown placeholder instead of being guessed at.
-function toVariableDef(raw: unknown): TemplateVariableDef | null {
+export function toVariableDef(raw: unknown): TemplateVariableDef | null {
   if (typeof raw === "string") return { type: "text" };
   const parsed = variableDefSchema.safeParse(raw);
   return parsed.success ? parsed.data : null;

package/packages/bundled-features/src/template-resolver/web/client-plugin.tsx

@@ -1,4 +1,4 @@
-import { EMPTY_VALUE_PLACEHOLDER } from "@cosmicdrift/kumiko-headless";
+import { EMPTY_VALUE_PLACEHOLDER } from "@cosmicdrift/kumiko-renderer/headless";
 // @runtime client
 // Client feature factory for the text-block content tree. Apps mount it via
 // createKumikoApp({ clientFeatures: [textBlocksClient()] }); it loads the
@@ -12,7 +12,6 @@ import { EMPTY_VALUE_PLACEHOLDER } from "@cosmicdrift/kumiko-headless";
 // (a hint that the slug exists but is empty).
 
 import { useShellUser } from "@cosmicdrift/kumiko-bundled-features/auth-email-password/web";
-import { CSRF_HEADER_NAME, readCsrfToken } from "@cosmicdrift/kumiko-dispatcher-live";
 import type {
   TargetRef,
   TreeChildrenSubscribe,
@@ -28,11 +27,12 @@ import {
   useQuery,
   useTranslation,
 } from "@cosmicdrift/kumiko-renderer";
+import { CSRF_HEADER_NAME, readCsrfToken } from "@cosmicdrift/kumiko-renderer/live";
 import {
   type ClientFeatureDefinition,
   PlainContentEditor,
   RichContentEditor,
-} from "@cosmicdrift/kumiko-renderer-web";
+} from "@cosmicdrift/kumiko-renderer/web";
 import type { ContentEditorFormat } from "@cosmicdrift/kumiko-types/nav";
 import { type FormEvent, type ReactNode, useEffect, useId, useState } from "react";
 import {

package/packages/bundled-features/src/template-resolver/web/document-tiptap-editor.tsx

@@ -12,7 +12,7 @@ import {
   useTranslation,
   VariableChips,
 } from "@cosmicdrift/kumiko-renderer";
-import { cn } from "@cosmicdrift/kumiko-renderer-web";
+import { cn } from "@cosmicdrift/kumiko-renderer/web";
 import { isOneOf } from "@cosmicdrift/kumiko-types/type-guards";
 import type { Editor, JSONContent } from "@tiptap/core";
 import { EditorContent, useEditor, useEditorState } from "@tiptap/react";

package/packages/bundled-features/src/template-resolver/web/document-toolbar-blocks.ts

@@ -1,16 +1,7 @@
 // @runtime client
 import type { ContentEditorProps } from "@cosmicdrift/kumiko-renderer";
 import type { ReactNode } from "react";
-
-export type DocumentToolbarBlock =
-  | "image"
-  | "table"
-  | "button"
-  | "divider"
-  | "repeat"
-  | "pageBreak"
-  | "align"
-  | "steps";
+import type { DocumentToolbarBlock } from "../document-blocks.ts";
 
 /** Imperative access for an outside panel (placeholder list, resource list). */
 export type DocumentEditorHandle = {
@@ -50,26 +41,9 @@ export type DocumentEditorProps = ContentEditorProps & {
   readonly onEditorReady?: (handle: DocumentEditorHandle | null) => void;
 };
 
-export const MAIL_DOCUMENT_BLOCKS = [
-  "image",
-  "table",
-  "button",
-  "divider",
-  "repeat",
-  "steps",
-] as const satisfies readonly DocumentToolbarBlock[];
-
-export const PDF_DOCUMENT_BLOCKS = [
-  "align",
-  "image",
-  "table",
-  "divider",
-  "repeat",
-  "steps",
-  "pageBreak",
-] as const satisfies readonly DocumentToolbarBlock[];
-
-/** Block set for a template-resource kind; every kind except "document-pdf" gets the mail set. */
-export function documentBlocksForKind(kind: string | undefined): readonly DocumentToolbarBlock[] {
-  return kind === "document-pdf" ? PDF_DOCUMENT_BLOCKS : MAIL_DOCUMENT_BLOCKS;
-}
+export {
+  type DocumentToolbarBlock,
+  documentBlocksForKind,
+  MAIL_DOCUMENT_BLOCKS,
+  PDF_DOCUMENT_BLOCKS,
+} from "../document-blocks.ts";

package/packages/bundled-features/src/template-resolver/web/i18n.ts

@@ -80,6 +80,30 @@ export const defaultTranslations: TranslationsByLocale = {
     "templateResolver.checks.sizeUnderCap": "The mail is within the 10 MiB size limit",
     "templateResolver.checks.requiredPlaceholders": "All required placeholders are used",
     "templateResolver.errors.preview.renderFailed": "The preview could not be rendered.",
+    "templateResolver.errors.patch.unknownBlock":
+      "The block {blockId} does not exist in the template.",
+    "templateResolver.errors.patch.blockRemoved":
+      "The block {blockId} was already removed by an earlier step.",
+    "templateResolver.errors.patch.textNotFound": "The text {find} was not found in the block.",
+    "templateResolver.errors.patch.textAmbiguous":
+      "The text {find} occurs {count} times in the block; use a longer text.",
+    "templateResolver.errors.patch.blockNotAllowed":
+      "The block type {type} is not available in {kind} templates.",
+    "templateResolver.errors.patch.blockTypeMismatch":
+      "This step needs a {expected} block, but the block is a {actual}.",
+    "templateResolver.errors.patch.invalidResourceKey": "The image key {resource} is not valid.",
+    "templateResolver.errors.patch.invalidButtonHref":
+      "A button target must be a placeholder in double curly braces.",
+    "templateResolver.errors.patch.invalidVariableName": "The variable name {name} is not valid.",
+    "templateResolver.errors.patch.invalidVariableDefinition":
+      "The definition of the variable {name} is not valid.",
+    "templateResolver.errors.patch.invalidDocument":
+      "The change would produce an invalid document.",
+    "templateResolver.errors.patch.invalidMetaKey": "The meta key {key} is not allowed.",
+    "templateResolver.errors.patch.variablesDeclaredByFeature":
+      "The variables of {slug} are fixed by the application and cannot be changed.",
+    "templateResolver.errors.patch.requiredPlaceholderRemoved":
+      "The change removes required placeholders: {names}",
     "templateResolver.errors.testMail.noChannel":
       "No email channel is set up, so no test mail can be sent.",
     "templateResolver.errors.testMail.noAddress":

package/packages/bundled-features/src/template-resolver/web/placeholder-line-editor.tsx

@@ -4,17 +4,17 @@
 // (subject, preheader). The stored value stays plain text; placeholders show
 // as chips while editing. Lives in the same lazy chunk as the document editor.
 
-import { cn } from "@cosmicdrift/kumiko-renderer-web";
+import { cn } from "@cosmicdrift/kumiko-renderer/web";
 import { Extension, Node } from "@tiptap/core";
 import { Placeholder, UndoRedo } from "@tiptap/extensions";
 import { EditorContent, useEditor } from "@tiptap/react";
 import StarterKit from "@tiptap/starter-kit";
 import { type ReactNode, useMemo, useState } from "react";
 import { DocumentVariable } from "../document-schema.ts";
+import { contentToLine, lineToContent, singleLine } from "../placeholder-text.ts";
 import { createVariableView } from "./document-editor-extensions.ts";
 import type { DocumentEditorHandle } from "./document-toolbar-blocks.ts";
 import { createEditorHandle } from "./editor-handle.ts";
-import { contentToLine, lineToContent, singleLine } from "./placeholder-text.ts";
 import { useStableByKey } from "./use-stable-by-key.ts";
 
 export type PlaceholderLineEditorProps = {

package/packages/bundled-features/src/tenant/web/client-plugin.tsx

@@ -1,6 +1,6 @@
 // @runtime client
 import { mergeTranslations, type TranslationsByLocale } from "@cosmicdrift/kumiko-renderer";
-import type { ClientFeatureDefinition } from "@cosmicdrift/kumiko-renderer-web";
+import type { ClientFeatureDefinition } from "@cosmicdrift/kumiko-renderer/web";
 import {
   MEMBER_ROLES_CELL_COMPONENT,
   MEMBER_STATUS_CELL_COMPONENT,

package/packages/bundled-features/src/tenant/web/member-status-cell.tsx

@@ -5,7 +5,7 @@
 // projectionList renderer — only this one cell stays TSX.
 
 import { type ColumnRendererProps, useTranslation } from "@cosmicdrift/kumiko-renderer";
-import { StatusBadge, type StatusTone } from "@cosmicdrift/kumiko-renderer-web";
+import { StatusBadge, type StatusTone } from "@cosmicdrift/kumiko-renderer/web";
 import type { ReactNode } from "react";
 import { translateOrRaw } from "../../shared/web/translate-or-raw.ts";