A5-Greifrand an die KURZE Seite

A5 hoch (a5p) unten, A5 quer (a5l) rechts - A5 wird an der kurzen (148 mm)
Seite gegriffen. A6 und DIN lang bleiben an der langen Seite.

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

package.json

@@ -16,8 +16,10 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "basic-ftp": "^5.0.5",
     "cors": "^2.8.5",
     "dotenv": "^16.4.5",
+    "exceljs": "^4.4.0",
     "express": "^4.19.0",
     "multer": "^2.0.2",
     "pdf-lib": "^1.17.1",

src/api/controllers/batch-controller.js

@@ -0,0 +1,148 @@
+/**
+ * Batch-Bündelung (alternativer Übermittlungsweg)
+ * ---------------------------------------------------------------------------
+ * Fasst offene batch_submissions JE ZUGANG (api_client) zusammen:
+ *   • xlsx im festen Schema (Firma, Vorname, Nachname, Zeile1-3, PLZ, Stadt, Land)
+ *   • Sammel-Druck-PDF: alle mitgelieferten Druck-PDFs 1:1 aneinandergehängt
+ * und lädt beide per FTP(S) in die Wurzel des Ziel-Servers. Danach werden die
+ * Datensätze als „bundled" markiert. Text-only-Datensätze (ohne PDF) bleiben
+ * offen (für die manuelle Schreibvorlage/Plotter) und wandern NICHT ins Bündel.
+ *
+ * Ausgelöst durch: Cron (03:00 Folgetag; Sa+So gemeinsam) und den Directus-Knopf
+ * (POST /api/batch/build mit client_id = sofortige Bündelung des aktuellen Stands).
+ */
+const { Readable } = require('stream');
+const { PDFDocument } = require('pdf-lib');
+const ExcelJS = require('exceljs');
+const ftp = require('basic-ftp');
+const config = require('../../config');
+const { fetchBatchPending, markBatchBundled, fetchAssetBuffer } = require('../../services/directus-service');
+
+const XLSX_HEADER = ['Firma', 'Vorname', 'Nachname', 'Zeile1', 'Zeile2', 'Zeile3', 'PLZ', 'Stadt', 'Land'];
+
+/** Datum/Uhrzeit in Europe/Berlin (für Cron-Fenster + Dateinamen, TZ-unabhängig). */
+function berlinParts(d = new Date()) {
+  const fmt = new Intl.DateTimeFormat('en-CA', {
+    timeZone: 'Europe/Berlin', year: 'numeric', month: '2-digit', day: '2-digit',
+    hour: '2-digit', minute: '2-digit', weekday: 'short', hour12: false,
+  });
+  const p = Object.fromEntries(fmt.formatToParts(d).map((x) => [x.type, x.value]));
+  return { date: `${p.year}-${p.month}-${p.day}`, hour: parseInt(p.hour, 10), minute: parseInt(p.minute, 10), weekday: p.weekday };
+}
+/** Kalendertag (Berlin) minus N Tage → YYYY-MM-DD. Mittag-UTC vermeidet DST-Sprünge. */
+function datumMinus(dateStr, tage) {
+  const [y, m, d] = String(dateStr).split('-').map(Number);
+  return new Date(Date.UTC(y, m - 1, d - tage, 12, 0, 0)).toISOString().slice(0, 10);
+}
+
+function buildXlsx(subs) {
+  const wb = new ExcelJS.Workbook();
+  const ws = wb.addWorksheet('Empfaenger');
+  ws.addRow(XLSX_HEADER);
+  ws.getRow(1).font = { bold: true };
+  for (const s of subs) {
+    ws.addRow([s.firma || '', s.vorname || '', s.nachname || '', s.zeile1 || '', s.zeile2 || '',
+      s.zeile3 || '', s.plz || '', s.stadt || '', s.land || '']);
+  }
+  ws.columns.forEach((c) => { c.width = 18; });
+  return wb.xlsx.writeBuffer().then((ab) => Buffer.from(ab));
+}
+
+async function buildMergedPdf(subs) {
+  const merged = await PDFDocument.create();
+  let seiten = 0;
+  for (const s of subs) {
+    if (!s.pdf_file) continue;
+    try {
+      const buf = await fetchAssetBuffer(s.pdf_file);
+      const src = await PDFDocument.load(buf, { ignoreEncryption: true });
+      const pages = await merged.copyPages(src, src.getPageIndices());
+      pages.forEach((p) => merged.addPage(p));
+      seiten += pages.length;
+    } catch (e) {
+      console.error(`[batch] PDF ${s.pdf_file} (Datensatz ${s.id}) übersprungen: ${e.message}`);
+    }
+  }
+  return { bytes: Buffer.from(await merged.save()), seiten };
+}
+
+async function ftpUpload(dateien) {
+  const { host, port, user, password, secure, rejectUnauthorized } = config.ftp;
+  if (!host || !user) throw new Error('FTP nicht konfiguriert (SKRIFT_FTP_HOST/USER fehlen).');
+  // Diagnose ohne Passwort-Leak: bei „530 Login incorrect" trotz korrekter Daten
+  // ist meist die Passwort-Laenge im .env falsch (Quotes/CRLF/Leerzeichen).
+  console.log(`[batch] FTP-Login: host=${host}:${port} user="${user}" pw_len=${(password || '').length} secure=${secure}`);
+  const client = new ftp.Client(30000);
+  // client.ftp.verbose = true;
+  try {
+    await client.access({ host, port, user, password, secure, secureOptions: { rejectUnauthorized } });
+    for (const f of dateien) await client.uploadFrom(Readable.from(f.buffer), f.name);
+  } finally {
+    client.close();
+  }
+}
+
+/** Bündelt EINEN Zugang: xlsx + Sammel-PDF bauen, hochladen, Datensätze markieren. */
+async function buendleZugang(clientId, subs, label, zeitSuffix) {
+  const withPdf = subs.filter((s) => s.pdf_file);
+  if (!withPdf.length) return { client_id: clientId, count: 0, skipped: 'keine Druck-PDFs' };
+  const basis = `${clientId}_${label}${zeitSuffix ? `_${zeitSuffix}` : ''}`;
+  const xlsx = await buildXlsx(withPdf);
+  const { bytes: pdf, seiten } = await buildMergedPdf(withPdf);
+  await ftpUpload([
+    { name: `${basis}.xlsx`, buffer: xlsx },
+    { name: `${basis}.pdf`, buffer: pdf },
+  ]);
+  await markBatchBundled(withPdf.map((s) => s.id), basis);
+  console.log(`[batch] Zugang ${clientId}: ${withPdf.length} Datensätze / ${seiten} PDF-Seiten → ${basis}.{xlsx,pdf} hochgeladen.`);
+  return { client_id: clientId, count: withPdf.length, pages: seiten, file: basis };
+}
+
+/** Bündelt alle offenen Datensätze (optional nur ein Zugang), gruppiert je Zugang. */
+async function buendleAlle({ clientId = null, ids = null, label, zeitSuffix = '' }) {
+  const alle = await fetchBatchPending(clientId, ids);
+  const proZugang = new Map();
+  for (const s of alle) {
+    const k = String(s.api_client);
+    if (!proZugang.has(k)) proZugang.set(k, []);
+    proZugang.get(k).push(s);
+  }
+  const ergebnis = [];
+  for (const [k, subs] of proZugang) {
+    try { ergebnis.push(await buendleZugang(k, subs, label, zeitSuffix)); }
+    catch (e) { console.error(`[batch] Zugang ${k} fehlgeschlagen: ${e.message}`); ergebnis.push({ client_id: k, error: e.message }); }
+  }
+  return ergebnis;
+}
+
+/** HTTP: POST /api/batch/build  { client_id?, label?, time_suffix? }
+ *  Ohne client_id → alle Zugänge (wie der Cron). label default = heute (Berlin). */
+async function buildBundles(req, res) {
+  try {
+    const clientId = (req.body && req.body.client_id != null && String(req.body.client_id).trim()) ? String(req.body.client_id).trim() : null;
+    const ids = (req.body && Array.isArray(req.body.ids) && req.body.ids.length) ? req.body.ids : null;
+    const label = (req.body && req.body.label) ? String(req.body.label) : berlinParts().date;
+    // Manuelle Bündelung mit Uhrzeit-Suffix, damit sie den Cron-Tageslauf (nur Datum) nicht überschreibt.
+    const zeitSuffix = (req.body && req.body.time_suffix !== undefined)
+      ? String(req.body.time_suffix)
+      : `${String(berlinParts().hour).padStart(2, '0')}${String(berlinParts().minute).padStart(2, '0')}`;
+    const ergebnis = await buendleAlle({ clientId, ids, label, zeitSuffix });
+    return res.json({ ok: true, bundles: ergebnis });
+  } catch (err) {
+    console.error('[batch] build fehlgeschlagen:', err);
+    return res.status(500).json({ error: 'Batch-Bündelung fehlgeschlagen', message: err.message });
+  }
+}
+
+/** Cron-Lauf: alle Zugänge, Label = Vortag (Berlin). Sa+So gemeinsam am Montag,
+ *  Sonntag 03:00 wird übersprungen (Samstag wartet auf den Montagslauf). */
+async function runScheduledBatch() {
+  const { date, weekday } = berlinParts();
+  if (weekday === 'Sun') { console.log('[batch-cron] Sonntag – Samstag wird am Montag mit Sonntag gebündelt, kein Lauf.'); return; }
+  const label = datumMinus(date, 1); // Vortag (bei Montag = Sonntag; deckt Sa+So ab)
+  console.log(`[batch-cron] Start Tageslauf, Label ${label} (${weekday}).`);
+  const ergebnis = await buendleAlle({ label, zeitSuffix: '' });
+  console.log(`[batch-cron] fertig: ${ergebnis.length} Zugang/Zugänge verarbeitet.`);
+}
+
+module.exports = { buildBundles, runScheduledBatch, berlinParts };

src/api/controllers/directus-controller.js

@@ -12,11 +12,12 @@
 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
 const LETTER_FORMAT = { a4: 'a4', a6_hoch: 'a6p', a6_quer: 'a6l' };
-const ENVELOPE_FORMAT = { c6: 'c6', dinlang: 'din_lang' };
+const ENVELOPE_FORMAT = { c6: 'c6', dinlang: 'din_lang', c4: 'c4' };
 
 /** Baut den Adressblock für einen Umschlag aus einer Empfängerzeile. */
 function addressText(entry) {
@@ -31,6 +32,8 @@ function addressText(entry) {
 
 /** Platzhalterwerte einer Zeile (strukturierte Felder + freie Platzhalter). */
 function placeholdersOf(entry) {
+  // Die 5 Adresszeilen (5-Zeilen-Modus) auch als [[Zeile1]]..[[Zeile5]] verfügbar.
+  const zeilen = String(entry.free_text || '').split('\n');
   return {
     Anrede: entry.salutation || '',
     Vorname: entry.first_name || '',
@@ -40,6 +43,8 @@ function placeholdersOf(entry) {
     Ort: entry.city || '',
     Land: entry.country || '',
     Briefnummer: entry.letter_number ?? '',
+    Zeile1: zeilen[0] || '', Zeile2: zeilen[1] || '', Zeile3: zeilen[2] || '',
+    Zeile4: zeilen[3] || '', Zeile5: zeilen[4] || '',
     ...(entry.placeholders && typeof entry.placeholders === 'object' ? entry.placeholders : {}),
   };
 }
@@ -55,6 +60,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 +86,26 @@ 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 hat Vorrang; sonst Standardtext.
-      // Abweichender Text je Schriftstück (#5) 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).
+    // Ohne Brieftext KEINE Karte erzeugen – dann wird (falls gewünscht) nur das Kuvert erzeugt.
+    if (istPostkarte && String(briefText).trim()) {
+      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, fontScaleEnv, 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',
@@ -167,6 +192,9 @@ async function generateFromDirectus(req, res, next) {
         previewSession: order.preview_session || null,
         // Eingegebener Brieftext → als brieftext.txt im Ausgabeordner ablegen.
         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).
@@ -311,8 +312,9 @@ async function runGeneration({ orderNumber, letters, metadata }) {
       const filepath = isEnv ? path.join(envelopesDir, filename) : path.join(outputDir, filename);
 
       // 1:1 aus der Vorschau übernehmen, wenn für dieses Dokument eine
-      // Vorschau-Datei existiert.
+      // Vorschau-Datei existiert. Ausnahme: Kuvert mit Absender – das wird frisch
-      if (previewSession) {
+      // gerendert, damit der Absender (oben links) sicher drauf ist.
+      if (previewSession && !(isEnv && metadata.envelopeSender)) {
         const cached = path.join(previewsRoot, previewSession, filename);
         try {
           await fs.access(cached);
@@ -329,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 }
+            { 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, recipientScale: letter.fontScaleEnv || 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 }
+            { 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, recipientScale: letter.recipientScale || 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/api/routes/batch-routes.js

@@ -0,0 +1,14 @@
+const express = require('express');
+const router = express.Router();
+const { authenticateApiToken } = require('../middleware/auth');
+const batchController = require('../controllers/batch-controller');
+
+/**
+ * POST /api/batch/build
+ * Bündelt offene batch_submissions (xlsx + Sammel-Druck-PDF) und lädt sie per FTP
+ * hoch. Body: { client_id?, label?, time_suffix? }. Ohne client_id → alle Zugänge.
+ * Wird vom Directus-Knopf (ein Zugang, sofort) und intern vom Cron genutzt.
+ */
+router.post('/build', authenticateApiToken, batchController.buildBundles);
+
+module.exports = router;

src/config/index.js

@@ -55,5 +55,29 @@ module.exports = {
     clientSecret: process.env.PAYPAL_CLIENT_SECRET || '',
     // 'sandbox' oder 'live'
     environment: process.env.PAYPAL_ENVIRONMENT || 'sandbox'
-  }
+  },
+
+  // Alternativer Übermittlungsweg (batch_submissions): Ziel-FTP für die täglichen
+  // Bündel (xlsx + Sammel-Druck-PDF). Passwort NUR über ENV.
+  // envClean entfernt versehentliche umschließende Anführungszeichen und CR/LF
+  // (häufige .env-Fallen unter Windows/docker env_file), die sonst zu „530
+  // Login incorrect" führen, obwohl die Daten korrekt sind.
+  ftp: (() => {
+    const envClean = (v) => String(v || '').replace(/[\r\n]+/g, '').replace(/^(['"])([\s\S]*)\1$/, '$2');
+    // Passwoerter mit Sonderzeichen ($ # @ …) werden in .env-Dateien oft
+    // verstuemmelt ($ = Variable, # = Kommentar). Deshalb bevorzugt base64:
+    // SKRIFT_FTP_PASSWORD_B64 wird dekodiert und ist damit env-sicher.
+    const pwB64 = envClean(process.env.SKRIFT_FTP_PASSWORD_B64);
+    const password = pwB64 ? Buffer.from(pwB64, 'base64').toString('utf8') : envClean(process.env.SKRIFT_FTP_PASSWORD);
+    return {
+      host: envClean(process.env.SKRIFT_FTP_HOST),
+      port: parseInt(process.env.SKRIFT_FTP_PORT, 10) || 21,
+      user: envClean(process.env.SKRIFT_FTP_USER),
+      password,
+    // explizites FTP über TLS (wie im FTP-Client eingestellt). 'false' schaltet ab.
+    secure: String(process.env.SKRIFT_FTP_SECURE || 'true').toLowerCase() !== 'false',
+    // Selbstsigniertes Zertifikat zulassen (viele FTP-Server) – auf 'false' setzen für strikte Prüfung.
+      rejectUnauthorized: String(process.env.SKRIFT_FTP_REJECT_UNAUTHORIZED || 'false').toLowerCase() === 'true',
+    };
+  })(),
 };

src/lib/page-layout.js

@@ -6,26 +6,43 @@ const FONT_SIZE_PX = 26;
 // im Speicher gehalten (stündlich / manuell aufgefrischt via applyRenderFormats).
 // Ist Directus nicht erreichbar oder ein Format nicht hinterlegt, greifen die
 // eingebauten Defaults – die Generierung läuft also immer.
-const DEFAULT_LINE_LIMITS = { a4: 27, a6p: 14, a6l: 11 };
+const DEFAULT_LINE_LIMITS = { a4: 27, a5p: 19, a5l: 13, a6p: 14, a6l: 11, dinlang_karte: 11 };
 const DEFAULT_FORMAT_LAYOUTS = {
   a4: { marginTopMm: 25, marginLeftMm: 20, lineHeightFactor: 1.35 },
-  a6p: { marginTopMm: 8, marginLeftMm: 8, lineHeightFactor: 1.3 },
+  // A5 greift an der KURZEN (148 mm) Seite: hoch → unten, quer → rechts.
-  a6l: { marginTopMm: 8, marginLeftMm: 8, marginRightMm: 14, lineHeightFactor: 1.2 },
+  a5p: { marginTopMm: 20, marginLeftMm: 15, marginBottomMm: 14, lineHeightFactor: 1.35 },
+  a5l: { marginTopMm: 20, marginLeftMm: 15, marginRightMm: 14, lineHeightFactor: 1.35 },
+  // DIN lang greift an der langen (210 mm) Seite → unten.
+  dinlang_karte: { marginTopMm: 8, marginLeftMm: 10, marginBottomMm: 14, lineHeightFactor: 1.2 },
+  // A6-Greifrand IMMER an der langen (148 mm) Seite:
+  //  • a6p (hoch, 105×148): lange Seite = rechts  → marginRightMm (Breite)
+  //  • a6l (quer, 148×105): lange Seite = unten   → marginBottomMm (Zeilen)
+  a6p: { marginTopMm: 8, marginLeftMm: 8, marginRightMm: 14, lineHeightFactor: 1.3 },
+  a6l: { marginTopMm: 8, marginLeftMm: 8, marginBottomMm: 14, lineHeightFactor: 1.2 },
   din_lang: { marginTopMm: 50, marginLeftMm: 10, lineHeightFactor: 1.2 },
   c6: { marginTopMm: 60, marginLeftMm: 10, lineHeightFactor: 1.2 },
+  // C4 quer (Querformat-Beschriftung, maschinenseitig quer eingelegt).
+  c4: { marginTopMm: 70, marginLeftMm: 20, lineHeightFactor: 1.2 },
 };
 const DEFAULT_PAGE_FORMATS = {
   a4: { widthMm: 210, heightMm: 297 },
+  a5p: { widthMm: 148, heightMm: 210 },
+  a5l: { widthMm: 210, heightMm: 148 },
+  dinlang_karte: { widthMm: 210, heightMm: 105 },
   a6p: { widthMm: 105, heightMm: 148 },
   a6l: { widthMm: 148, heightMm: 105 },
   din_lang: { widthMm: 220, heightMm: 110 },
   c6: { widthMm: 162, heightMm: 114 },
+  c4: { widthMm: 324, heightMm: 229 },
 };
+// Art des Formats (brief/umschlag/postkarte) – steuert, WAS generiert wird.
+const DEFAULT_KINDS = { a4: 'brief', a5p: 'brief', a5l: 'brief', a6p: 'brief', a6l: 'brief', dinlang_karte: 'brief', din_lang: 'umschlag', c6: 'umschlag', c4: '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 +54,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) };
     }
@@ -51,13 +70,20 @@ function applyRenderFormats(rows) {
     };
     const mr = r.margin_right_mm ?? alt.marginRightMm;
     if (mr != null && mr !== '') layout.marginRightMm = Number(mr);
+    const mb = r.margin_bottom_mm ?? alt.marginBottomMm;
+    if (mb != null && mb !== '') layout.marginBottomMm = Number(mb);
     fl[k] = layout;
     if (r.line_limit != null && r.line_limit !== '') ll[k] = Number(r.line_limit);
   }
   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 +98,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;
+  if (!missHandler || !k) return;
-  signaledMisses.add(k);
+  // 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 */ }
 }
 
@@ -100,6 +126,7 @@ function getLayoutForFormat(format) {
     marginTopPx: mmToPx(layoutConfig.marginTopMm),
     marginLeftPx: mmToPx(layoutConfig.marginLeftMm),
     marginRightPx: layoutConfig.marginRightMm ? mmToPx(layoutConfig.marginRightMm) : null,
+    marginBottomPx: layoutConfig.marginBottomMm ? mmToPx(layoutConfig.marginBottomMm) : 0,
     lineHeightPx: FONT_SIZE_PX * layoutConfig.lineHeightFactor,
   };
 }
@@ -133,6 +160,21 @@ function getLineLimit(format) {
   return LINE_LIMITS[normalizedFormat] || LINE_LIMITS.a4;
 }
 
+// Effektives Zeilenlimit: das kleinere aus (a) konfiguriertem line_limit,
+// gegenläufig zur Schriftgröße skaliert, und (b) geometrischer Kapazität, die
+// einen unteren Greifrand (marginBottomMm) frei hält. Dadurch reserviert A6 quer
+// (marginBottomMm=14) unten Freiraum für den rollengeführten Plotter, ohne dass
+// die anderen Formate (ohne Bottom-Rand) berührt werden.
+function getEffectiveLineLimit(format, fontScale = 1) {
+  const fs = Math.max(0.8, Math.min(1.5, Number(fontScale) || 1));
+  const konfiguriert = Math.max(1, Math.round(getLineLimit(format) / fs));
+  const { heightPx } = getPageDimensions(format);
+  const { marginTopPx, marginBottomPx, lineHeightPx } = getLayoutForFormat(format);
+  const nutzbarPx = heightPx - marginTopPx - (marginBottomPx || 0);
+  const geo = Math.max(1, Math.floor(nutzbarPx / (lineHeightPx * fs)));
+  return Math.min(konfiguriert, geo);
+}
+
 module.exports = {
   PX_PER_MM,
   FONT_SIZE_PX,
@@ -140,6 +182,8 @@ module.exports = {
   getLayoutForFormat,
   getPageDimensions,
   getLineLimit,
+  getEffectiveLineLimit,
+  getFormatKind,
   escapeXml,
   applyRenderFormats,
   setFormatMissHandler,

src/lib/svg-generator.js

@@ -2,7 +2,7 @@ const {
   FONT_SIZE_PX,
   getLayoutForFormat,
   getPageDimensions,
-  getLineLimit,
+  getEffectiveLineLimit,
   escapeXml,
   mmToPx
 } = require('./page-layout');
@@ -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.
@@ -25,20 +29,39 @@ const SIG_CANVAS_H = 160;
 function buildSignatureElement(svgString, x, y, scale) {
   if (!svgString || typeof svgString !== 'string') return '';
 
-  // Nur <path>-Elemente extrahieren (unsere Signatur-SVGs enthalten ausschließlich Paths)
+  // viewBox der Signatur lesen, damit beliebige Quell-SVGs (z.B. Illustrator-
-  const pathRegex = /<path\b([^/]*)\/>/gi;
+  // Export mit eigener viewBox) korrekt normiert werden statt fix auf den
+  // 600×160-Zeichen-Canvas. Ohne viewBox: Fallback auf den Canvas (Alt-Signaturen).
+  let minx = 0;
+  let miny = 0;
+  let vh = SIG_CANVAS_H;
+  const vbM = svgString.match(/viewBox\s*=\s*"([^"]+)"/i);
+  if (vbM) {
+    const p = vbM[1].trim().split(/[\s,]+/).map(Number);
+    if (p.length === 4 && p[2] > 0 && p[3] > 0) { minx = p[0]; miny = p[1]; vh = p[3]; }
+  }
+  // Skala auf die Eigen-Höhe beziehen: Canvas-Signaturen (vh=160) unverändert,
+  // hochgeladene SVGs werden auf dieselbe Zielhöhe eingepasst.
+  const s = scale * (SIG_CANVAS_H / vh);
+
+  // Alle Zeichen-Elemente extrahieren und IMMER als Single-Stroke ausgeben:
+  // fill:none + schwarzer Stroke inline; Klasse/Style/fill/stroke/width/height
+  // entfernen. So gehen per <style>-Klasse (z.B. .cls-1) gesetzte Linien nicht
+  // verloren (sonst fällt der Pfad auf fill:black zurück und rendert gefüllt).
+  const elemRe = /<(path|polyline|line|circle|ellipse|polygon)\b([^>]*?)\/?>/gi;
   const elements = [];
   let m;
-  while ((m = pathRegex.exec(svgString)) !== null) {
+  while ((m = elemRe.exec(svgString)) !== null) {
-    // Stroke-Farbe auf Druckfarbe setzen, stroke-width relativ zur Skalierung anpassen
+    const attrs = m[2].replace(/\s(?:class|style|fill|stroke|stroke-width|width|height)\s*=\s*"[^"]*"/gi, '');
-    const attrs = m[1]
+    elements.push(`<${m[1]}${attrs} fill="none" stroke="#000000"/>`);
-      .replace(/stroke="[^"]*"/i, 'stroke="#000000"')
-      .replace(/stroke-width="[^"]*"/i, `stroke-width="${(2.5 / scale).toFixed(2)}"`);
-    elements.push(`<path${attrs}/>`);
   }
   if (!elements.length) return '';
 
-  return `<g transform="translate(${x.toFixed(1)}, ${y.toFixed(1)}) scale(${scale.toFixed(4)})">
+  // stroke-width auf der Gruppe (in Quell-Einheiten), damit nach scale ~2.5px herauskommt.
+  const sw = (2.5 / s).toFixed(2);
+  const tx = (x - minx * s).toFixed(1);
+  const ty = (y - miny * s).toFixed(1);
+  return `<g transform="translate(${tx}, ${ty}) scale(${s.toFixed(4)})" stroke-width="${sw}" stroke-linecap="round" stroke-linejoin="round">
   ${elements.join('\n  ')}
 </g>`;
 }
@@ -117,7 +140,7 @@ function generateLetterSVG(text, format, options = {}) {
       .join('\n  ');
 
     // Größere Schrift → weniger Zeilen passen aufs Blatt (Limit gegenläufig skalieren).
-    const lineLimit = Math.max(1, Math.round(getLineLimit(format) / fontScale));
+    const lineLimit = getEffectiveLineLimit(format, fontScale);
     return {
       svg: `<svg xmlns="http://www.w3.org/2000/svg"
      width="${widthMm}mm" height="${heightMm}mm"
@@ -159,7 +182,7 @@ function generateLetterSVG(text, format, options = {}) {
   const allSvgElements = [];
   let currentY = marginTopPx + fontSizePx;
   let totalLineCount = 0;
-  const lineLimit = Math.max(1, Math.round(getLineLimit(format) / fontScale));
+  const lineLimit = getEffectiveLineLimit(format, fontScale);
 
   let si = 0;
   while (si < segments.length) {
@@ -275,8 +298,15 @@ function generateEnvelopeSVG(text, format, type, options = {}) {
     startX = 0; // Dummy-Wert, wird für jede Zeile überschrieben
 
   } else {
-    // type === 'recipient' / 'free': Links, max. 60% der Umschlagsbreite
+    // type === 'recipient' / 'free'. Ist ein Absender gesetzt, sitzt der
-    const maxWidthPx = Math.min(widthPx - marginLeftPx - 20, widthPx * 0.6);
+    // Empfänger UNTEN RECHTS (klassisches Kuvert), sonst wie bisher oben links.
+    const hatAbsender = !!String(options.sender || '').trim();
+    // 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 || ''),
@@ -285,9 +315,17 @@ function generateEnvelopeSVG(text, format, type, options = {}) {
       fontSizePx,
     });
 
+    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 = startXEmpf;
+      const untenBaseline = heightPx * 0.80; // unterste Zeile ~20 % über der Unterkante
+      startY = Math.round(untenBaseline - Math.max(0, lines.length - 1) * lineHeightPx);
+    } else {
       startX = marginLeftPx;
       startY = marginTopPx + fontSizePx;
     }
+  }
 
   let paths = [];
 
@@ -328,6 +366,28 @@ function generateEnvelopeSVG(text, format, type, options = {}) {
     });
   }
 
+  // Absender oben links – nur wenn gesetzt und kein zentrierter Freitext.
+  const absender = String(options.sender || '').trim();
+  if (absender && type !== 'custom') {
+    // 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,
+      fontFileName: fontConfig.file,
+      fontSizePx: absSize,
+      // Echt oben links – unabhängig vom großen Kuvert-Rand.
+      startX: Math.round(widthPx * 0.06),
+      startY: Math.round(heightPx * 0.14),
+      lineHeightPx: absLH,
+      realisticHandwriting: options.realisticHandwriting ?? false,
+    });
+    paths = [...paths, ...absPaths];
+  }
+
   const pathElements = paths
     .map(
       (p) => `<path d="${escapeXml(p.d)}"
@@ -361,6 +421,171 @@ 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 bodyLineCount = 0;
+  let bodyLineLimit = 1;
+  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;
+  }
+
+  // Absender oben links – ZUERST, damit der Text knapp darunter beginnen kann.
+  // Größe folgt der „Absender-Größe" aus dem manuellen Druck (options.senderScale).
+  let senderBottomPx = mmToPx(2);
+  if (sender) {
+    const senderScale = Math.max(0.5, Math.min(1.8, Number(options.senderScale) || 1));
+    const senderSize = FONT_SIZE_PX * 0.55 * senderScale;
+    const senderLH = (baseLineHeightPx / FONT_SIZE_PX) * senderSize;
+    const senderLines = wrapTextToLinesByWidth({ text: sender, maxWidthPx: mmToPx(textUpperRightMm - textLeftMm), fontFileName: fontFile, fontSizePx: senderSize }).slice(0, 2);
+    const senderStartY = mmToPx(2) + senderSize;
+    paths.push(...layoutTextToPaths({
+      lines: senderLines, fontFileName: fontFile, fontSizePx: senderSize,
+      startX: mmToPx(textLeftMm), startY: senderStartY, lineHeightPx: senderLH, realisticHandwriting: realistic,
+    }));
+    senderBottomPx = senderStartY + Math.max(0, senderLines.length - 1) * senderLH + senderSize * 0.3;
+  }
+
+  // Text links (L-förmig). Beginn nur ETWAS unter dem Absender (≈2 mm); ohne
+  // Absender wie im Maßblatt bei y≈14 mm. Nur DER Text kann „zu lang" sein.
+  const baseline0 = (sender ? senderBottomPx + mmToPx(2) : mmToPx(14)) + fontSizePx;
+  bodyLineLimit = Math.max(1, Math.floor((mmToPx(maxYmm) - baseline0) / lineHeightPx) + 1);
+  if (body) {
+    const bodyLines = flowVariabel(body, fontSizePx, baseline0, lineHeightPx);
+    bodyLineCount = bodyLines.length;
+    if (bodyLineCount > bodyLineLimit) overflow = true;
+    paths.push(...layoutTextToPaths({
+      lines: bodyLines, fontFileName: fontFile, fontSizePx,
+      startX: mmToPx(textLeftMm), startY: baseline0, lineHeightPx, realisticHandwriting: realistic,
+    }));
+  }
+
+  // Empfänger im sicheren Adressfeld (rechts unten). Größe folgt der „Schriftgröße
+  // Kuvert" (options.recipientScale). Passt der Block nicht in die 46-mm-Zone, wird
+  // er automatisch verkleinert – so bleibt die Codierzone IMMER frei.
+  if (recipient) {
+    const feldOben = mmToPx(addrTopMm);
+    const feldUnten = mmToPx(maxYmm);
+    const feldBreite = mmToPx(addrRightMm - addrLeftMm);
+    const recScale = Math.max(0.6, Math.min(1.6, Number(options.recipientScale) || 1));
+    const recBaseSize = FONT_SIZE_PX * recScale;
+    const recBaseLH = baseLineHeightPx * recScale;
+    let recSize = recBaseSize;
+    let recLH = recBaseLH;
+    let recLines = [];
+    for (const scale of [1, 0.9, 0.8, 0.72, 0.65, 0.6]) {
+      recSize = recBaseSize * scale;
+      recLH = recBaseLH * scale;
+      recLines = wrapTextToLinesByWidth({ text: recipient, maxWidthPx: feldBreite, fontFileName: fontFile, fontSizePx: recSize });
+      const blockUnten = feldOben + recSize + Math.max(0, recLines.length - 1) * recLH + recSize * 0.3;
+      if (blockUnten <= feldUnten) break;
+    }
+    paths.push(...layoutTextToPaths({
+      lines: recLines, fontFileName: fontFile, fontSizePx: recSize,
+      startX: mmToPx(addrLeftMm), startY: feldOben + recSize, lineHeightPx: recLH, 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: einfache Kugelschreiber-Linie (Single-Stroke, keine Füllung) –
+  // gleiche Strichstärke wie die Handschrift, damit die Ballpoint-Optik greift.
+  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="0.6" fill="none" stroke-linecap="round" vector-effect="non-scaling-stroke"/>`;
+
+  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: bodyLineCount, lineLimit: bodyLineLimit };
+}
+
 /**
  * Mehrseitiges Schriftstück: Der Text fließt automatisch über so viele Seiten,
  * wie nötig (linesPerPage = Zeilenlimit des Formats). Ein erzwungener Umbruch ist
@@ -381,7 +606,7 @@ function generateLetterPages(text, format, options = {}) {
   const fontScale = Math.max(0.8, Math.min(1.5, Number(options.fontScale) || 1));
   const fontSizePx = FONT_SIZE_PX * fontScale;
   const lineHeightPx = baseLineHeightPx * fontScale;
-  const linesPerPage = Math.max(1, Math.round(getLineLimit(format) / fontScale));
+  const linesPerPage = getEffectiveLineLimit(format, fontScale);
 
   // Erzwungene Seitenumbrüche zuerst; danach jeden Block nach Zeilen auto-fließen.
   const bloecke = String(text || '').split(/\[\[seitenumbruch\]\]/gi);
@@ -441,7 +666,7 @@ function countLetterPages(text, format, options = {}) {
   const maxWidthPx = widthPx - marginLeftPx - (marginRightPx ?? marginLeftPx);
   const fontScale = Math.max(0.8, Math.min(1.5, Number(options.fontScale) || 1));
   const fontSizePx = FONT_SIZE_PX * fontScale;
-  const linesPerPage = Math.max(1, Math.round(getLineLimit(format) / fontScale));
+  const linesPerPage = getEffectiveLineLimit(format, fontScale);
 
   const seitenZeilen = [];
   for (const block of String(text || '').split(/\[\[seitenumbruch\]\]/gi)) {
@@ -456,6 +681,7 @@ function countLetterPages(text, format, options = {}) {
 module.exports = {
   generateLetterSVG,
   generateEnvelopeSVG,
+  generatePostcardSVG,
   generateLetterPages,
   countLetterPages
 };

src/server.js

@@ -5,7 +5,9 @@ const config = require('./config');
 const previewRoutes = require('./api/routes/preview-routes');
 const orderRoutes = require('./api/routes/order-routes');
 const chargeRoutes = require('./api/routes/charge-routes');
+const batchRoutes = require('./api/routes/batch-routes');
 const healthRoutes = require('./api/routes/health-routes');
+const { runScheduledBatch, berlinParts } = require('./api/controllers/batch-controller');
 
 const errorHandler = require('./api/middleware/error-handler');
 const requestLogger = require('./api/middleware/request-logger');
@@ -27,10 +29,11 @@ async function refreshRenderFormats() {
   }
 }
 
-// Unbekanntes Format angefragt → sofort nachladen (max. alle 30 s, damit ein
+// Unbekanntes Format angefragt → sofort nachladen (max. alle 5 s, damit ein
-// dauerhaft unbekanntes Format kein Dauerfeuer auslöst).
+// 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();
 });
@@ -48,6 +51,7 @@ app.use('/health', healthRoutes);
 app.use('/api/preview', previewRoutes);
 app.use('/api/order', orderRoutes);
 app.use('/api/charge', chargeRoutes);
+app.use('/api/batch', batchRoutes);
 
 // Format-Cache manuell auffrischen (Token-geschützt) – für „sofort übernehmen".
 app.post('/api/formats/refresh', async (req, res) => {
@@ -79,6 +83,22 @@ app.listen(config.port, () => {
   // Formate initial laden und stündlich auffrischen (zentral aus Directus).
   refreshRenderFormats();
   setInterval(refreshRenderFormats, 60 * 60 * 1000);
+
+  // Batch-FTP-Bündelung nur, wenn ausdrücklich aktiviert (Standardweg ist die
+  // Übernahme in die Produktion, nicht FTP). SKRIFT_BATCH_FTP_CRON=true schaltet
+  // den täglichen 03:00-Lauf (Europe/Berlin) wieder ein; Sa+So am Montag.
+  if (String(process.env.SKRIFT_BATCH_FTP_CRON || '').toLowerCase() === 'true') {
+    let letzterBatchTag = null;
+    setInterval(() => {
+      try {
+        const { date, hour } = berlinParts();
+        if (hour !== 3 || letzterBatchTag === date) return;
+        letzterBatchTag = date;
+        runScheduledBatch().catch((e) => console.error('[batch-cron] Fehler:', e.message));
+      } catch (e) { console.error('[batch-cron] Tick-Fehler:', e.message); }
+    }, 60 * 1000);
+    console.log('Batch-FTP-Cron:    aktiv (03:00 Europe/Berlin)');
+  }
 });
 
 // Graceful shutdown

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',
+    '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,8 +106,27 @@ 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',
   );
 }
 
-module.exports = { fetchOrder, updateOrder, addStatusHistory, fetchRenderFormats, fetchOrdersMinimal, fetchAssetBuffer };
+/** Offene (pending) Batch-Übermittlungen MIT Druck-PDF, optional je Zugang.
+ *  Text-only-Datensätze (ohne PDF) werden bewusst NICHT gebündelt. */
+async function fetchBatchPending(clientId, ids) {
+  let filter = 'filter[status][_eq]=pending&filter[pdf_file][_nnull]=true';
+  if (clientId != null) filter += `&filter[api_client][_eq]=${encodeURIComponent(clientId)}`;
+  if (Array.isArray(ids) && ids.length) filter += `&filter[id][_in]=${ids.map(encodeURIComponent).join(',')}`;
+  const fields = 'id,api_client,firma,vorname,nachname,zeile1,zeile2,zeile3,plz,stadt,land,pdf_file';
+  return (await directusFetch(`/items/batch_submissions?${filter}&sort=date_created&limit=-1&fields=${fields}`)) || [];
+}
+
+/** Markiert Datensätze als gebündelt (nach erfolgreichem FTP-Upload). */
+async function markBatchBundled(ids, bundleName) {
+  if (!ids || !ids.length) return;
+  return directusFetch('/items/batch_submissions', {
+    method: 'PATCH',
+    body: JSON.stringify({ keys: ids, data: { status: 'bundled', bundle_name: bundleName, bundled_at: new Date().toISOString() } }),
+  });
+}
+
+module.exports = { fetchOrder, updateOrder, addStatusHistory, fetchRenderFormats, fetchOrdersMinimal, fetchAssetBuffer, fetchBatchPending, markBatchBundled };

src/services/scriptalizer-service.js

@@ -141,29 +141,49 @@ async function scriptalizeBatch(texts, font = "tilda", errFrequency = 10) {
     config.scriptalizer.fontMap[font.toLowerCase()] ||
     config.scriptalizer.fontMap.tilda;
   const separator = config.scriptalizer.separator;
-  const BATCH_SIZE = 18; // 18 Texte pro Scriptalizer API Call (Scriptalizer-API-Limit: 32000 Zeichen pro Call → ca. 1700 Zeichen pro Brief sicher)
+  const BATCH_SIZE = 18; // Zusätzlicher Deckel: max. 18 Texte pro Call (unabhängig von der Länge).
+  // Primäre Grenze ist die ZEICHENLÄNGE: die Scriptalizer-API begrenzt den
+  // InputText auf 32000 Zeichen pro Call ("Input length limit 32000 exceeded").
+  // Fixe 18er-Batches sprengen das bei langen (mehrseitigen) Texten – daher nach
+  // kumulativer Länge batchen, mit Sicherheitsabstand.
+  const MAX_BATCH_CHARS = 28000;
+  const sepLen = separator.length;
 
+  // Batches nach Länge (und max. Anzahl) bilden.
+  const batches = [];
+  {
+    let cur = [];
+    let curLen = 0;
+    for (const t of texts) {
+      const tLen = String(t || "").length;
+      const projected = curLen + (cur.length ? sepLen : 0) + tLen;
+      if (cur.length && (projected > MAX_BATCH_CHARS || cur.length >= BATCH_SIZE)) {
+        batches.push(cur);
+        cur = [];
+        curLen = 0;
+      }
+      cur.push(t);
+      curLen += (cur.length > 1 ? sepLen : 0) + tLen;
+    }
+    if (cur.length) batches.push(cur);
+  }
+
+  const totalBatches = batches.length;
   console.log(
-    `[Scriptalizer] Processing ${texts.length} texts in batches of ${BATCH_SIZE}`
+    `[Scriptalizer] Processing ${texts.length} texts in ${totalBatches} batch(es) (max ${BATCH_SIZE} texts / ${MAX_BATCH_CHARS} chars each)`
   );
 
   const allScriptalized = [];
 
-  // Teile in 25er Batches auf
+  for (let b = 0; b < batches.length; b += 1) {
-  for (let i = 0; i < texts.length; i += BATCH_SIZE) {
+    const batch = batches[b];
-    const batch = texts.slice(i, i + BATCH_SIZE);
+    const batchNumber = b + 1;
-    const batchNumber = Math.floor(i / BATCH_SIZE) + 1;
+    const combinedText = batch.join(separator);
-    const totalBatches = Math.ceil(texts.length / BATCH_SIZE);
 
     console.log(
-      `[Scriptalizer] Processing batch ${batchNumber}/${totalBatches} (${
+      `[Scriptalizer] Processing batch ${batchNumber}/${totalBatches} (${batch.length} texts, ${combinedText.length} chars)`
-        batch.length
-      } texts, indices ${i}-${i + batch.length - 1})`
     );
 
-    // Kombiniere Texte mit Separator
-    const combinedText = batch.join(separator);
-
     try {
       const result = await callScriptalizer(
         combinedText,