Postkarten-Layout nach Plotter-Maßblatt (A6 Dialogpost)

Absender oben links (x2–72/y2–12), Text L-förmig links (x2–72/y14–40 +
x2–81,4/y40–88), Empfänger im sicheren Adressfeld (x86,6–146/y42–88), Trennstrich
bei x84 (1,2 mm). Frankierzone (x74–148/y0–40) und Codierzone (y90–105) bleiben
frei. Zonen an W/H verankert (auch DIN lang). Variabler L-förmiger Textfluss.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/api/controllers/directus-controller.js

@@ -12,6 +12,7 @@
 const { runGeneration } = require('./order-controller');
 const directus = require('../../services/directus-service');
 const { countLetterPages } = require('../../lib/svg-generator');
+const { getFormatKind } = require('../../lib/page-layout');
 const { replacePlaceholders } = require('../../services/placeholder-service');
 
 // Directus-Formatschlüssel → Backend-Formate
@@ -55,6 +56,9 @@ function buildDocuments(order, entries) {
   // Datei-Produkte (z. B. Unterschriftenservice): das „Schriftstück" ist das vom
   // Kunden hochgeladene Dokument – es wird NICHT generiert. Kuverts hingegen schon.
   const istDatei = order.product?.input_mode === 'datei';
+  // Postkarte: Text links, Absender+Empfänger rechts, Briefmarkenfeld frei – ein SVG
+  // je Karte (kein separater Umschlag). Erkennung über die render_format-Art.
+  const istPostkarte = getFormatKind(letterFormat) === 'postkarte';
   // Kuvert-only-Produkt: es wird KEIN Schriftstück generiert, nur die (adressierten)
   // Kuverts. Etwaige hochgeladene PDF-Briefe liegen als source_files am Auftrag.
   const istKuvertOnly = order.product?.type === 'envelope';
@@ -78,9 +82,25 @@ function buildDocuments(order, entries) {
     // Briefnummer 1 gehört. Vorschau nummeriert identisch (siehe skrift-orders).
     const nr = Number(entry.letter_number) || (i + 1);
 
-    if (!istDatei && !istKuvertOnly) {
-      // Abweichender Text je Schriftstück (#5) hat Vorrang; sonst Standardtext.
-      const briefText = (entry.text && String(entry.text).trim()) ? entry.text : (order.text_template || '');
+    // Abweichender Text je Schriftstück hat Vorrang; sonst Standardtext.
+    const briefText = (entry.text && String(entry.text).trim()) ? entry.text : (order.text_template || '');
+
+    // Postkarte: EIN Dokument mit Text + Absender + Empfänger (über Marker getrennt).
+    if (istPostkarte) {
+      const recip = addressText(entry);
+      const sender = order.envelope_sender ? String(order.envelope_sender).trim() : '';
+      let combined = String(briefText || '');
+      if (sender) combined += `[[pk_abs]]${sender}`;
+      if (recip) combined += `[[pk_adr]]${recip}`;
+      documents.push({
+        index: nr, type: 'postcard', text: combined, format: letterFormat, font,
+        placeholders, fontScale: fontScaleLetter, realisticHandwriting: realistisch,
+      });
+      return;
+    }
+
+    // Kein Schriftstück erzeugen, wenn kein Text hinterlegt ist (z. B. „nur Kuverts drucken").
+    if (!istDatei && !istKuvertOnly && String(briefText).trim()) {
       documents.push({
         index: nr,
         type: 'letter',
@@ -169,6 +189,7 @@ async function generateFromDirectus(req, res, next) {
         rawText: order.text_template || null,
         // Absender fürs Kuvert (manuelle Aufträge): oben links, Empfänger unten rechts.
         envelopeSender: order.envelope_sender || null,
+        envelopeSenderScale: Number(order.envelope_sender_scale) || 1,
       },
     });
 

src/api/controllers/order-controller.js

@@ -3,7 +3,7 @@ const fsSync = require('fs');
 const path = require('path');
 const config = require('../../config');
 const { scriptalizeBatch } = require('../../services/scriptalizer-service');
-const { generateLetterSVG, generateEnvelopeSVG, generateLetterPages } = require('../../lib/svg-generator');
+const { generateLetterSVG, generateEnvelopeSVG, generatePostcardSVG, generateLetterPages } = require('../../lib/svg-generator');
 const { replacePlaceholders, generateAllCSVs } = require('../../services/placeholder-service');
 const { TAB_MARKER } = require('../../lib/svg-font-engine');
 
@@ -220,7 +220,7 @@ async function runGeneration({ orderNumber, letters, metadata }) {
 
       for (const letter of fontLetters) {
         const raw = letter.processedText;
-        const parts = raw.split(/(\t|\[\[signatur\d+\]\]|\[\[seitenumbruch\]\]|[&|])/gi);
+        const parts = raw.split(/(\t|\[\[signatur\d+\]\]|\[\[seitenumbruch\]\]|\[\[pk_abs\]\]|\[\[pk_adr\]\]|[&|])/gi);
         const segments = [], markers = [];
         for (let i = 0; i < parts.length; i++) {
           if (i % 2 === 0) segments.push(parts[i]);
@@ -272,6 +272,7 @@ async function runGeneration({ orderNumber, letters, metadata }) {
       const letter = processedLetters[i];
       const absoluteIndex = letter.index !== undefined ? letter.index : i;
       const isEnv = letter.type === 'envelope';
+      const isPostcard = letter.type === 'postcard';
       const pad = String(absoluteIndex).padStart(3, '0');
 
       // Mehrseitiger Brief → N Seiten-Dateien letter_NNN_pM.svg (Seite 1..N).
@@ -330,7 +331,12 @@ async function runGeneration({ orderNumber, letters, metadata }) {
         if (isEnv) {
           svgResult = generateEnvelopeSVG(
             scriptalizedText, letter.format, letter.envelopeType,
-            { font: letter.font, realisticHandwriting: letter.realisticHandwriting ?? false, fontScale: letter.fontScale, sender: metadata.envelopeSender || '' }
+            { font: letter.font, realisticHandwriting: letter.realisticHandwriting ?? false, fontScale: letter.fontScale, sender: metadata.envelopeSender || '', senderScale: metadata.envelopeSenderScale || 1 }
+          );
+        } else if (isPostcard) {
+          svgResult = generatePostcardSVG(
+            scriptalizedText, letter.format,
+            { font: letter.font, realisticHandwriting: letter.realisticHandwriting ?? false, fontScale: letter.fontScale, senderScale: metadata.envelopeSenderScale || 1 }
           );
         } else {
           svgResult = generateLetterSVG(

src/api/controllers/preview-controller.js

@@ -7,6 +7,7 @@ const { scriptalizeBatch } = require("../../services/scriptalizer-service");
 const {
   generateLetterSVG,
   generateEnvelopeSVG,
+  generatePostcardSVG,
   generateLetterPages,
 } = require("../../lib/svg-generator");
 const {
@@ -101,7 +102,7 @@ async function generateBatch(req, res, next) {
     for (const letter of processedLetters) {
       const raw = letter.processedText;
       // Splitten an \t UND [[signaturN]] (mit capture-Gruppe → Marker bleiben erhalten)
-      const parts = raw.split(/(\t|\[\[signatur\d+\]\]|\[\[seitenumbruch\]\]|[&|])/gi);
+      const parts = raw.split(/(\t|\[\[signatur\d+\]\]|\[\[seitenumbruch\]\]|\[\[pk_abs\]\]|\[\[pk_adr\]\]|[&|])/gi);
       const segments = [], markers = [];
       for (let i = 0; i < parts.length; i++) {
         if (i % 2 === 0) segments.push(parts[i]);
@@ -167,7 +168,7 @@ async function generateBatch(req, res, next) {
         if (letter.type === "envelope") {
           const svgResult = generateEnvelopeSVG(
             scriptalizedText, letter.format, letter.envelopeType,
-            { font: letter.font, realisticHandwriting: letter.realisticHandwriting ?? false, fontScale: letter.fontScale, sender: letter.sender || '' }
+            { font: letter.font, realisticHandwriting: letter.realisticHandwriting ?? false, fontScale: letter.fontScale, sender: letter.sender || '', senderScale: letter.senderScale || 1 }
           );
           if (svgResult.overflow) hasOverflow = true;
           const filename = `envelope_${pad}.svg`;
@@ -177,6 +178,19 @@ async function generateBatch(req, res, next) {
             lineCount: svgResult.lineCount, lineLimit: svgResult.lineLimit, overflow: svgResult.overflow,
             recipientName: null,
           });
+        } else if (letter.type === "postcard") {
+          const svgResult = generatePostcardSVG(scriptalizedText, letter.format, {
+            font: letter.font, realisticHandwriting: letter.realisticHandwriting ?? false,
+            fontScale: letter.fontScale, senderScale: letter.senderScale || 1,
+          });
+          if (svgResult.overflow) hasOverflow = true;
+          const filename = `letter_${pad}.svg`;
+          await fs.writeFile(path.join(sessionDir, filename), svgResult.svg, "utf8");
+          files.push({
+            index: absoluteIndex, filename, url: `/api/preview/${finalSessionId}/${filename}`,
+            lineCount: svgResult.lineCount, lineLimit: svgResult.lineLimit, overflow: svgResult.overflow,
+            recipientName,
+          });
         } else if (letter.multiPage) {
           // Mehrseitiger Brief: Text fließt über N Seiten – kein Überlauf-Fehler.
           const { pages } = generateLetterPages(scriptalizedText, letter.format, {

src/lib/page-layout.js

@@ -21,11 +21,14 @@ const DEFAULT_PAGE_FORMATS = {
   din_lang: { widthMm: 220, heightMm: 110 },
   c6: { widthMm: 162, heightMm: 114 },
 };
+// Art des Formats (brief/umschlag/postkarte) – steuert, WAS generiert wird.
+const DEFAULT_KINDS = { a4: 'brief', a6p: 'brief', a6l: 'brief', din_lang: 'umschlag', c6: 'umschlag' };
 
 // Live-Cache (wird von applyRenderFormats ersetzt). Start = Defaults.
 let LINE_LIMITS = { ...DEFAULT_LINE_LIMITS };
 let FORMAT_LAYOUTS = { ...DEFAULT_FORMAT_LAYOUTS };
 let PAGE_FORMATS = { ...DEFAULT_PAGE_FORMATS };
+let KINDS = { ...DEFAULT_KINDS };
 
 /**
  * Übernimmt Format-Definitionen aus Directus (render_formats) in den Cache.
@@ -37,9 +40,11 @@ function applyRenderFormats(rows) {
   const pf = { ...DEFAULT_PAGE_FORMATS };
   const fl = { ...DEFAULT_FORMAT_LAYOUTS };
   const ll = { ...DEFAULT_LINE_LIMITS };
+  const kn = { ...DEFAULT_KINDS };
   for (const r of Array.isArray(rows) ? rows : []) {
     const k = String(r.key || '').toLowerCase();
     if (!k) continue;
+    if (r.kind) kn[k] = String(r.kind).toLowerCase();
     if (r.page_width_mm && r.page_height_mm) {
       pf[k] = { widthMm: Number(r.page_width_mm), heightMm: Number(r.page_height_mm) };
     }
@@ -57,7 +62,12 @@ function applyRenderFormats(rows) {
   PAGE_FORMATS = pf;
   FORMAT_LAYOUTS = fl;
   LINE_LIMITS = ll;
-  signaledMisses.clear();
+  KINDS = kn;
+}
+
+// Art eines Formats (brief/umschlag/postkarte). Unbekannt → 'brief'.
+function getFormatKind(format) {
+  return KINDS[String(format).toLowerCase()] || 'brief';
 }
 
 // mm in Pixel umrechnen
@@ -72,12 +82,12 @@ function mmToPx(mm) {
 // stündliche Aktualisierung abzuwarten. Für DIESEN Aufruf greift noch der
 // Default – der nächste Aufruf hat das Format.
 let missHandler = null;
-const signaledMisses = new Set();
 function setFormatMissHandler(fn) { missHandler = fn; }
 function signalMiss(key) {
   const k = String(key || '').toLowerCase();
-  if (!missHandler || !k || signaledMisses.has(k)) return;
-  signaledMisses.add(k);
+  if (!missHandler || !k) return;
+  // Kein „schon gemeldet"-Merker mehr: sonst blieb ein Key hängen, wenn die
+  // Nachlade-Drossel gerade griff. Die Drossel im Handler verhindert Dauerfeuer.
   try { missHandler(k); } catch { /* egal */ }
 }
 
@@ -140,6 +150,7 @@ module.exports = {
   getLayoutForFormat,
   getPageDimensions,
   getLineLimit,
+  getFormatKind,
   escapeXml,
   applyRenderFormats,
   setFormatMissHandler,

src/lib/svg-generator.js

@@ -18,6 +18,10 @@ const {
 const SIG_CANVAS_W = 600;
 const SIG_CANVAS_H = 160;
 
+// Mindestabstand des Adressblocks zum rechten Rand (mm). Der Plotter braucht rechts
+// Greiffläche – gilt einheitlich für Postkarte UND Umschlag-Empfänger (mit Absender).
+const RAND_RECHTS_MM = 15;
+
 /**
  * Extrahiert Path- und Polyline-Elemente aus einem SVG-String und gibt sie als
  * umgeformte <g>-Gruppe zurück, die an Position (x, y) mit Skalierung scale eingebettet ist.
@@ -297,7 +301,12 @@ function generateEnvelopeSVG(text, format, type, options = {}) {
     // type === 'recipient' / 'free'. Ist ein Absender gesetzt, sitzt der
     // Empfänger UNTEN RECHTS (klassisches Kuvert), sonst wie bisher oben links.
     const hatAbsender = !!String(options.sender || '').trim();
-    const maxWidthPx = Math.min(widthPx - marginLeftPx - 20, widthPx * (hatAbsender ? 0.36 : 0.6));
+    // Empfänger unten rechts (mit Absender): Startpunkt zuerst festlegen, dann die
+    // Textbreite so begrenzen, dass rechts der Plotter-Mindestabstand frei bleibt.
+    const startXEmpf = Math.round(widthPx * 0.55);
+    const maxWidthPx = hatAbsender
+      ? Math.max(mmToPx(30), (widthPx - mmToPx(RAND_RECHTS_MM)) - startXEmpf)
+      : Math.min(widthPx - marginLeftPx - 20, widthPx * 0.6);
 
     lines = wrapTextToLinesByWidth({
       text: String(text || ''),
@@ -309,7 +318,7 @@ function generateEnvelopeSVG(text, format, type, options = {}) {
     if (hatAbsender) {
       // Empfänger unten rechts – bewusst über Höhen-/Breiten-Anteile, damit der
       // große Kuvert-Rand (marginTop bis ~50 % der Höhe) nicht alles nach oben zieht.
-      startX = Math.round(widthPx * 0.60);
+      startX = startXEmpf;
       const untenBaseline = heightPx * 0.80; // unterste Zeile ~20 % über der Unterkante
       startY = Math.round(untenBaseline - Math.max(0, lines.length - 1) * lineHeightPx);
     } else {
@@ -357,11 +366,14 @@ function generateEnvelopeSVG(text, format, type, options = {}) {
     });
   }
 
-  // Absender oben links (kleiner) – nur wenn gesetzt und kein zentrierter Freitext.
+  // Absender oben links – nur wenn gesetzt und kein zentrierter Freitext.
   const absender = String(options.sender || '').trim();
   if (absender && type !== 'custom') {
-    const absSize = fontSizePx * 0.62;
-    const absLH = lineHeightPx * 0.62;
+    // Eigene Absender-Größe (Prozent, 1 = 100%). Grundgröße = Empfänger-Grundschrift
+    // (früher fix 0.62 → zu klein). Über options.senderScale prozentual einstellbar.
+    const senderScale = Math.max(0.5, Math.min(2, Number(options.senderScale) || 1));
+    const absSize = FONT_SIZE_PX * senderScale;
+    const absLH = lineHeightPx * (absSize / fontSizePx);
     const absLines = absender.split('\n').map((l) => l.replace(/\s+$/, ''));
     const absPaths = layoutTextToPaths({
       lines: absLines,
@@ -409,6 +421,146 @@ function generateEnvelopeSVG(text, format, type, options = {}) {
   return { svg: svg.trim(), overflow: lineCount > lineLimit, lineCount, lineLimit };
 }
 
+// Postkarten-Marker: teilen den (bereits scriptalisierten) Text in Body/Absender/
+// Empfänger. Werden in der Scriptalisierung wie [[signaturN]] als Marker erhalten.
+const PK_ABS = '[[pk_abs]]';
+const PK_ADR = '[[pk_adr]]';
+function splitPostcardText(text) {
+  let rest = String(text || '');
+  let recipient = '';
+  let sender = '';
+  const iAdr = rest.indexOf(PK_ADR);
+  if (iAdr >= 0) { recipient = rest.slice(iAdr + PK_ADR.length); rest = rest.slice(0, iAdr); }
+  const iAbs = rest.indexOf(PK_ABS);
+  if (iAbs >= 0) { sender = rest.slice(iAbs + PK_ABS.length); rest = rest.slice(0, iAbs); }
+  return { body: rest.trim(), sender: sender.trim(), recipient: recipient.trim() };
+}
+
+/**
+ * Postkarte (einseitig) nach dem Plotter-Maßblatt (Dialogpost A6, Ursprung oben
+ * links, Maße in mm):
+ *   • Absender:  x 2–72,  y 2–12   (2 Zeilen, klein)
+ *   • Text:      x 2–72,  y 14–40  (oben, schmal, links neben der Frankierzone)
+ *          und  x 2–81,4, y 40–88  (unten, breiter) – L-förmiger Textfluss
+ *   • Empfänger: x 86,6–146, y 42–88  (sicheres Adressfeld)
+ *   • Trennstrich: x 84, y 42–88, Breite 1,2 mm
+ *   • FREI: Frankierzone (x 74–148, y 0–40) und Codierzone (y 90–105)
+ * Andere Kartengrößen: Zonen an W/H verankert (Adresse rechts, Text links,
+ * Frankierzone rechts oben, Codierzone unten frei). Text kommt scriptalisiert
+ * mit den Markern [[pk_abs]] / [[pk_adr]].
+ */
+function generatePostcardSVG(text, format, options = {}) {
+  const fontKey = normalizeFontKey(options.font);
+  const fontFile = SVG_FONT_CONFIG[fontKey].file;
+  const realistic = options.realisticHandwriting ?? false;
+
+  const { widthPx, heightPx, widthMm: W, heightMm: H } = getPageDimensions(format);
+  const { lineHeightPx: baseLineHeightPx } = getLayoutForFormat(format);
+
+  const { body, sender, recipient } = splitPostcardText(text);
+
+  const fontScale = Math.max(0.8, Math.min(1.5, Number(options.fontScale) || 1));
+  const fontSizePx = FONT_SIZE_PX * fontScale;
+  const lineHeightPx = baseLineHeightPx * fontScale;
+
+  // Zonen in mm (Maßblatt), für andere Größen an den Rändern verankert.
+  const maxYmm = H - 17;                          // Codierzone (unten 15 mm) frei → A6: 88
+  const frankBottomMm = 40;                        // Frankierzone-Unterkante (Briefmarke)
+  const frankLeftMm = W - 74;                      // Frankierzone links → A6: 74
+  const addrRightMm = W - 2;                       // A6: 146
+  const addrLeftMm = addrRightMm - 59.4;           // A6: 86,6
+  const addrTopMm = 42;
+  const textLeftMm = 2;
+  const textUpperRightMm = frankLeftMm - 2;        // A6: 72
+  const textLowerRightMm = addrLeftMm - 5.2;       // A6: 81,4
+  const trennXmm = (textLowerRightMm + addrLeftMm) / 2; // A6: 84
+
+  const paths = [];
+  let overflow = false;
+
+  // Variabler (L-förmiger) Textfluss: oben schmal (bis Frankierzone), unten breit.
+  const breiteBeiY = (yPx) => (yPx < mmToPx(frankBottomMm)
+    ? mmToPx(textUpperRightMm - textLeftMm)
+    : mmToPx(textLowerRightMm - textLeftMm));
+  function flowVariabel(txt, size, baseline0, lh) {
+    const paras = String(txt).split(/\r?\n/);
+    const out = [];
+    let y = baseline0;
+    for (const para of paras) {
+      const words = para.split(/\s+/).filter(Boolean);
+      if (!words.length) { out.push(''); y += lh; continue; }
+      let cur = '';
+      for (const w of words) {
+        const test = cur ? cur + ' ' + w : w;
+        const wpx = measureTextWidthPx({ text: test, fontFileName: fontFile, fontSizePx: size });
+        if (cur && wpx > breiteBeiY(y)) { out.push(cur); y += lh; cur = w; } else cur = test;
+      }
+      if (cur !== '') { out.push(cur); y += lh; }
+    }
+    return out;
+  }
+
+  // Text links (L-förmig).
+  if (body) {
+    const baseline0 = mmToPx(14) + fontSizePx;
+    const bodyLines = flowVariabel(body, fontSizePx, baseline0, lineHeightPx);
+    const letzteBaseline = baseline0 + Math.max(0, bodyLines.length - 1) * lineHeightPx;
+    if (letzteBaseline > mmToPx(maxYmm)) overflow = true;
+    paths.push(...layoutTextToPaths({
+      lines: bodyLines, fontFileName: fontFile, fontSizePx,
+      startX: mmToPx(textLeftMm), startY: baseline0, lineHeightPx, realisticHandwriting: realistic,
+    }));
+  }
+
+  // Absender oben links (2 Zeilen), klein genug für die 10-mm-Zone.
+  if (sender) {
+    const senderSize = FONT_SIZE_PX * 0.55 * Math.max(0.7, Math.min(1.2, Number(options.senderScale) || 1));
+    const senderLH = (baseLineHeightPx / FONT_SIZE_PX) * senderSize;
+    const senderLines = wrapTextToLinesByWidth({ text: sender, maxWidthPx: mmToPx(textUpperRightMm - textLeftMm), fontFileName: fontFile, fontSizePx: senderSize }).slice(0, 2);
+    paths.push(...layoutTextToPaths({
+      lines: senderLines, fontFileName: fontFile, fontSizePx: senderSize,
+      startX: mmToPx(textLeftMm), startY: mmToPx(2) + senderSize, lineHeightPx: senderLH, realisticHandwriting: realistic,
+    }));
+  }
+
+  // Empfänger im sicheren Adressfeld (rechts unten).
+  if (recipient) {
+    const recLines = wrapTextToLinesByWidth({ text: recipient, maxWidthPx: mmToPx(addrRightMm - addrLeftMm), fontFileName: fontFile, fontSizePx });
+    const recBaseline0 = mmToPx(addrTopMm) + fontSizePx;
+    if (recBaseline0 + Math.max(0, recLines.length - 1) * lineHeightPx > mmToPx(maxYmm)) overflow = true;
+    paths.push(...layoutTextToPaths({
+      lines: recLines, fontFileName: fontFile, fontSizePx,
+      startX: mmToPx(addrLeftMm), startY: recBaseline0, lineHeightPx, realisticHandwriting: realistic,
+    }));
+  }
+
+  const pathElements = paths
+    .map((p) => `<path d="${escapeXml(p.d)}"
+        transform="${p.transform}"
+        stroke="#000000"
+        stroke-width="0.6"
+        fill="none"
+        stroke-linecap="round"
+        stroke-linejoin="round"
+        vector-effect="non-scaling-stroke"
+      />`)
+    .join('\n  ');
+
+  // Trennstrich (solide Linie, 1,2 mm breit) zwischen Text und Adressfeld.
+  const trennstrich = `<path d="M ${mmToPx(trennXmm).toFixed(1)} ${mmToPx(addrTopMm).toFixed(1)} L ${mmToPx(trennXmm).toFixed(1)} ${mmToPx(maxYmm).toFixed(1)}" stroke="#000000" stroke-width="${mmToPx(1.2).toFixed(1)}" stroke-linecap="butt" fill="none"/>`;
+
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg"
+     width="${W}mm"
+     height="${H}mm"
+     viewBox="0 0 ${widthPx} ${heightPx}">
+  <rect x="0" y="0" width="${widthPx}" height="${heightPx}" fill="#FFFFFF" />
+  ${trennstrich}
+  ${pathElements}
+</svg>`;
+
+  return { svg: svg.trim(), overflow, lineCount: 0, lineLimit: 0 };
+}
+
 /**
  * Mehrseitiges Schriftstück: Der Text fließt automatisch über so viele Seiten,
  * wie nötig (linesPerPage = Zeilenlimit des Formats). Ein erzwungener Umbruch ist
@@ -504,6 +656,7 @@ function countLetterPages(text, format, options = {}) {
 module.exports = {
   generateLetterSVG,
   generateEnvelopeSVG,
+  generatePostcardSVG,
   generateLetterPages,
   countLetterPages
 };

src/server.js

@@ -27,10 +27,11 @@ async function refreshRenderFormats() {
   }
 }
 
-// Unbekanntes Format angefragt → sofort nachladen (max. alle 30 s, damit ein
-// dauerhaft unbekanntes Format kein Dauerfeuer auslöst).
+// Unbekanntes Format angefragt → sofort nachladen (max. alle 5 s, damit ein
+// dauerhaft unbekanntes Format kein Dauerfeuer auslöst). Neu in Directus angelegte
+// Formate sind damit ohne Backend-Neustart binnen weniger Sekunden aktiv.
 setFormatMissHandler((key) => {
-  if (Date.now() - lastFormatRefresh < 30 * 1000) return;
+  if (Date.now() - lastFormatRefresh < 5 * 1000) return;
   console.log(`[Formate] Unbekanntes Format "${key}" angefragt – lade Formate nach.`);
   refreshRenderFormats();
 });

src/services/directus-service.js

@@ -41,7 +41,7 @@ async function directusFetch(path, options = {}) {
 async function fetchOrder(orderId) {
   const fields = [
     'id', 'order_number', 'customer_email', 'font', 'status',
-    'needs_envelope', 'envelope_labeling', 'envelope_text', 'envelope_format', 'envelope_sender',
+    'needs_envelope', 'envelope_labeling', 'envelope_text', 'envelope_format', 'envelope_sender', 'envelope_sender_scale',
     'text_template', 'motif_mode', 'own_cards', 'entries_count', 'preview_session',
     'source_file', 'product.key', 'product.type', 'product.input_mode', 'format.key',
     'font_scale_letter', 'font_scale_envelope', 'signatures_manual', 'multi_page', 'realistic',
@@ -106,7 +106,7 @@ async function fetchAssetBuffer(fileId) {
 async function fetchRenderFormats() {
   return directusFetch(
     '/items/render_formats?filter[active][_eq]=true&limit=-1' +
-    '&fields=key,page_width_mm,page_height_mm,margin_top_mm,margin_left_mm,margin_right_mm,line_height_factor,line_limit',
+    '&fields=key,kind,page_width_mm,page_height_mm,margin_top_mm,margin_left_mm,margin_right_mm,line_height_factor,line_limit',
   );
 }