@cosmicdrift/kumiko-document-designer 0.389.0 → 0.390.0

package/dist/web/use-mail-editor-parts.d.ts

@@ -0,0 +1,42 @@
+import type { EditorMode } from "./editor-header.tsx";
+import type { ConfirmDialog } from "./mail-dialogs.tsx";
+import type { MailEditorBodyProps } from "./mail-editor-logic.ts";
+export declare function useMailUiState(row: MailEditorBodyProps["row"]): {
+    baseline: import("./mail-types.ts").MailDraft;
+    draft: import("./mail-types.ts").MailDraft;
+    setDraft: import("react").Dispatch<import("react").SetStateAction<import("./mail-types.ts").MailDraft>>;
+    settled: import("./mail-types.ts").MailDraft;
+    settle: (next: import("./mail-types.ts").MailDraft) => void;
+    mode: EditorMode;
+    setMode: import("react").Dispatch<import("react").SetStateAction<EditorMode>>;
+    creating: boolean;
+    setCreating: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    dialog: ConfirmDialog;
+    setDialog: import("react").Dispatch<import("react").SetStateAction<ConfirmDialog>>;
+    uploadOpen: boolean;
+    setUploadOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    pdfOpen: boolean;
+    setPdfOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    resourceError: string | null;
+    setResourceError: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    resetError: string | null;
+    setResetError: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    editorEpoch: number;
+    setEditorEpoch: import("react").Dispatch<import("react").SetStateAction<number>>;
+    includeAttachments: boolean;
+    setIncludeAttachments: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    prefixSubject: boolean;
+    setPrefixSubject: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+};
+export type MailUiState = ReturnType<typeof useMailUiState>;
+export type MailServices = ReturnType<typeof useMailServices>;
+export declare function useMailServices(props: MailEditorBodyProps): {
+    insert: import("./use-insert-targets.ts").InsertTargets;
+    persistence: import("./use-mail-persistence.ts").MailPersistence;
+    testMail: import("./use-test-mail.ts").TestMail;
+    own: import("./use-own-address.ts").OwnAddress;
+    filesAvailable: boolean;
+    resourceRemove: import("@cosmicdrift/kumiko-renderer").UseMutationResult<unknown>;
+    layouts: import("./use-overview-rows.ts").OverviewRows;
+    pdfTemplates: import("./use-overview-rows.ts").OverviewRows;
+};

package/dist/web/use-mail-editor-parts.js

@@ -0,0 +1,74 @@
+import { TemplateResolverHandlers } from "@cosmicdrift/kumiko-bundled-features/template-resolver/web";
+import { useMutation } from "@cosmicdrift/kumiko-renderer";
+import { useState } from "react";
+import { loadedMailOf } from "./mail-draft.js";
+import { useFilesCapability } from "./use-files-capability.js";
+import { useInsertTargets } from "./use-insert-targets.js";
+import { useMailPersistence } from "./use-mail-persistence.js";
+import { useOverviewRows } from "./use-overview-rows.js";
+import { useOwnAddress } from "./use-own-address.js";
+import { useSettledValue } from "./use-settled-value.js";
+import { useTestMail } from "./use-test-mail.js";
+export function useMailUiState(row) {
+    const [baseline] = useState(() => loadedMailOf(row));
+    const [draft, setDraft] = useState(baseline);
+    const [settled, settle] = useSettledValue(baseline);
+    const [mode, setMode] = useState("edit");
+    const [creating, setCreating] = useState(false);
+    const [dialog, setDialog] = useState({ kind: "none" });
+    const [uploadOpen, setUploadOpen] = useState(false);
+    const [pdfOpen, setPdfOpen] = useState(false);
+    const [resourceError, setResourceError] = useState(null);
+    const [resetError, setResetError] = useState(null);
+    const [editorEpoch, setEditorEpoch] = useState(0);
+    const [includeAttachments, setIncludeAttachments] = useState(true);
+    const [prefixSubject, setPrefixSubject] = useState(true);
+    return {
+        baseline,
+        draft,
+        setDraft,
+        settled,
+        settle,
+        mode,
+        setMode,
+        creating,
+        setCreating,
+        dialog,
+        setDialog,
+        uploadOpen,
+        setUploadOpen,
+        pdfOpen,
+        setPdfOpen,
+        resourceError,
+        setResourceError,
+        resetError,
+        setResetError,
+        editorEpoch,
+        setEditorEpoch,
+        includeAttachments,
+        setIncludeAttachments,
+        prefixSubject,
+        setPrefixSubject,
+    };
+}
+export function useMailServices(props) {
+    const { slug, locale, title, isSystemAdmin, row } = props;
+    const insert = useInsertTargets();
+    const persistence = useMailPersistence({ slug, locale, title, isSystemAdmin, row });
+    const testMail = useTestMail();
+    const own = useOwnAddress();
+    const filesAvailable = useFilesCapability();
+    const resourceRemove = useMutation(TemplateResolverHandlers.resourceRemove);
+    const layouts = useOverviewRows("mail-layout");
+    const pdfTemplates = useOverviewRows("document-pdf");
+    return {
+        insert,
+        persistence,
+        testMail,
+        own,
+        filesAvailable,
+        resourceRemove,
+        layouts,
+        pdfTemplates,
+    };
+}

package/dist/web/use-mail-editor-state.d.ts

@@ -0,0 +1,89 @@
+import type { MailEditorBodyProps } from "./mail-editor-logic.ts";
+import type { MailValidation, PickedValues } from "./mail-types.ts";
+type Translate = (key: string, params?: Readonly<Record<string, unknown>>) => string;
+export declare function useMailEditorState(props: MailEditorBodyProps, t: Translate): {
+    update: (patch: Partial<import("./mail-types.ts").MailDraft>) => void;
+    reset: () => void;
+    saveAndReload: (publish: boolean) => Promise<void>;
+    perform: (target: import("./mail-dialogs.tsx").LeaveTarget) => void;
+    leave: (target: import("./mail-dialogs.tsx").LeaveTarget) => void;
+    leaveSave: (target: import("./mail-dialogs.tsx").LeaveTarget) => Promise<void>;
+    removeResource: (key: string) => Promise<void>;
+    sendTestMail: () => void;
+    ui: {
+        baseline: import("./mail-types.ts").MailDraft;
+        draft: import("./mail-types.ts").MailDraft;
+        setDraft: import("react").Dispatch<import("react").SetStateAction<import("./mail-types.ts").MailDraft>>;
+        settled: import("./mail-types.ts").MailDraft;
+        settle: (next: import("./mail-types.ts").MailDraft) => void;
+        mode: import("./editor-header.tsx").EditorMode;
+        setMode: import("react").Dispatch<import("react").SetStateAction<import("./editor-header.tsx").EditorMode>>;
+        creating: boolean;
+        setCreating: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+        dialog: import("./mail-dialogs.tsx").ConfirmDialog;
+        setDialog: import("react").Dispatch<import("react").SetStateAction<import("./mail-dialogs.tsx").ConfirmDialog>>;
+        uploadOpen: boolean;
+        setUploadOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+        pdfOpen: boolean;
+        setPdfOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+        resourceError: string | null;
+        setResourceError: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+        resetError: string | null;
+        setResetError: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+        editorEpoch: number;
+        setEditorEpoch: import("react").Dispatch<import("react").SetStateAction<number>>;
+        includeAttachments: boolean;
+        setIncludeAttachments: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+        prefixSubject: boolean;
+        setPrefixSubject: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    };
+    services: {
+        insert: import("./use-insert-targets.ts").InsertTargets;
+        persistence: import("./use-mail-persistence.ts").MailPersistence;
+        testMail: import("./use-test-mail.ts").TestMail;
+        own: import("./use-own-address.ts").OwnAddress;
+        filesAvailable: boolean;
+        resourceRemove: import("@cosmicdrift/kumiko-renderer").UseMutationResult<unknown>;
+        layouts: import("./use-overview-rows.ts").OverviewRows;
+        pdfTemplates: import("./use-overview-rows.ts").OverviewRows;
+    };
+    validation: MailValidation | null;
+    picked: Readonly<Record<string, unknown>> | null;
+    setPicked: (next: PickedValues | null) => void;
+    pickedVariables: Readonly<Record<string, unknown>> | null;
+    variableSchema: Readonly<Record<string, unknown>>;
+    locked: boolean;
+    dirty: boolean;
+    busy: boolean;
+    canSave: boolean;
+    canPublish: boolean;
+    resources: readonly import("./mail-types.ts").LinkedResourceView[];
+    pdfTitles: Map<string, string>;
+    uploadTemplateId: string | null;
+    takenKeys: string[];
+    attachments: ({
+        readonly kind: "file";
+        readonly key: string;
+        readonly fileRefId: string;
+        readonly fileName: string;
+    } | {
+        readonly kind: "pdf";
+        readonly key: string;
+        readonly templateSlug: string;
+        readonly fileName: string;
+    })[];
+    resourcePreviews: {
+        [k: string]: {
+            src: string;
+            caption: string;
+        };
+    };
+    railValidation: MailValidation | null;
+    vocabulary: import("./mail-edit-center.tsx").EditorVocabulary;
+    footer: {
+        readonly tone: "bad" | "warn" | "ok";
+        readonly text: string;
+    } | null;
+    fieldErrors: Partial<Record<"previewText" | "subject", string>>;
+};
+export {};

package/dist/web/use-mail-editor-state.js

@@ -0,0 +1,55 @@
+import { TemplateResolverQueries } from "@cosmicdrift/kumiko-bundled-features/template-resolver/web";
+import { useQuery, useUnsavedInputSource } from "@cosmicdrift/kumiko-renderer";
+import { useEffect, useRef, useState } from "react";
+import { buildMeta, isDraftDirty, parseJsonRecord, pickDeclaredVariables } from "./mail-draft.js";
+import { buildMailModel } from "./mail-editor-model.js";
+import { useMailServices, useMailUiState } from "./use-mail-editor-parts.js";
+export function useMailEditorState(props, t) {
+    const { slug, locale, isSystemAdmin, row } = props;
+    const ui = useMailUiState(row);
+    const [picked, setPicked] = useState(null);
+    const services = useMailServices(props);
+    const locked = row === null && !ui.creating;
+    const variableSchema = parseJsonRecord(row?.variableSchema);
+    const validation = useQuery(TemplateResolverQueries.validate, {
+        slug,
+        kind: "mail",
+        contentFormat: "html",
+        content: ui.settled.body,
+        meta: buildMeta(ui.settled),
+        variableSchema,
+        locale,
+        scope: isSystemAdmin ? "system" : "tenant",
+    }).data;
+    const pickedVariables = pickDeclaredVariables(picked, validation?.variables);
+    // A pick belongs to the variables it was made for: after the declared set changes it is dropped,
+    // so a re-added variable does not revive an old record value.
+    const declaredVariables = validation?.variables;
+    const declaredVariableNames = declaredVariables === undefined ? null : Object.keys(declaredVariables).sort().join("|");
+    const previousDeclaredNames = useRef(declaredVariableNames);
+    useEffect(() => {
+        // skip: validation has not loaded, so there is no declared set to compare
+        if (declaredVariableNames === null)
+            return;
+        if (previousDeclaredNames.current !== null &&
+            previousDeclaredNames.current !== declaredVariableNames) {
+            setPicked(null);
+        }
+        previousDeclaredNames.current = declaredVariableNames;
+    }, [declaredVariableNames]);
+    const dirty = isDraftDirty(ui.draft, ui.baseline);
+    useUnsavedInputSource(() => dirty);
+    return buildMailModel({
+        props,
+        t,
+        ui,
+        picked,
+        setPicked,
+        services,
+        validation,
+        variableSchema,
+        pickedVariables,
+        locked,
+        dirty,
+    });
+}

package/dist/web/use-pdf-editor-state.d.ts

@@ -0,0 +1,77 @@
+import type { EditorMode } from "./editor-header.tsx";
+import { type EditorState, type GeneratedPdf } from "./pdf-editor-draft.ts";
+import { type PuppeteerStatus, type TemplateDetail, type TemplateListRow, type TemplateScope, type TenantOverrides, type ValidationResult } from "./types.ts";
+type Translate = (key: string, params?: Readonly<Record<string, unknown>>) => string;
+export declare function usePdfEditorState(input: {
+    readonly slug: string;
+    readonly requestedLocale: string | undefined;
+}, t: Translate): {
+    host: {
+        insert: import("./use-insert-targets.ts").InsertTargets;
+        filesAvailable: boolean;
+        overview: import("./use-overview-rows.ts").OverviewRows;
+        scope: TemplateScope;
+    };
+    doc: {
+        rowsQuery: import("@cosmicdrift/kumiko-renderer").UseQueryResult<readonly TemplateListRow[]>;
+        locales: readonly string[];
+        locale: string;
+        row: TemplateListRow | undefined;
+        detailQuery: import("@cosmicdrift/kumiko-renderer").UseQueryResult<TemplateDetail | null>;
+        detail: TemplateDetail | null;
+        setState: import("react").Dispatch<import("react").SetStateAction<EditorState | null>>;
+        current: EditorState | null;
+    };
+    settleTimer: import("react").RefObject<NodeJS.Timeout | null>;
+    ui: {
+        overridesOpen: boolean;
+        setOverridesOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+        draftEpoch: number;
+        setDraftEpoch: import("react").Dispatch<import("react").SetStateAction<number>>;
+        mode: EditorMode;
+        setMode: import("react").Dispatch<import("react").SetStateAction<EditorMode>>;
+        busy: "pdf" | "publish" | "save" | null;
+        setBusy: import("react").Dispatch<import("react").SetStateAction<"pdf" | "publish" | "save" | null>>;
+        actionError: string | null;
+        setActionError: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+        generated: GeneratedPdf | null;
+        setGenerated: import("react").Dispatch<import("react").SetStateAction<GeneratedPdf | null>>;
+        autoPrintedFor: import("react").RefObject<string | null>;
+        pendingLocale: string | null;
+        setPendingLocale: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    };
+    server: {
+        variableSchema: Record<string, unknown>;
+        validationQuery: import("@cosmicdrift/kumiko-renderer").UseQueryResult<ValidationResult>;
+        validation: ValidationResult | null;
+        layout: {
+            readonly slug: string;
+            readonly scope: TemplateScope;
+            readonly html: string;
+            readonly regions: import("./types.ts").LayoutRegionsHtml;
+        } | null;
+        layouts: import("./use-overview-rows.ts").OverviewRows;
+        brandingLogoFile: string;
+        statusQuery: import("@cosmicdrift/kumiko-renderer").UseQueryResult<PuppeteerStatus>;
+        showOrigin: boolean;
+        overridesQuery: import("@cosmicdrift/kumiko-renderer").UseQueryResult<TenantOverrides>;
+    };
+    vocabulary: {
+        variables: Readonly<Record<string, import("./mail-types.ts").MailVariable>>;
+        imageVariables: string[];
+        systemVariables: readonly string[];
+        systemLabels: Readonly<Record<string, string>>;
+        variableLabels: {
+            [x: string]: string;
+        };
+        variableNames: string[];
+        resourcePreviews: {
+            [k: string]: {
+                src: string;
+                caption: string;
+            };
+        };
+    };
+};
+export type PdfEditorState = ReturnType<typeof usePdfEditorState>;
+export {};

package/dist/web/use-pdf-editor-state.js

@@ -0,0 +1,161 @@
+import { TemplateResolverQueries } from "@cosmicdrift/kumiko-bundled-features/template-resolver/web";
+import { useQuery, useUserRoles } from "@cosmicdrift/kumiko-renderer";
+import { RendererPuppeteerClientQueries } from "@cosmicdrift/kumiko-renderer-puppeteer-client/qualified-names";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { BRANDING_QUERY_QN } from "./constants.js";
+import { systemLabelMap, variableLabelMap } from "./mail-draft.js";
+import { draftFromDetail, imageLabelSource, NO_VARIABLES, snapshotOf, textVariablesOf, } from "./pdf-editor-draft.js";
+import { visibleSystemPlaceholders } from "./pdf-left-rail.js";
+import { serializePdfMeta } from "./pdf-meta.js";
+import { localesOf, parseJsonObject, pickRow, resolveLocale } from "./template-rows.js";
+import { DOCUMENT_PDF_KIND, PDF_LAYOUT_KIND, } from "./types.js";
+import { useFilesCapability } from "./use-files-capability.js";
+import { useInsertTargets } from "./use-insert-targets.js";
+import { useOverviewRows } from "./use-overview-rows.js";
+function usePdfHostServices() {
+    const insert = useInsertTargets();
+    const filesAvailable = useFilesCapability();
+    const overview = useOverviewRows(DOCUMENT_PDF_KIND);
+    const roles = useUserRoles();
+    const scope = roles?.includes("SystemAdmin") === true ? "system" : "tenant";
+    return { insert, filesAvailable, overview, scope };
+}
+function usePdfDocument(slug, requestedLocale, scope) {
+    const rowsQuery = useQuery(TemplateResolverQueries.list, {
+        kind: DOCUMENT_PDF_KIND,
+    });
+    const rows = rowsQuery.data ?? [];
+    const locales = localesOf(rows, slug);
+    const locale = resolveLocale(requestedLocale, locales);
+    const row = pickRow(rows, slug, locale, scope);
+    const detailQuery = useQuery(TemplateResolverQueries.findById, { id: row?.id ?? "" }, { enabled: row !== undefined });
+    // useQuery keeps the previous key's data while the next one loads, so a scope or locale
+    // switch would otherwise hand the old row to save and publish.
+    const detail = row !== undefined && detailQuery.data?.id === row.id ? detailQuery.data : null;
+    const [state, setState] = useState(null);
+    if (detail !== null && (state === null || state.key !== detail.id)) {
+        const draft = draftFromDetail(detail);
+        setState({ key: detail.id, draft, settled: draft, snapshot: snapshotOf(draft) });
+    }
+    const current = state !== null && detail !== null && state.key === detail.id ? state : null;
+    return { rowsQuery, locales, locale, row, detailQuery, detail, setState, current };
+}
+function useSettleTimer() {
+    const settleTimer = useRef(null);
+    // A pending settle must not fire into an unmounted editor.
+    useEffect(() => () => {
+        if (settleTimer.current !== null)
+            clearTimeout(settleTimer.current);
+    }, []);
+    return settleTimer;
+}
+function usePdfUiState() {
+    const [overridesOpen, setOverridesOpen] = useState(false);
+    const [draftEpoch, setDraftEpoch] = useState(0);
+    const [mode, setMode] = useState("edit");
+    const [busy, setBusy] = useState(null);
+    const [actionError, setActionError] = useState(null);
+    const [generated, setGenerated] = useState(null);
+    const autoPrintedFor = useRef(null);
+    const [pendingLocale, setPendingLocale] = useState(null);
+    return {
+        overridesOpen,
+        setOverridesOpen,
+        draftEpoch,
+        setDraftEpoch,
+        mode,
+        setMode,
+        busy,
+        setBusy,
+        actionError,
+        setActionError,
+        generated,
+        setGenerated,
+        autoPrintedFor,
+        pendingLocale,
+        setPendingLocale,
+    };
+}
+function usePdfServerQueries(input) {
+    const { slug, scope } = input;
+    const { locale, detail, current } = input.doc;
+    const variableSchema = useMemo(() => parseJsonObject(detail?.variableSchema ?? null), [detail?.variableSchema]);
+    const settledMeta = current === null ? null : serializePdfMeta(current.settled.meta);
+    const validationQuery = useQuery(TemplateResolverQueries.validate, {
+        slug,
+        kind: DOCUMENT_PDF_KIND,
+        contentFormat: "html",
+        content: current?.settled.content ?? "",
+        meta: settledMeta ?? {},
+        variableSchema,
+        locale,
+        scope,
+    }, { enabled: current !== null });
+    const validation = validationQuery.data;
+    const layoutSlug = current?.settled.meta.layoutSlug ?? "";
+    const previewQuery = useQuery(TemplateResolverQueries.preview, {
+        slug,
+        kind: DOCUMENT_PDF_KIND,
+        locale,
+        content: detail?.content ?? "",
+        meta: layoutSlug === "" ? {} : { layoutSlug },
+        variableSchema,
+    }, { enabled: detail !== null });
+    const layout = previewQuery.error === null ? (previewQuery.data?.layout ?? null) : null;
+    const layouts = useOverviewRows(PDF_LAYOUT_KIND);
+    // The built-in "logo" resource of a layout is the tenant's branding logo.
+    const branding = useQuery(BRANDING_QUERY_QN, {});
+    const brandingLogoFile = branding.data?.logoFile ?? "";
+    const statusQuery = useQuery(RendererPuppeteerClientQueries.status, {});
+    const showOrigin = scope === "system";
+    const overridesQuery = useQuery(TemplateResolverQueries.tenantOverrides, { slug, kind: DOCUMENT_PDF_KIND, locale }, { enabled: showOrigin && detail !== null });
+    return {
+        variableSchema,
+        validationQuery,
+        validation,
+        layout,
+        layouts,
+        brandingLogoFile,
+        statusQuery,
+        showOrigin,
+        overridesQuery,
+    };
+}
+function usePdfVocabulary(t, validation, detail) {
+    const allVariables = validation?.variables ?? NO_VARIABLES;
+    // Photos are record data, never an inline placeholder: images variables only feed the Images block.
+    const variables = useMemo(() => textVariablesOf(allVariables), [allVariables]);
+    const imageVariables = useMemo(() => Object.keys(allVariables).filter((name) => allVariables[name]?.type === "images"), [allVariables]);
+    const systemVariables = useMemo(() => visibleSystemPlaceholders(validation?.systemPlaceholders ?? []), [validation?.systemPlaceholders]);
+    const systemLabels = useMemo(() => systemLabelMap(t, systemVariables), [t, systemVariables]);
+    const variableLabels = useMemo(() => ({
+        ...systemLabels,
+        ...variableLabelMap(t, variables),
+        ...variableLabelMap(t, imageLabelSource(allVariables)),
+    }), [systemLabels, variables, allVariables, t]);
+    const variableNames = useMemo(() => Object.keys(variables), [variables]);
+    const linkedResources = detail?.linkedResources ?? null;
+    // The editor shows resource images from the stored copies; no extra request is made here.
+    const resourcePreviews = useMemo(() => Object.fromEntries(Object.entries(parseJsonObject(linkedResources)).flatMap(([key, fileRefId]) => typeof fileRefId === "string"
+        ? [[key, { src: `/api/files/${encodeURIComponent(fileRefId)}`, caption: key }]]
+        : [])), [linkedResources]);
+    return {
+        variables,
+        imageVariables,
+        systemVariables,
+        systemLabels,
+        variableLabels,
+        variableNames,
+        resourcePreviews,
+    };
+}
+export function usePdfEditorState(input, t) {
+    const { slug, requestedLocale } = input;
+    const host = usePdfHostServices();
+    const doc = usePdfDocument(slug, requestedLocale, host.scope);
+    const settleTimer = useSettleTimer();
+    const ui = usePdfUiState();
+    const server = usePdfServerQueries({ slug, scope: host.scope, doc });
+    const vocabulary = usePdfVocabulary(t, server.validation, doc.detail);
+    return { host, doc, settleTimer, ui, server, vocabulary };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-document-designer",
-  "version": "0.389.0",
+  "version": "0.390.0",
   "description": "Document designer for Kumiko: template overview, layout editor (mail layout, PDF letterhead) and the PDF template editor.",
   "license": "MIT",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -20,11 +20,11 @@
     "./web/styles.css": "./src/web/styles.css"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-bundled-features": "0.389.0",
-    "@cosmicdrift/kumiko-framework": "0.389.0",
-    "@cosmicdrift/kumiko-renderer": "0.389.0",
-    "@cosmicdrift/kumiko-renderer-puppeteer-client": "0.389.0",
-    "@cosmicdrift/kumiko-types": "0.389.0",
+    "@cosmicdrift/kumiko-bundled-features": "0.390.0",
+    "@cosmicdrift/kumiko-framework": "0.390.0",
+    "@cosmicdrift/kumiko-renderer": "0.390.0",
+    "@cosmicdrift/kumiko-renderer-puppeteer-client": "0.390.0",
+    "@cosmicdrift/kumiko-types": "0.390.0",
     "react": "^19.2.6"
   },
   "devDependencies": {

package/src/changes.json

@@ -1,4 +1,22 @@
 [
+  {
+    "version": "0.390.0",
+    "type": "improvement",
+    "title": "PDF editor actions drop unreachable null checks",
+    "detail": "generatePdf, printOnce and the save path of the PDF template editor no longer check for a missing editor state; the editor only builds its actions once the state is loaded, and the type already excludes null. A new test pins the publishSystem path for a SystemAdmin who holds a clean tenant template."
+  },
+  {
+    "version": "0.390.0",
+    "type": "fix",
+    "title": "The PDF editor no longer saves or publishes the previous row after a scope switch",
+    "detail": "When the host scope changed while the editor was open, for example once the SystemAdmin role loaded, the editor kept showing the tenant copy until the system row arrived. Save then wrote the tenant content as the system template, and publish sent the tenant row to publishSystem. The editor now shows the loading state until the detail of the newly picked row has loaded."
+  },
+  {
+    "version": "0.390.0",
+    "type": "improvement",
+    "title": "Split PDF, layout and mail editors into hooks and render functions",
+    "detail": "PdfTemplateEditor, LayoutEditorBody and MailEditorBody compose focused state hooks, pure logic modules and render functions for chrome, panes and previews. Rendered markup and behavior are unchanged."
+  },
   {
     "version": "0.389.0",
     "type": "fix",