Textmengencheck ohne Abfragelimit

generatePreview aus /textmenge sendet check:true -> Backend rendert unbegrenzt
und ohne Vorschau-Kontingent-Verbrauch.

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

src/App.tsx

@@ -7,6 +7,8 @@ import Auftraege from './routes/Auftraege';
 import Stammdaten from './routes/Stammdaten';
 import Configurator from './routes/Configurator';
 import MusterSeite from './routes/Muster';
+import AngebotSeite from './routes/Angebot';
+import FreigabeSeite from './routes/Freigabe';
 import Textmenge from './routes/Textmenge';
 import { loadSession } from './lib/api';
 
@@ -36,8 +38,11 @@ export default function App() {
           <Routes>
             <Route path="/" element={<Configurator />} />
             <Route path="/login" element={<Login />} />
-            {/* Muster als eigene Seite (kein Popup) – Direktlink /muster. */}
+            {/* Muster & individuelles Angebot als eigene Seiten (kein Popup). */}
             <Route path="/muster" element={<MusterSeite />} />
+            <Route path="/angebot" element={<AngebotSeite />} />
+            {/* Motiv-Freigabe über Einmal-Link (kein Login nötig). */}
+            <Route path="/freigabe/:token" element={<FreigabeSeite />} />
             {/* Textmengen-Tool – öffentlich, Direktlink /textmenge. */}
             <Route path="/textmenge" element={<Textmenge />} />
             <Route

src/components/AppShell.tsx

@@ -180,7 +180,7 @@ function Angebot({ onClose, vorbelegung }: { onClose: () => void; vorbelegung?:
 export function Muster({ onClose = () => {}, variant = 'dialog' }: { onClose?: () => void; variant?: 'dialog' | 'page' }) {
   const [produkte, setProdukte] = useState<Product[]>([]);
   const [form, setForm] = useState({
-    product: '', name: '', email: '', phone: '',
+    product: '', first_name: '', last_name: '', email: '', phone: '',
     street: '', zip: '', city: '', country: 'Deutschland', message: '',
   });
   const [datenschutz, setDatenschutz] = useState(false);
@@ -195,7 +195,8 @@ export function Muster({ onClose = () => {}, variant = 'dialog' }: { onClose?: (
       fetchMyCustomer()
         .then((c) => c && setForm((f) => ({
           ...f,
-          name: [c.first_name, c.last_name].filter(Boolean).join(' ') || f.name,
+          first_name: c.first_name || f.first_name,
+          last_name: c.last_name || f.last_name,
           email: c.email || f.email,
           phone: c.phone || f.phone,
         })))
@@ -216,7 +217,8 @@ export function Muster({ onClose = () => {}, variant = 'dialog' }: { onClose?: (
     try {
       await sendSampleRequest({
         product: form.product,
-        name: form.name.trim(),
+        first_name: form.first_name.trim(),
+        last_name: form.last_name.trim(),
         email: form.email.trim(),
         phone: form.phone.trim() || undefined,
         street: form.street.trim(),
@@ -259,7 +261,7 @@ export function Muster({ onClose = () => {}, variant = 'dialog' }: { onClose?: (
     </div>
   );
 
-  const gueltig = form.product && form.name.trim() && istEmail(form.email) && form.phone.trim()
+  const gueltig = form.product && form.first_name.trim() && form.last_name.trim() && istEmail(form.email) && form.phone.trim()
     && form.street.trim() && form.zip.trim() && form.city.trim() && datenschutz;
 
   return wrap('Muster bestellen', (
@@ -275,12 +277,13 @@ export function Muster({ onClose = () => {}, variant = 'dialog' }: { onClose?: (
             {produkte.map((p) => <option key={p.key} value={p.key}>{p.name}</option>)}
           </select>
         </div>
-        {feld('name', 'Name')}
+        {feld('first_name', 'Vorname')}
+        {feld('last_name', 'Nachname')}
         {feld('email', 'E-Mail-Adresse', false, 'email')}
         {feld('phone', 'Telefon', false, 'tel')}
         {feld('street', 'Straße und Hausnummer')}
         {feld('zip', 'PLZ')}
-        {feld('city', 'Stadt')}
+        {feld('city', 'Ort')}
         <div className="sk-field">
           <label className="sk-label sk-label--required" htmlFor="m-country">Land</label>
           <select id="m-country" className="sk-input" value={form.country} onChange={set('country')}>
@@ -398,10 +401,10 @@ function Sidebar({ onNavigate }: { onNavigate?: () => void }) {
           <IconMail />
           <span>Muster bestellen</span>
         </NavLink>
-        <button className="sk-nav-item sk-nav-item--quiet" onClick={() => { open('angebot'); onNavigate?.(); }}>
+        <NavLink to="/angebot" className="sk-nav-item sk-nav-item--quiet" onClick={onNavigate}>
           <IconOffer />
           <span>Individuelles Angebot</span>
-        </button>
+        </NavLink>
         <button className="sk-nav-item sk-nav-item--quiet" onClick={() => { open('hilfe'); onNavigate?.(); }}>
           <IconHelp />
           <span>Hilfe</span>

src/components/OfferForm.tsx

@@ -15,7 +15,7 @@ const istEmail = (e: string) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(e.trim());
  */
 export default function OfferForm({ produkt, onClose }: { produkt?: string; onClose?: () => void }) {
   const gewaehltesProdukt = produkt?.trim() || '';
-  const [form, setForm] = useState({ name: '', email: '', phone: '', quantity: '', message: '' });
+  const [form, setForm] = useState({ first_name: '', last_name: '', email: '', phone: '', quantity: '', message: '' });
   const [datenschutz, setDatenschutz] = useState(false);
   const [status, setStatus] = useState<'formular' | 'sendet' | 'fertig'>('formular');
   const [fehler, setFehler] = useState<string[]>([]);
@@ -28,7 +28,8 @@ export default function OfferForm({ produkt, onClose }: { produkt?: string; onCl
         if (!c) return;
         setForm((f) => ({
           ...f,
-          name: [c.first_name, c.last_name].filter(Boolean).join(' ') || f.name,
+          first_name: c.first_name || f.first_name,
+          last_name: c.last_name || f.last_name,
           email: c.email || f.email,
           phone: c.phone || f.phone,
         }));
@@ -49,7 +50,8 @@ export default function OfferForm({ produkt, onClose }: { produkt?: string; onCl
     setStatus('sendet');
     try {
       await sendOfferRequest({
-        name: form.name.trim(),
+        first_name: form.first_name.trim(),
+        last_name: form.last_name.trim(),
         email: form.email.trim(),
         phone: form.phone.trim() || undefined,
         quantity: form.quantity ? Number(form.quantity) : null,
@@ -90,8 +92,12 @@ export default function OfferForm({ produkt, onClose }: { produkt?: string; onCl
       )}
       <form style={{ marginTop: 'var(--sk-space-4)' }} onSubmit={absenden}>
         <div className="sk-field">
-          <label className="sk-label" htmlFor="a-name">Name</label>
-          <input id="a-name" className="sk-input" value={form.name} onChange={set('name')} required />
+          <label className="sk-label" htmlFor="a-vorname">Vorname</label>
+          <input id="a-vorname" className="sk-input" value={form.first_name} onChange={set('first_name')} required />
+        </div>
+        <div className="sk-field">
+          <label className="sk-label" htmlFor="a-nachname">Nachname</label>
+          <input id="a-nachname" className="sk-input" value={form.last_name} onChange={set('last_name')} required />
         </div>
         <div className="sk-field">
           <label className="sk-label" htmlFor="a-mail">E-Mail</label>

src/lib/api.ts

@@ -232,7 +232,13 @@ export type Product = {
   input_mode: 'text' | 'datei';
 };
 
-export type Format = { id: number; key: string; name: string; product: number };
+export type Format = {
+  id: number; key: string; name: string; product: number;
+  /** Familie fürs Ausrichtungs-Dropdown (z. B. A5, A6). Leer = eigener Eintrag. */
+  family?: string | null;
+  /** Ausrichtung innerhalb der Familie. Leer = keine Wahl. */
+  orientation?: 'hoch' | 'quer' | null;
+};
 
 /**
  * Produkt-Schlüssel, die für den angemeldeten Kunden individuell freigeschaltet
@@ -268,6 +274,31 @@ export async function fetchFormats(): Promise<Format[]> {
   return data?.data ?? [];
 }
 
+/**
+ * Formate für den Textmengencheck: alle mit show_check=true. Das sind die
+ * Text-Seiten-Formate (A4, A5, DIN lang, A6) – unabhängig davon, ob sie im
+ * öffentlichen Konfigurator bestellbar sind. Adress-Postkarten sind ausgenommen.
+ */
+export async function fetchCheckFormats(): Promise<Format[]> {
+  const felder = 'fields=id,key,name,product,family,orientation';
+  try {
+    const data = await request(
+      `/items/formats?${felder}&filter[show_check][_eq]=true&limit=-1`,
+      { auth: false },
+    );
+    const rows: Format[] = data?.data ?? [];
+    if (rows.length) return rows;
+  } catch {
+    /* Feld show_check evtl. noch nicht angelegt → Fallback unten. */
+  }
+  // Fallback (z. B. vor dem Directus-Bootstrap): aktive Formate, damit der Check nutzbar bleibt.
+  const aktiv = await request(
+    `/items/formats?${felder}&filter[active][_eq]=true&limit=-1`,
+    { auth: false },
+  );
+  return aktiv?.data ?? [];
+}
+
 /* ── Preis & Bestellung (Extension skrift-orders) ─────────────────────────── */
 
 export type QuoteLine = { label: string; amount: number; per_unit?: boolean };
@@ -296,11 +327,33 @@ export type QuoteInput = {
   email?: string;
   /** Segment für den Mengen-Multiplikator (B2B/B2C). */
   person_type?: 'privat' | 'unternehmen';
+  /** Gewähltes Kundenangebot (ID) – Aufschläge werden serverseitig addiert. */
+  offer?: number;
 };
 
-/** Preis serverseitig berechnen lassen – der Client rechnet nie selbst. */
+/** Preis serverseitig berechnen lassen – der Client rechnet nie selbst.
+ *  auth:true, damit bei eingeloggten Kunden der Token mitgeht (Kundenangebote). */
 export async function fetchQuote(input: QuoteInput): Promise<Quote> {
-  return request('/skrift-orders/quote', { method: 'POST', body: input, auth: false });
+  return request('/skrift-orders/quote', { method: 'POST', body: input, auth: true });
+}
+
+/* ── Kundenangebote (customer_offers) ───────────────────────────────────────── */
+
+export type OfferSurcharge = { label: string; amount: number };
+export type CustomerOffer = {
+  id: number;
+  label: string;
+  name_suffix?: string | null;
+  note?: string | null;
+  allow_multi_page?: boolean;
+  surcharges?: OfferSurcharge[] | null;
+  product?: { key: string; name: string } | null;
+};
+
+/** Angebote des eingeloggten Kunden für ein Produkt (leer, wenn nicht eingeloggt). */
+export async function fetchMyOffers(productKey: string): Promise<CustomerOffer[]> {
+  const data = await request(`/skrift-orders/my-offers?product=${encodeURIComponent(productKey)}`, { auth: true });
+  return data?.offers ?? [];
 }
 
 /* ── Motive ───────────────────────────────────────────────────────────────── */
@@ -372,6 +425,8 @@ export type PreviewInput = {
   realistic?: boolean;
   envelope_labeling?: string;
   envelope_text?: string;
+  /** Textmengencheck: unbegrenzt, ohne Vorschau-Kontingent. */
+  check?: boolean;
   entries: unknown[];
 };
 
@@ -420,6 +475,8 @@ export type OrderInput = {
   voucher_code?: string;
   payment_method: 'paypal' | 'rechnung';
   source?: string;
+  /** Gewähltes Kundenangebot (ID). */
+  offer?: number;
   entries: unknown[];
   /** Motiv aus dem Katalog (ID) bzw. hochgeladene Datei (Directus-Datei-ID). */
   motif?: number;
@@ -436,7 +493,9 @@ export type OrderResult = {
 };
 
 export async function createOrder(input: OrderInput): Promise<OrderResult> {
-  return request('/skrift-orders', { method: 'POST', body: input, auth: false });
+  // auth:true → eingeloggte Kunden senden ihren Token (Kundenangebote greifen);
+  // Gäste haben keine Session → kein Header, Verhalten wie zuvor.
+  return request('/skrift-orders', { method: 'POST', body: input, auth: true });
 }
 
 /** Vermerkt eine erfolgreiche PayPal-Zahlung am Auftrag. */
@@ -501,7 +560,8 @@ export async function uploadFile(datei: File): Promise<string> {
 /* ── Angebotsanfrage ──────────────────────────────────────────────────────── */
 
 export type OfferRequest = {
-  name: string;
+  first_name: string;
+  last_name: string;
   email: string;
   phone?: string;
   quantity?: number | null;
@@ -518,7 +578,8 @@ export async function sendOfferRequest(input: OfferRequest) {
 
 export type SampleRequest = {
   product: string;
-  name: string;
+  first_name: string;
+  last_name: string;
   email: string;
   phone?: string;
   street: string;
@@ -532,6 +593,29 @@ export async function sendSampleRequest(input: SampleRequest) {
   return request('/skrift-orders/sample-request', { method: 'POST', body: input, auth: false });
 }
 
+/* ── Motiv-Freigabe (öffentlich, per Einmal-Token) ─────────────────────────── */
+
+export type Freigabe = {
+  order_number: string;
+  product: string;
+  status: 'pending' | 'approved' | 'changes' | string;
+  note: string;
+  has_layout: boolean;
+};
+
+export async function fetchFreigabe(token: string): Promise<Freigabe> {
+  return request(`/skrift-orders/freigabe/${encodeURIComponent(token)}`, { auth: false });
+}
+
+export async function sendFreigabe(token: string, action: 'approve' | 'changes', note?: string) {
+  return request(`/skrift-orders/freigabe/${encodeURIComponent(token)}`, { method: 'POST', body: { action, note }, auth: false });
+}
+
+/** Direkte URL zum A6-Entwurfs-SVG (Token-gated, kein Login nötig). */
+export function freigabeLayoutUrl(token: string) {
+  return `${BASE}/skrift-orders/freigabe/${encodeURIComponent(token)}/layout`;
+}
+
 /* ── Statusverlauf & Benachrichtigungen ───────────────────────────────────── */
 
 export type StatusEvent = {

src/routes/Angebot.tsx

@@ -0,0 +1,13 @@
+import { useNavigate } from 'react-router-dom';
+import OfferForm from '../components/OfferForm';
+
+/** Individuelles Angebot als eigene Seite (Direktlink /angebot) – kein Popup. */
+export default function AngebotSeite() {
+  const navigate = useNavigate();
+  return (
+    <div className="sk-view">
+      <h1>Individuelles Angebot anfordern</h1>
+      <OfferForm onClose={() => navigate('/')} />
+    </div>
+  );
+}

src/routes/Configurator.tsx

@@ -12,6 +12,7 @@ import {
   fetchPriceItems,
   fetchProducts,
   fetchQuote,
+  fetchMyOffers,
   fetchSettings,
   generatePreview,
   validateText,
@@ -26,6 +27,7 @@ import {
   type Product,
   type PublicSettings,
   type Quote,
+  type CustomerOffer,
 } from '../lib/api';
 import { ladePayPal, rendereButtons } from '../lib/paypal';
 import { ladeVorlageHerunter, leseEmpfaengerDatei } from '../lib/excel';
@@ -42,8 +44,10 @@ const PRODUKT_TEXT: Record<string, string> = {
   follow_ups: 'Automatisierte handschriftliche Nachfass-Mailings für mehr Rücklauf.',
 };
 
-/** Standard-Platzhalter der strukturierten Adresse (werden automatisch befüllt). */
-const STANDARD_STRUKTUR = ['Anrede', 'Vorname', 'Nachname', 'Strasse', 'PLZ', 'Ort', 'Land'];
+/** Standard-Platzhalter der strukturierten Adresse (werden automatisch befüllt).
+ *  Ohne „Anrede" – dafür gibt es kein Empfängerfeld; als [[Anrede]] ist es ein
+ *  frei befüllbarer eigener Platzhalter. */
+const STANDARD_STRUKTUR = ['Vorname', 'Nachname', 'Strasse', 'PLZ', 'Ort', 'Land'];
 /** Standard-Platzhalter der Freitext-Adresse. */
 const STANDARD_FREITEXT = ['Zeile1', 'Zeile2', 'Zeile3', 'Zeile4', 'Zeile5'];
 
@@ -302,6 +306,7 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
 
   const [motifMode, setMotifMode] = useState<MotifMode>(entwurf.motifMode ?? 'katalog');
   const [motifs, setMotifs] = useState<Motif[]>([]);
+  const [motifeGeladen, setMotifeGeladen] = useState(false);
   const [motifId, setMotifId] = useState<number | null>(entwurf.motifId ?? null);
   // Gestaltungsservice ist jetzt eine der sich gegenseitig ausschließenden
   // Motiv-Optionen – daher abgeleitet, kein eigener Zustand mehr.
@@ -336,6 +341,9 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
 
   const [quote, setQuote] = useState<Quote | null>(null);
   const [quoteFehler, setQuoteFehler] = useState<string | null>(null);
+  // Kundenangebote (customer_offers) für den eingeloggten Kunden + das Produkt.
+  const [offers, setOffers] = useState<CustomerOffer[]>([]);
+  const [offerId, setOfferId] = useState<number | null>(null);
 
   const [previewDocs, setPreviewDocs] = useState<PreviewDoc[]>([]);
   const [previewLaedt, setPreviewLaedt] = useState(false);
@@ -352,7 +360,7 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
 
   const [sendet, setSendet] = useState(false);
   const [bestellFehler, setBestellFehler] = useState<string[]>([]);
-  const [bestellung, setBestellung] = useState<{ nummer: string; zahlung: string; bezahlt: boolean; extern?: boolean } | null>(null);
+  const [bestellung, setBestellung] = useState<{ nummer: string; zahlung: string; bezahlt: boolean; betrag: number; extern?: boolean } | null>(null);
 
   const [settings, setSettings] = useState<PublicSettings | null>(null);
   const [preisKatalog, setPreisKatalog] = useState<Record<string, PriceItem>>({});
@@ -396,7 +404,7 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
 
     // … Motive, Einstellungen und Preise dagegen optional. Sie dürfen den
     // Konfigurator nicht blockieren, wenn Felder fehlen (z. B. vor dem Bootstrap).
-    fetchMotifs().then(setMotifs).catch(() => setMotifs([]));
+    fetchMotifs().then(setMotifs).catch(() => setMotifs([])).finally(() => setMotifeGeladen(true));
     fetchSettings().then(setSettings).catch(() => setSettings(null));
     fetchPriceItems()
       .then((items) => setPreisKatalog(Object.fromEntries(items.map((i) => [i.key, i]))))
@@ -495,6 +503,17 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
     [motifs, benoetigteAusrichtung],
   );
   const gewaehltesMotiv = sichtbareMotive.find((m) => m.id === motifId) ?? null;
+  // Katalog-Auswahl nur anbieten, wenn (nach dem Laden) auch Motive hinterlegt
+  // sind. Vor dem Laden bleibt die Option sichtbar (Standard), damit sie nicht
+  // aufblitzt und wieder verschwindet.
+  const katalogVerfuegbar = sichtbareMotive.length > 0;
+  const katalogOptionSichtbar = !motifeGeladen || katalogVerfuegbar;
+
+  // Ist „Motiv aus unserer Auswahl" gewählt, aber es gibt (nach dem Laden) keine
+  // Motive für dieses Format, automatisch auf „Ohne Motiv" wechseln.
+  useEffect(() => {
+    if (motifeGeladen && !katalogVerfuegbar && motifMode === 'katalog') setMotifMode('ohne');
+  }, [motifeGeladen, katalogVerfuegbar, motifMode]);
 
   // Produkt aus dem Direktlink (z. B. /briefe) vorwählen, sobald geladen –
   // überschreibt auch ein evtl. zwischengespeichertes anderes Produkt.
@@ -565,23 +584,6 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
   useEffect(() => { setPreviewSession(null); },
     [textTemplate, font, format, realistisch, labeling, needsEnvelope, umschlagText, entries]);
 
-  // Empfängerzeilen an die Menge angleichen (nur im Tabellenmodus). Gilt auch im
-  // Extern-Modus: die (vom Betreiber vorgegebene) Menge erzeugt die passende
-  // Anzahl Zeilen – egal ob mit oder ohne Kuvert/Empfänger.
-  useEffect(() => {
-    // Bei vielen Empfängern (Tabelle unpraktisch) wird auf Excel verwiesen und
-    // nicht synchronisiert – AUSSER im Extern-Modus ohne Empfänger-Schritt, wo die
-    // Menge einfach N Blanko-Dokumente erzeugen muss (auch über der Tabellengrenze).
-    if (nurUpload && (!externModus || empfaengerSchritt)) return;
-    setEntries((prev) => {
-      if (prev.length === quantity) return prev;
-      if (prev.length < quantity) {
-        return [...prev, ...Array.from({ length: quantity - prev.length }, leereEntry)];
-      }
-      return prev.slice(0, quantity);
-    });
-  }, [quantity, nurUpload, externModus, empfaengerSchritt]);
-
   // Extern-Preset (vom Betreiber im Direktlink gesetzt) – der Kunde wählt nichts:
   //   ?extern=1&versand=sammel|einzeln&kuvert=0|1&beschriftung=empfaenger|freitext|keine&menge=N
   // Die Menge ist maßgeblich (greift immer); nur ein Excel-Import passt sie an die
@@ -613,6 +615,14 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
 
   // Produkt kommt aus dem Direktlink; Extern-Modus ist oben definiert.
   const angemeldet = !!loadSession();
+  // Kundenangebote laden, sobald Produkt gewählt + eingeloggt (sonst keine).
+  useEffect(() => {
+    setOfferId(null);
+    if (!product || !angemeldet) { setOffers([]); return; }
+    let ab = false;
+    fetchMyOffers(product).then((o) => { if (!ab) setOffers(o); }).catch(() => { if (!ab) setOffers([]); });
+    return () => { ab = true; };
+  }, [product, angemeldet]);
   // „Sie sind" entfällt, wenn die Einstufung schon feststeht (eingeloggt mit
   // person_type) oder im Extern-Modus.
   const zeigeSieSind = !externModus && !(angemeldet && !!personType);
@@ -705,6 +715,7 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
       voucher_code: voucher.trim() || undefined,
       // Bekannte E-Mail mitgeben, damit Kundenrabatte in den Live-Preis einfließen.
       email: istEmail(rechnung.email) ? rechnung.email.trim() : undefined,
+      offer: offerId ?? undefined,
     })
       .then((q) => !abgebrochen && setQuote(q))
       .catch((err) => {
@@ -715,7 +726,7 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
 
     return () => { abgebrochen = true; };
   }, [product, kontaktSelektiert, format, preisMenge, shippingType, needsEnvelope, labeling,
-      motifMode, istPostkarte, textservice, designservice, voucher, rechnung.email, personType]);
+      motifMode, istPostkarte, textservice, designservice, voucher, rechnung.email, personType, offerId]);
 
   /**
    * Einzelversand: Kuvert mit Empfängeradresse ist zwingend (wir adressieren
@@ -778,6 +789,49 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
   const eigeneImText = genutztePlatzhalter.filter((p) => !standardSet.has(p.toLowerCase()));
   /** Platzhalter im individuellen Umschlagtext – analog zur Text-Tabelle. */
   const genutztePlatzhalterUmschlag = useMemo(() => textPlatzhalter(umschlagText), [umschlagText]);
+
+  // Müssen pro Dokument eigene Daten erfasst werden? Das ist der Fall bei einem
+  // Empfänger-/Individualtext-Schritt oder bei eigenen Platzhaltern im Brieftext
+  // (jede Zeile trägt andere Werte → oberhalb der Tabellengrenze via Excel).
+  const zeilenDatenNoetig = !!empfaengerSchritt || eigeneImText.length > 0;
+
+  // Empfängerzeilen an die Menge angleichen. Unterhalb der Tabellengrenze immer;
+  // darüber nur, wenn KEINE Pflicht-Zeilendaten nötig sind (z. B. identische
+  // Sammelkarten ohne Empfängerliste) – dann erzeugt die Menge N Blanko-Zeilen.
+  // Werden pro Zeile Daten gebraucht, bleibt es beim Excel-Upload (nicht syncen).
+  // Im Extern-Modus wie bisher: syncen außer bei Empfänger-/Individualtext-Schritt.
+  useEffect(() => {
+    if (nurUpload && (externModus ? empfaengerSchritt : zeilenDatenNoetig)) return;
+    setEntries((prev) => {
+      if (prev.length === quantity) return prev;
+      if (prev.length < quantity) {
+        return [...prev, ...Array.from({ length: quantity - prev.length }, leereEntry)];
+      }
+      return prev.slice(0, quantity);
+    });
+  }, [quantity, nurUpload, externModus, empfaengerSchritt, zeilenDatenNoetig]);
+  /**
+   * Entry für den Versand ans Backend: löst ALLE im Text/Umschlag genutzten
+   * Platzhalter explizit auf (Standard-Platzhalter aus der Adresse via standardWert,
+   * eigene aus e.placeholders). So wird je Empfänger sicher ersetzt – unabhängig
+   * davon, wie das Backend die Adressfelder interpretiert.
+   *
+   * Zusätzlich wird der Freitext nur bei Adressmodus „freitext" mitgeschickt.
+   * Bei strukturierter Adresse muss free_text leer sein, sonst bevorzugt das
+   * Backend (addressText) den Freitext und beschriftet den Umschlag falsch –
+   * auch wenn im Freitextfeld nur Reste von einem früheren Moduswechsel stehen.
+   */
+  const mitPlatzhaltern = (e: Entry): Entry => {
+    const used = [...new Set([...genutztePlatzhalter, ...genutztePlatzhalterUmschlag])];
+    return {
+      ...e,
+      free_text: adressModus === 'freitext' ? e.free_text : '',
+      placeholders: {
+        ...Object.fromEntries(used.map((p) => [p, standardWert(e, p)])),
+        ...e.placeholders,
+      },
+    };
+  };
   /**
    * Werden Platzhalterwerte NICHT bereits in einem Empfänger-Schritt erfasst
    * (kein Adress-Schritt, kein Umschlag-Freitext)? Dann muss der Text-Schritt
@@ -807,7 +861,7 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
       .then(() => {
         if (abgebrochen || !paypalRef.current) return;
         return rendereButtons(paypalRef.current, {
-          betrag: quote?.gross_total ?? 0,
+          betrag: bestellung.betrag,
           beschreibung: `Skrift ${gewaehltesProdukt?.name ?? ''} – ${bestellung.nummer}`,
           onApproved: async (referenz) => {
             await confirmPayment(bestellung.nummer, referenz);
@@ -819,7 +873,7 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
       .catch((err) => setBestellFehler([err.message ?? 'PayPal konnte nicht geladen werden.']));
 
     return () => { abgebrochen = true; };
-  }, [bestellung, settings, quote?.gross_total, gewaehltesProdukt?.name]);
+  }, [bestellung, settings, gewaehltesProdukt?.name]);
 
   const mwst = quote?.mwst_percent ?? settings?.mwst_percent ?? 19;
 
@@ -897,8 +951,16 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
     if (!paypalMoeglich && zahlung === 'paypal') setZahlung('rechnung');
   }, [paypalMoeglich, zahlung]);
 
+  // Sicherheitsnetz gegen Fehlbelastung: Die produzierte Menge (entries_count,
+  // serverseitig = entries.length) MUSS der berechneten/bezahlten Menge
+  // entsprechen. Weicht sie ab (z. B. Excel mit weniger Zeilen als gewählte
+  // Menge, oder nachträglich geänderte Menge), wird die Bestellung blockiert –
+  // sonst zahlt der Kunde für mehr Karten, als tatsächlich angelegt werden.
+  // Extern-/Datei-/Preislose Produkte haben ein anderes Mengenmodell → ausgenommen.
+  const mengeStimmt = externModus || dateiModus || keinePreise || entries.length === quantity;
+
   // Ohne Preis (Extern-Modus/Datei-Produkt) gibt es keinen quote – dort reicht die Zustimmung.
-  const bestellbereit = agb && datenschutz && final && (!!quote || keinePreise);
+  const bestellbereit = agb && datenschutz && final && (!!quote || keinePreise) && mengeStimmt;
 
   async function weiter() {
     // Beim Verlassen des Text-Schritts prüfen, ob das Schriftstück zu viele
@@ -918,7 +980,7 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
           realistic: realistisch,
           envelope_labeling: needsEnvelope ? labeling : 'keine',
           envelope_text: umschlagText,
-          entries: entries.slice(0, 3),
+          entries: entries.slice(0, 3).map(mitPlatzhaltern),
         });
         if (r.has_overflow) {
           setTextUeberlauf(true);
@@ -967,7 +1029,7 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
         realistic: realistisch,
         envelope_labeling: needsEnvelope ? labeling : 'keine',
         envelope_text: umschlagText,
-        entries: entries.slice(0, 3),
+        entries: entries.slice(0, 3).map(mitPlatzhaltern),
       });
       setPreviewDocs(ergebnis.docs);
       setPreviewVerbleibend(ergebnis.remaining);
@@ -1049,6 +1111,7 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
           ...(designservice ? ['gestaltungsservice'] : []),
         ],
         voucher_code: voucher.trim() || undefined,
+        offer: offerId ?? undefined,
         payment_method: keinePreise ? 'rechnung' : zahlung,
         source: externModus ? 'extern' : (loadSession() ? 'portal' : 'configurator'),
         // Gezeigte Vorschau 1:1 übernehmen (nur wenn unverändert seit der Vorschau).
@@ -1065,7 +1128,9 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
               street: lieferung.street, zip: lieferung.zip, city: lieferung.city, country: lieferung.country,
             }
           : null,
-        entries: entries.map((e) => ({
+        entries: entries.map((e) => {
+          const n = mitPlatzhaltern(e); // free_text-Normalisierung + Platzhalter
+          return {
             salutation: e.salutation,
             first_name: e.first_name,
             last_name: e.last_name,
@@ -1074,11 +1139,12 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
             zip: e.zip,
             city: e.city,
             country: e.country,
-          free_text: adressModus === 'freitext' ? e.free_text : '',
-          placeholders: e.placeholders,
+            free_text: n.free_text,
+            placeholders: n.placeholders,
             // Abweichender Text nur, wenn wirklich gesetzt (sonst greift der Standardtext).
             text: (e.text && e.text.trim()) ? e.text : undefined,
-        })),
+          };
+        }),
       });
       // Auftrag ist abgesendet – der zwischengespeicherte Entwurf wird verworfen.
       try { localStorage.removeItem(ENTWURF_KEY); } catch { /* egal */ }
@@ -1086,6 +1152,10 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
         nummer: ergebnis.order_number,
         zahlung: ergebnis.payment_method,
         bezahlt: ergebnis.payment_method !== 'paypal',
+        // Serverseitig bestätigter Betrag – NUR dieser wird per PayPal belastet,
+        // nie der Client-Quote (der könnte von der tatsächlich angelegten
+        // Auftragsmenge abweichen und den Kunden falsch belasten).
+        betrag: ergebnis.gross_total,
         extern: externModus,
       });
     } catch (err) {
@@ -1234,6 +1304,31 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
           {/* ── Menge & Versand ─────────────────────────────────── */}
           {aktuell === 'Menge & Versand' && (
             <>
+              {offers.length > 0 && (
+                <section className="sk-card">
+                  <h2>Ihr Angebot</h2>
+                  <div className="sk-options" style={{ marginTop: 'var(--sk-space-4)' }}>
+                    <Option name="offer" selected={offerId === null} onSelect={() => setOfferId(null)} title="Standard" />
+                    {offers.map((o) => (
+                      <Option key={o.id} name="offer" selected={offerId === o.id} onSelect={() => setOfferId(o.id)}
+                        title={o.label + (o.name_suffix ? ` (${o.name_suffix})` : '')} />
+                    ))}
+                  </div>
+                  {(() => {
+                    const o = offerId !== null ? offers.find((x) => x.id === offerId) : null;
+                    if (!o) return null;
+                    const sur = o.surcharges ?? [];
+                    return (
+                      <div style={{ marginTop: 'var(--sk-space-3)', fontSize: 13, color: 'var(--sk-muted, #666)', lineHeight: 1.5 }}>
+                        {sur.length > 0 && (
+                          <div>Aufschläge pro Stück: {sur.map((s) => `${s.label} +${Number(s.amount).toFixed(2)} €`).join(' · ')}</div>
+                        )}
+                        {o.note && <div style={{ marginTop: 4 }}>{o.note}</div>}
+                      </div>
+                    );
+                  })()}
+                </section>
+              )}
               <section className="sk-card">
                 <h2>Wie viele?</h2>
                 <div className="sk-field" style={{ marginTop: 'var(--sk-space-4)', marginBottom: 0 }}>
@@ -1312,8 +1407,10 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
               {/* Einheitliche Radio-Karten in fester Reihenfolge – es ist immer
                   genau eine Option gewählt (auch der Gestaltungsservice). */}
               <div className="sk-options" style={{ marginTop: 'var(--sk-space-4)' }}>
+                {katalogOptionSichtbar && (
                   <Option name="motif" selected={motifMode === 'katalog'} onSelect={() => setMotifMode('katalog')}
                     title="Motiv aus unserer Auswahl" desc="Wir zeigen Ihnen passende Motive" />
+                )}
                 <Option name="motif" selected={motifMode === 'ohne'} onSelect={() => setMotifMode('ohne')}
                   title="Ohne Motiv" desc="Blanko-Karte, nur beschrieben" />
                 <Option name="motif" selected={motifMode === 'upload'} onSelect={() => setMotifMode('upload')}
@@ -1998,6 +2095,22 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
                   </span>
                 </label>
 
+                {!mengeStimmt && (
+                  <div role="alert" style={{
+                    border: '1px solid var(--sk-danger, #c62828)',
+                    background: 'rgba(198,40,40,0.08)',
+                    color: 'var(--sk-danger, #c62828)',
+                    borderRadius: 'var(--sk-radius, 10px)',
+                    padding: 'var(--sk-space-3) var(--sk-space-4)',
+                    margin: 'var(--sk-space-4) 0 0',
+                    fontSize: 'var(--sk-size-sm)',
+                  }}>
+                    Ihre hinterlegten Empfänger/Dokumente ({entries.length}) stimmen nicht mit der
+                    gewählten Menge ({quantity}) überein. Bitte gleichen Sie die Menge oder Ihre
+                    Empfängerliste an, bevor Sie kostenpflichtig bestellen.
+                  </div>
+                )}
+
                 {bestellFehler.length > 0 && (
                   <ul className="sk-error" style={{ margin: 'var(--sk-space-3) 0 0', paddingLeft: '1.1em' }}>
                     {bestellFehler.map((f) => <li key={f}>{f}</li>)}

src/routes/Freigabe.tsx

@@ -0,0 +1,105 @@
+import { useEffect, useState } from 'react';
+import { useParams } from 'react-router-dom';
+import { ApiError, fetchFreigabe, sendFreigabe, freigabeLayoutUrl, type Freigabe } from '../lib/api';
+
+/**
+ * Öffentliche Motiv-Freigabe (Direktlink mit Einmal-Token, kein Login nötig).
+ * Zeigt den A6-Entwurf und lässt den Kunden freigeben oder einen Änderungswunsch
+ * hinterlegen. Erst nach Freigabe geht die Karte in den Druck.
+ */
+export default function FreigabeSeite() {
+  const { token = '' } = useParams();
+  const [data, setData] = useState<Freigabe | null>(null);
+  const [status, setStatus] = useState<'laedt' | 'da' | 'fehler'>('laedt');
+  const [fehler, setFehler] = useState('');
+  const [modus, setModus] = useState<'ansicht' | 'aendern'>('ansicht');
+  const [note, setNote] = useState('');
+  const [sendet, setSendet] = useState(false);
+  const [ergebnis, setErgebnis] = useState<'approved' | 'changes' | null>(null);
+
+  useEffect(() => {
+    fetchFreigabe(token)
+      .then((d) => { setData(d); setStatus('da'); if (d.status === 'approved' || d.status === 'changes') setErgebnis(d.status); })
+      .catch((e) => { setStatus('fehler'); setFehler(e instanceof ApiError ? e.message : 'Freigabe-Link ungültig oder abgelaufen.'); });
+  }, [token]);
+
+  async function absenden(action: 'approve' | 'changes') {
+    if (action === 'changes' && !note.trim()) { setFehler('Bitte beschreiben Sie kurz Ihren Änderungswunsch.'); return; }
+    setFehler(''); setSendet(true);
+    try {
+      await sendFreigabe(token, action, action === 'changes' ? note.trim() : undefined);
+      setErgebnis(action === 'approve' ? 'approved' : 'changes');
+    } catch (e) {
+      setFehler(e instanceof ApiError ? e.message : 'Konnte nicht gespeichert werden.');
+    } finally { setSendet(false); }
+  }
+
+  if (status === 'laedt') return <div className="sk-view"><p className="sk-note">Lädt …</p></div>;
+  if (status === 'fehler') return (
+    <div className="sk-view">
+      <h1>Freigabe</h1>
+      <p className="sk-error">{fehler}</p>
+    </div>
+  );
+
+  const d = data!;
+  const vorschau = (
+    <div style={{
+      margin: 'var(--sk-space-4) 0', maxWidth: 520, aspectRatio: '148 / 105', width: '100%',
+      border: '1px solid var(--sk-border)', borderRadius: 'var(--sk-radius)', overflow: 'hidden',
+      background: '#f4f6fa', boxShadow: '0 2px 10px rgba(0,0,0,.08)',
+    }}>
+      {d.has_layout
+        ? <img src={freigabeLayoutUrl(token)} alt="A6-Entwurf" style={{ width: '100%', height: '100%', objectFit: 'contain', display: 'block' }} />
+        : <div style={{ display: 'grid', placeItems: 'center', height: '100%' }}><span className="sk-note">Entwurf wird noch erstellt …</span></div>}
+    </div>
+  );
+
+  if (ergebnis === 'approved') return (
+    <div className="sk-view">
+      <h1>Vielen Dank!</h1>
+      <p>Sie haben den Entwurf zu <strong>{d.order_number}</strong> freigegeben. Ihre Karte geht jetzt in den Druck.</p>
+      {vorschau}
+    </div>
+  );
+  if (ergebnis === 'changes') return (
+    <div className="sk-view">
+      <h1>Änderungswunsch erhalten</h1>
+      <p>Danke – wir haben Ihren Änderungswunsch zu <strong>{d.order_number}</strong> notiert und melden uns mit einem neuen Entwurf.</p>
+      {vorschau}
+    </div>
+  );
+
+  return (
+    <div className="sk-view">
+      <h1>Ihr Postkarten-Entwurf</h1>
+      <p className="sk-note">Bestellung {d.order_number} · {d.product}. Bitte prüfen Sie den Druck-Entwurf (A6). Erst nach Ihrer Freigabe geht die Karte in den Druck.</p>
+      {vorschau}
+
+      {fehler && <p className="sk-error" style={{ margin: '0 0 var(--sk-space-3)' }}>{fehler}</p>}
+
+      {modus === 'ansicht' ? (
+        <div style={{ display: 'flex', gap: 'var(--sk-space-3)', flexWrap: 'wrap' }}>
+          <button className="sk-btn sk-btn--primary" disabled={sendet} onClick={() => absenden('approve')}>
+            {sendet ? 'Wird gesendet …' : '✓ Entwurf freigeben'}
+          </button>
+          <button className="sk-btn" disabled={sendet} onClick={() => { setModus('aendern'); setFehler(''); }}>
+            Änderung wünschen
+          </button>
+        </div>
+      ) : (
+        <div className="sk-field">
+          <label className="sk-label" htmlFor="f-note">Was sollen wir ändern?</label>
+          <textarea id="f-note" className="sk-input" rows={4} value={note} onChange={(e) => setNote(e.target.value)}
+            placeholder="z. B. Motiv etwas größer, anderer Ausschnitt, Text ergänzen …" />
+          <div style={{ display: 'flex', gap: 'var(--sk-space-3)', flexWrap: 'wrap', marginTop: 'var(--sk-space-3)' }}>
+            <button className="sk-btn sk-btn--primary" disabled={sendet} onClick={() => absenden('changes')}>
+              {sendet ? 'Wird gesendet …' : 'Änderungswunsch senden'}
+            </button>
+            <button className="sk-btn" disabled={sendet} onClick={() => { setModus('ansicht'); setFehler(''); }}>Zurück</button>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}

src/routes/Textmenge.tsx

@@ -1,5 +1,5 @@
 import { useEffect, useMemo, useState } from 'react';
-import { fetchFormats, fetchSettings, generatePreview } from '../lib/api';
+import { fetchCheckFormats, fetchSettings, generatePreview } from '../lib/api';
 import type { Format, PublicSettings, PreviewDoc, PreviewOverflow } from '../lib/api';
 
 /** Schriftarten wie im Konfigurator/manuellen Druck. */
@@ -87,7 +87,9 @@ function overflowMeldung(overflow?: PreviewOverflow[]) {
 export default function Textmenge() {
   const [formate, setFormate] = useState<Format[]>([]);
   const [settings, setSettings] = useState<PublicSettings | null>(null);
-  const [format, setFormat] = useState('a4');
+  // Format wird über Familie (A4/A5/A6/DIN lang) + optionale Ausrichtung (hoch/quer) gewählt.
+  const [familie, setFamilie] = useState('');
+  const [ausrichtung, setAusrichtung] = useState('');
   const [font, setFont] = useState('tilda');
   const [realistic, setRealistic] = useState(true);
   const [text, setText] = useState('');
@@ -99,15 +101,45 @@ export default function Textmenge() {
   const [gross, setGross] = useState(false);
 
   useEffect(() => {
-    fetchFormats()
-      .then((f) => {
-        setFormate(f);
-        setFormat(f.find((x) => x.key === 'a4')?.key ?? f[0]?.key ?? 'a4');
-      })
-      .catch(() => {});
+    fetchCheckFormats().then(setFormate).catch(() => {});
     fetchSettings().then(setSettings).catch(() => {});
   }, []);
 
+  // Formate zu Familien gruppieren (gleiche family = ein Eintrag mit Ausrichtungen).
+  // Formate ohne family bilden je einen eigenen Eintrag (Label = Name).
+  const familien = useMemo(() => {
+    const map = new Map<string, Format[]>();
+    for (const f of formate) {
+      const label = (f.family && f.family.trim()) || f.name;
+      if (!map.has(label)) map.set(label, []);
+      map.get(label)!.push(f);
+    }
+    return [...map.entries()].map(([label, items]) => ({ label, items }));
+  }, [formate]);
+
+  // Aktuelle Familie + verfügbare Ausrichtungen + effektiv gewähltes Format.
+  const aktuelleFamilie = familien.find((fm) => fm.label === familie) ?? familien[0] ?? null;
+  const ausrichtungen = (aktuelleFamilie?.items ?? []).filter((f) => f.orientation);
+  const hatAusrichtung = ausrichtungen.length > 1;
+  const gewaehltesFormat = aktuelleFamilie
+    ? (hatAusrichtung
+        ? (aktuelleFamilie.items.find((f) => f.orientation === ausrichtung) ?? aktuelleFamilie.items[0])
+        : aktuelleFamilie.items[0])
+    : null;
+  const formatKey = gewaehltesFormat?.key ?? 'a4';
+
+  // Standardauswahl setzen / reparieren, wenn Formate geladen sind oder sich die Familie ändert.
+  useEffect(() => {
+    if (!familien.length) return;
+    const gueltig = familien.some((fm) => fm.label === familie);
+    if (!gueltig) {
+      const start = familien.find((fm) => fm.items.some((f) => f.key === 'a4')) ?? familien[0];
+      setFamilie(start.label);
+      const ori = start.items.filter((f) => f.orientation);
+      setAusrichtung(ori.length > 1 ? (ori[0].orientation ?? '') : '');
+    }
+  }, [familien, familie]);
+
   // Escape schließt die Großansicht.
   useEffect(() => {
     if (!gross) return;
@@ -142,7 +174,7 @@ export default function Textmenge() {
     setDoc(null);
     setFehler(null);
     setGross(false);
-  }, [text, font, format, realistic]);
+  }, [text, font, formatKey, realistic]);
 
   async function generieren() {
     if (!text.trim() || laedt) return;
@@ -153,8 +185,9 @@ export default function Textmenge() {
         client_id: clientId(),
         text,
         font,
-        format,
+        format: formatKey,
         realistic,
+        check: true,
         entries: [{}],
       });
       if (ergebnis.has_overflow) {
@@ -185,13 +218,34 @@ export default function Textmenge() {
           <div style={{ display: 'flex', gap: 16, flexWrap: 'wrap' }}>
             <label className="sk-field" style={{ flex: '1 1 200px' }}>
               <span className="sk-label">Format</span>
-              <select className="sk-input" value={format} onChange={(e) => setFormat(e.target.value)}>
-                {formate.length === 0 && <option value="a4">A4</option>}
-                {formate.map((f) => (
-                  <option key={f.key} value={f.key}>{f.name}</option>
+              <select
+                className="sk-input"
+                value={aktuelleFamilie?.label ?? ''}
+                onChange={(e) => {
+                  setFamilie(e.target.value);
+                  const fam = familien.find((fm) => fm.label === e.target.value);
+                  const ori = (fam?.items ?? []).filter((f) => f.orientation);
+                  setAusrichtung(ori.length > 1 ? (ori[0].orientation ?? '') : '');
+                }}
+              >
+                {familien.length === 0 && <option value="">A4</option>}
+                {familien.map((fm) => (
+                  <option key={fm.label} value={fm.label}>{fm.label}</option>
                 ))}
               </select>
             </label>
+            {hatAusrichtung && (
+              <label className="sk-field" style={{ flex: '1 1 200px' }}>
+                <span className="sk-label">Ausrichtung</span>
+                <select className="sk-input" value={ausrichtung} onChange={(e) => setAusrichtung(e.target.value)}>
+                  {ausrichtungen.map((f) => (
+                    <option key={f.key} value={f.orientation ?? ''}>
+                      {f.orientation === 'hoch' ? 'Hochformat' : f.orientation === 'quer' ? 'Querformat' : f.name}
+                    </option>
+                  ))}
+                </select>
+              </label>
+            )}
             <label className="sk-field" style={{ flex: '1 1 200px' }}>
               <span className="sk-label">Schriftart</span>
               <select className="sk-input" value={font} onChange={(e) => setFont(e.target.value)}>