@flowselections/layout-maker 1.32.0 → 1.38.4

package/dist-lib/lib/printQueue.server.js

@@ -4,6 +4,8 @@
 // de juiste printer. Draait alleen op de server (cron / interne aanroep).
 // ============================================================================
 import { maakPakbonOrder, renderPakbonDocument, voorbeeldPakbonOrder, } from "./pakbonHtml.js";
+import { bouwPakbonScanInhoud, bewaarPakbonScanInhoud } from "./pakbonScan.js";
+import { pakbonLayoutVariant } from "./pakbonBuilder.js";
 import { renderProductiebonDocument } from "./productiebonHtml.js";
 import { heeftOrderInhoud, laadOrderVanuitDatabase } from "./orderData.server.js";
 import { profielHeeftInhoud, renderProfielDocument } from "./profielHtml.js";
@@ -47,6 +49,13 @@ export class GeenDocumentFout extends Error {
         this.name = "GeenDocumentFout";
     }
 }
+/** De Engine heeft de taak gepland, maar de layout is nog niet aangeleverd. */
+export class WachtOpLayoutFout extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = "WachtOpLayoutFout";
+    }
+}
 /**
  * Oudere/andere benamingen voor hetzelfde document. De Logistiek Engine noemt
  * de afleverbrief bijvoorbeeld nog "verzendbrief"; hier vertalen we dat naar
@@ -65,6 +74,85 @@ export function normaliseerDocumenttype(type) {
         return "document";
     return DOCUMENTTYPE_ALIASSEN[t] ?? t;
 }
+// ---------------------------------------------------------------------------
+// Contract met de Logistics Engine.
+// De Engine bepaalt documentsoort, variant, layout en printplek; deze module
+// rendert en print alleen. Alles hieronder leest die keuzes uit de opdracht en
+// overruled ze nooit.
+// ---------------------------------------------------------------------------
+/** Het layout-id zoals de Engine het aanlevert (kolom of payload). */
+export function leesEngineLayoutId(job) {
+    const p = (job.payload ?? {});
+    const d = (p.data ?? {});
+    for (const k of [job.layout_id, p.layout_id, p.layoutId, d.layout_id, d.layoutId]) {
+        const v = String(k ?? "").trim();
+        if (v)
+            return v;
+    }
+    return "";
+}
+/** Documentsoort zoals de Engine hem noemt (`document_code`). */
+function leesDocumentCode(job) {
+    const p = (job.payload ?? {});
+    const d = (p.data ?? {});
+    for (const k of [job.document_code, p.document_code, p.documentCode, d.document_code]) {
+        const v = String(k ?? "").trim();
+        if (v)
+            return v;
+    }
+    return "";
+}
+/** Is dit een opdracht die door de Logistics Engine is gepland? */
+function isEngineOpdracht(job) {
+    const p = (job.payload ?? {});
+    if (leesDocumentCode(job))
+        return true;
+    const bron = String(p.bron_module ?? p.owner_module ?? p.source_module ?? "").toLowerCase();
+    return bron.includes("logistic") || bron.includes("engine");
+}
+/** Handmatig opnieuw printen? */
+function isHerprint(job) {
+    const p = (job.payload ?? {});
+    const d = (p.data ?? {});
+    return job.is_herprint === true || p.is_herprint === true || d.is_herprint === true;
+}
+/** De ordersleutel waarop een herprint bij de oorspronkelijke print hoort. */
+function leesOrderRef(job) {
+    const p = (job.payload ?? {});
+    const d = (p.data ?? {});
+    for (const k of [job.order_ref, p.order_ref, p.orderRef, d.order_ref, d.orderRef, job.order_id]) {
+        const v = String(k ?? "").trim();
+        if (v)
+            return v;
+    }
+    return "";
+}
+/**
+ * Een herprint gebruikt dezelfde layout als de oorspronkelijke print. Stuurt de
+ * Engine geen layout mee, dan zoeken we die op bij de laatste geslaagde print
+ * van hetzelfde document van dezelfde order.
+ */
+async function zoekHerprintLayoutId(db, job) {
+    const orderRef = leesOrderRef(job);
+    if (!orderRef)
+        return "";
+    const type = normaliseerDocumenttype(leesDocumentCode(job) || job.documenttype);
+    const { data } = await db
+        .from("print_jobs")
+        .select("gebruikte_layout_id, documenttype, created_at")
+        .eq("order_ref", orderRef)
+        .not("gebruikte_layout_id", "is", null)
+        .order("created_at", { ascending: false })
+        .limit(10);
+    for (const rij of arr(data)) {
+        if (normaliseerDocumenttype(rij.documenttype) !== type)
+            continue;
+        const id = String(rij.gebruikte_layout_id ?? "").trim();
+        if (id)
+            return id;
+    }
+    return "";
+}
 /**
  * Zoekt de layout die bij de opdracht hoort.
  * Staat er een layout_id op de opdracht (bijv. gezet door de Logistiek
@@ -94,15 +182,19 @@ function magOntwerpWinnen(layout) {
     return String(layout.bron ?? "") !== "floriday";
 }
 async function zoekLayout(db, job) {
+    const engineJob = isEngineOpdracht(job);
     const heeftEigenOpmaak = typeof job.render_html === "string" && job.render_html.trim().length > 40;
-    // Een layout-id in het kenmerkenveld is alleen een verwijzing, geen
-    // koppeling: is er opmaak meegestuurd (bijv. een voorbeeldafdruk uit de
-    // ontwerper), dan is die opmaak leidend.
-    const uitPayload = heeftEigenOpmaak
+    const uitPayload = engineJob
         ? null
         : (job.payload?.layoutId ?? job.payload?.data?.layoutId ?? job.payload?.layout_id ?? null);
-    const id = job.layout_id ?? uitPayload;
-    const voorbeeld = heeftEigenOpmaak && isVoorbeeldAfdruk(job);
+    let id = leesEngineLayoutId(job) || job.layout_id || uitPayload;
+    if (engineJob && !id && isHerprint(job)) {
+        id = await zoekHerprintLayoutId(db, job);
+    }
+    if (engineJob && !id) {
+        throw new WachtOpLayoutFout("Wacht op layout_id van de Logistics Engine. Deze taak wordt niet met een vervangende layout uitgevoerd.");
+    }
+    const voorbeeld = !engineJob && heeftEigenOpmaak && isVoorbeeldAfdruk(job);
     if (id) {
         const { data } = await db
             .from("document_layouts")
@@ -113,19 +205,24 @@ async function zoekLayout(db, job) {
             throw new GeenDocumentFout("De layout die aan deze opdracht hangt bestaat niet meer. Koppel een geldige layout.");
         }
         const layout = data;
-        return { layout, ontwerpWint: !voorbeeld && magOntwerpWinnen(layout) };
+        return {
+            layout,
+            // Een Engine-layout is altijd leidend, ook als er render_html is meegestuurd.
+            ontwerpWint: engineJob || (!voorbeeld && magOntwerpWinnen(layout)),
+        };
     }
+    const documenttype = normaliseerDocumenttype(leesDocumentCode(job) || job.documenttype);
     const { data } = await db
         .from("document_layouts")
         .select("*")
-        .eq("documenttype", normaliseerDocumenttype(job.documenttype))
+        .eq("documenttype", documenttype)
         .eq("actief", true)
         .order("is_standaard", { ascending: false })
         .order("updated_at", { ascending: false })
         .limit(1);
     const gevonden = (arr(data)[0] ?? null);
     if (!gevonden && !job.render_html) {
-        throw new GeenDocumentFout(`Geen layout gevonden voor documenttype '${normaliseerDocumenttype(job.documenttype)}'. ` +
+        throw new GeenDocumentFout(`Geen layout gevonden voor documenttype '${documenttype}'. ` +
             "Maak een layout aan en zet die op actief.");
     }
     return { layout: gevonden, ontwerpWint: !voorbeeld && magOntwerpWinnen(gevonden) };
@@ -148,7 +245,7 @@ async function zoekBronregel(db, job) {
     const regel = data;
     if (!regel || regel.bron === "auto")
         return null;
-    if (regel.bron === "eigen_layout" && regel.layout_id && !job.layout_id) {
+    if (regel.bron === "eigen_layout" && regel.layout_id && !job.layout_id && !isEngineOpdracht(job)) {
         job.layout_id = regel.layout_id;
     }
     return regel.bron;
@@ -159,6 +256,8 @@ async function zoekBronregel(db, job) {
  */
 async function isFloridayLayoutKeuze(db, job) {
     const payload = (job.payload ?? {});
+    if (isEngineOpdracht(job))
+        return false;
     const id = job.layout_id ?? payload?.["layoutId"] ?? payload?.["layout_id"] ?? null;
     if (!id)
         return false;
@@ -324,18 +423,40 @@ async function zoekPrinter(db, job, layout) {
             return null;
         const { data } = await db
             .from("printers")
-            .select("id, naam, extern_printer_id, actief, papierformaat, ondersteunde_formaten, ondersteunde_laden, formaten_bijgewerkt_op")
+            .select("id, naam, extern_printer_id, actief, papierformaat, ondersteunde_formaten, ondersteunde_laden, formaten_bijgewerkt_op, afdrukmethode")
             .eq("id", id)
             .maybeSingle();
         return data && data.actief !== false ? data : null;
     };
-    const type = normaliseerDocumenttype(job.documenttype);
-    // 1. Printer die expliciet op de opdracht staat (bijv. handmatig herprinten).
-    let printer = await pak(job.printer_id);
+    const type = normaliseerDocumenttype(leesDocumentCode(job) || job.documenttype);
+    // Bij Engine-opdrachten is print_plek_id leidend. Een eventueel oud
+    // printer_id mag die keuze niet overschrijven.
+    let printer = isEngineOpdracht(job) && leesPrintPlekId(job)
+        ? null
+        : await pak(job.printer_id);
     if (printer)
         return { printer, reden: "" };
     const werkplek = String(job.payload?.werkplek ?? "").trim();
     const pickstation = leesPickstation(job);
+    const explicietePlek = leesPrintPlekId(job);
+    // Een Engine-printplek is een harde keuze. Nooit terugvallen op computer,
+    // layout of bedrijfsregels wanneer de Engine een print_plek_id meegaf.
+    if (explicietePlek) {
+        const { data: pp } = await db
+            .from("document_printplek_printers")
+            .select("printer_id")
+            .eq("print_plek_id", explicietePlek)
+            .eq("documenttype", type)
+            .maybeSingle();
+        printer = await pak(pp?.printer_id);
+        if (printer)
+            return { printer, reden: "" };
+        const { data: plek } = await db.from("print_plekken").select("naam").eq("id", explicietePlek).maybeSingle();
+        return {
+            printer: null,
+            reden: `Printplek '${String(plek?.naam ?? explicietePlek)}' heeft geen printer voor documenttype '${type}'.`,
+        };
+    }
     // 2. Regel van de printplek waar de opdracht vandaan komt.
     const plekId = await zoekPrintPlekId(db, job);
     if (plekId) {
@@ -414,24 +535,31 @@ async function zoekPrinter(db, job, layout) {
         reden: `Documenttype '${type}' heeft geen standaardprinter. Stel dit in bij Printen > Standaardregels.`,
     };
 }
+/** Verzamelt elk logo-id ergens in de layoutconfiguratie (op elke diepte). */
+function verzamelLogoIds(waarde, uit, diepte = 0) {
+    if (diepte > 8 || waarde === null || typeof waarde !== "object")
+        return;
+    if (Array.isArray(waarde)) {
+        for (const item of waarde)
+            verzamelLogoIds(item, uit, diepte + 1);
+        return;
+    }
+    for (const [sleutel, val] of Object.entries(waarde)) {
+        if ((sleutel === "logoId" || sleutel === "logo_id") && typeof val === "string" && val) {
+            uit.add(val);
+        }
+        else {
+            verzamelLogoIds(val, uit, diepte + 1);
+        }
+    }
+}
 /** Haalt de logo's op die in de layout gebruikt worden, met tijdelijke URL. */
 async function logosVoor(db, layout) {
     const config = layout?.config ?? null;
     const ids = new Set();
-    const documentLogo = config?.logo?.logoId;
-    if (documentLogo)
-        ids.add(String(documentLogo));
-    // Ook logo's die als blok in de ontwerper staan meenemen.
-    for (const sectie of Array.isArray(config?.sections) ? config.sections : []) {
-        const id = sectie?.opties?.logoId ?? sectie?.logoId;
-        if (id)
-            ids.add(String(id));
-    }
-    for (const blok of Array.isArray(config?.blokken) ? config.blokken : []) {
-        const id = blok?.opties?.logoId ?? blok?.logoId;
-        if (id)
-            ids.add(String(id));
-    }
+    // Logo's staan op verschillende plekken in de configuratie: als documentlogo,
+    // als blok in de ontwerper, of binnen `pakbon.secties` / `productiebon.blokken`.
+    verzamelLogoIds(config, ids);
     if (!ids.size)
         return [];
     const { data } = await db
@@ -510,6 +638,13 @@ export async function bouwHtml(db, job, keuze, uitkomst) {
             : null;
     if ((pakbonSecties && pakbonSecties.length) || String(layout.documenttype) === "pakbon") {
         const orderBron = p.order ?? p.data?.order ?? p.data ?? p;
+        const pakbonMethode = Array.isArray(pakbonSecties)
+            ? String(pakbonSecties.find((s) => s?.type === "pickmethode")?.opties?.methode ?? "kar")
+            : "kar";
+        const engineVariant = job.layout_variant ?? p.layout_variant ?? p.layoutVariant ?? p.data?.layout_variant ?? null;
+        if (isEngineOpdracht(job) && pakbonMethode === "beide" && !["full_cart", "partial_order"].includes(String(engineVariant ?? ""))) {
+            throw new WachtOpLayoutFout("Wacht op layout_variant van de Logistics Engine: kies full_cart of partial_order.");
+        }
         const uitDb = heeftOrderInhoud(orderBron) ? null : await laadOrderVanuitDatabase(db, p);
         // Een voorbeeldafdruk zonder ordergegevens krijgt een voorbeeldorder, zodat
         // je ziet hoe het document er in de praktijk uitziet.
@@ -517,14 +652,82 @@ export async function bouwHtml(db, job, keuze, uitkomst) {
             (p.voorbeeld === true && !heeftOrderInhoud(orderBron)
                 ? voorbeeldPakbonOrder()
                 : orderBron);
-        const order = maakPakbonOrder(bron);
-        return renderPakbonDocument(layout.config, order, {
+        // Barcode en kargegevens van de Engine mogen niet verloren gaan wanneer
+        // de ordergegevens uit een subobject komen.
+        const engineBarcode = p.barcode ?? p.data?.cart?.barcode ?? null;
+        const engineCart = p.data?.cart ?? null;
+        const bronRecord = (bron && typeof bron === "object" ? bron : {});
+        // Verwijder order-/payloadbarcodes: bij Engine-opdrachten zijn alleen de
+        // twee contractvelden hierboven toegestaan als bron voor de afleverbriefscan.
+        const { barcode: _bronBarcode, cart: _bronCart, ...bronZonderEngineBarcode } = bronRecord;
+        let order = maakPakbonOrder({
+            ...bronZonderEngineBarcode,
+            ...(engineBarcode ? { barcode: engineBarcode } : {}),
+            ...(engineCart ? { cart: engineCart } : {}),
+        });
+        if (isEngineOpdracht(job)) {
+            const barcode = String(engineBarcode ?? "").trim();
+            if (!barcode) {
+                throw new WachtOpLayoutFout("Wacht op barcode van de Logistics Engine: iedere kar moet een eigen pakbonbarcode krijgen.");
+            }
+            const cartId = String(engineCart?.cart_id ?? "").trim();
+            const karren = Array.isArray(order.karren) ? order.karren : [];
+            const passendeKarren = cartId
+                ? karren.filter((kar) => String(kar.cart_id ?? "").trim() === cartId)
+                : karren;
+            // Eén Engine-opdracht staat voor precies één kar en dus één pakbon. Een
+            // opdracht met meerdere karren mag niet één barcode aan meerdere karren
+            // koppelen; de Engine moet daarvoor afzonderlijke jobs aanmaken.
+            if (passendeKarren.length > 1 || (!cartId && karren.length > 1)) {
+                throw new WachtOpLayoutFout("Wacht op afzonderlijke kar-opdrachten van de Logistics Engine: maak per kar één print_job met een eigen barcode.");
+            }
+            if (cartId && passendeKarren.length === 0 && karren.length > 1) {
+                throw new WachtOpLayoutFout("De door de Logistics Engine gekozen kar is niet gevonden in de pakbongegevens.");
+            }
+            const gekozenKar = passendeKarren[0] ?? (karren.length === 1 ? karren[0] : null);
+            if (gekozenKar) {
+                order = {
+                    ...order,
+                    cart: {
+                        ...order.cart,
+                        ...engineCart,
+                        barcode,
+                        cart_id: cartId || gekozenKar.cart_id,
+                        cart_label: String(engineCart?.cart_label ?? gekozenKar.cart_label ?? "").trim() || undefined,
+                        cart_index: Number(engineCart?.cart_index ?? gekozenKar.cart_index ?? 0) || undefined,
+                        cart_total: Number(engineCart?.cart_total ?? gekozenKar.cart_total ?? 0) || undefined,
+                    },
+                    karren: [{ ...gekozenKar, barcode }],
+                };
+            }
+        }
+        const html = renderPakbonDocument(layout.config, order, {
             breedteMm,
             hoogteMm,
             margeMm: Number(layout.marge_boven ?? 12),
             titel: job.documentnaam ?? "Document",
+            layoutVariant: engineVariant,
             logos: await logosVoor(db, layout),
         });
+        // De Engine bepaalt de barcode. De module registreert uitsluitend de
+        // gerenderde inhoud onder die bestaande waarde voor de scanner. Als de
+        // registratie tijdelijk niet kan, mag dat een afdruk nooit blokkeren.
+        const scanInhoud = bouwPakbonScanInhoud(order, {
+            barcode: engineBarcode,
+            layoutVariant: pakbonLayoutVariant(engineVariant),
+            layoutId: String(layout.id ?? "") || null,
+            printJobId: String(job.id ?? "") || null,
+            isHerprint: isHerprint(job),
+        });
+        if (scanInhoud) {
+            try {
+                await bewaarPakbonScanInhoud(db, scanInhoud);
+            }
+            catch (e) {
+                await log(db, job.id, "barcode_inhoud_niet_opgeslagen", e instanceof Error ? e.message : "Registratie van barcode-inhoud mislukt");
+            }
+        }
+        return html;
     }
     // 2) Productiebon-layouts (blokken onder `productiebon.blokken`).
     if (Array.isArray(cfg.productiebon?.blokken) ||
@@ -616,6 +819,20 @@ function plattePayload(payload) {
     loop(payload, "", 0);
     return uit;
 }
+async function wachtOpLayout(db, job, reden) {
+    await db
+        .from("print_jobs")
+        .update({
+        status: "wachtend",
+        foutmelding: reden.slice(0, 500),
+        volgende_poging: new Date(Date.now() + 5 * 60 * 1000).toISOString(),
+        opgepakt_op: null,
+        voltooid_op: null,
+        updated_at: new Date().toISOString(),
+    })
+        .eq("id", job.id);
+    await log(db, job.id, "wacht_op_engine_layout", reden);
+}
 async function mislukt(db, job, reden, terugNaarWachtend) {
     const pogingen = Number(job.pogingen ?? 0);
     const opnieuw = terugNaarWachtend && pogingen < MAX_POGINGEN;
@@ -643,19 +860,20 @@ async function verwerkJob(db, job) {
         // 1) Bronregel: bepaalt of het meegestuurde document wordt gebruikt of dat
         //    er altijd een eigen ontwerp wordt opgemaakt.
         let bron = await zoekBronregel(db, job);
-        // 1b) Is er een vaste Floriday-layout gekozen? Die staat alleen voor het
-        //     kant-en-klare document uit Floriday: dat gaat 1-op-1 naar de printer.
-        if (await isFloridayLayoutKeuze(db, job)) {
+        // 1b) Legacy Floriday-keuze; Engine-opdrachten volgen uitsluitend hun
+        //     eigen layout_id en worden nooit teruggezet naar een externe PDF.
+        if (!isEngineOpdracht(job) && await isFloridayLayoutKeuze(db, job)) {
             bron = "extern_pdf";
             job.layout_id = null;
         }
-        if (bron === "eigen_layout") {
+        if (bron === "eigen_layout" || isEngineOpdracht(job)) {
             job.pdf_base64 = null;
             job.pdf_url = null;
         }
-        // 2) Kant-en-klare PDF (klantsticker, Floriday-document) gaat ongewijzigd door.
-        const klaar = await kantEnKlarePdf(db, job);
-        if (!klaar && bron === "extern_pdf") {
+        // 2) Kant-en-klare PDF gaat alleen buiten het Engine-contract ongewijzigd
+        //    door. De Engine bepaalt altijd de layout, ook als er een PDF aanwezig is.
+        const klaar = isEngineOpdracht(job) ? null : await kantEnKlarePdf(db, job);
+        if (!klaar && bron === "extern_pdf" && !isEngineOpdracht(job)) {
             await mislukt(db, job, "Floriday-document ontbreekt: voor dit document is ingesteld dat het " +
                 "aangeleverde document wordt gebruikt, maar er is geen PDF meegestuurd.", true);
             return "mislukt";
@@ -664,7 +882,9 @@ async function verwerkJob(db, job) {
         const layout = keuze.layout;
         const printerKeuze = await zoekPrinter(db, job, layout);
         const printer = printerKeuze.printer;
-        if (!printer?.extern_printer_id) {
+        // Virtuele PDF-printer: geen PrintNode nodig; de PDF wordt bewaard.
+        const isPdfPrinter = String(printer?.afdrukmethode ?? "") === "pdf";
+        if (!printer || (!isPdfPrinter && !printer.extern_printer_id)) {
             await mislukt(db, job, printerKeuze.reden ||
                 `Printer '${printer?.naam ?? "onbekend"}' is niet aan PrintNode gekoppeld.`, true);
             return "mislukt";
@@ -679,18 +899,69 @@ async function verwerkJob(db, job) {
                 throw new GeenDocumentFout("Het document was leeg: er zijn geen gegevens gevonden om af te drukken. " +
                     "Controleer of de layout blokken bevat en of de order gegevens heeft.");
             }
-            const liggend = String(layout?.orientatie ?? "portrait") === "landscape";
+            // Een voorbeeldafdruk koppelt bewust geen layout (het meegestuurde
+            // ontwerp is leidend), maar geeft wél het papierformaat van de bewerkte
+            // layout mee. Zonder dit zou het voorbeeld altijd op A4 uitkomen.
+            const vf = (job.payload ?? {})["voorbeeld_formaat"];
+            const liggend = String(layout?.orientatie ?? vf?.["orientatie"] ?? "portrait") === "landscape";
             pdfBase64 = await htmlNaarPdfServer({
                 html,
-                breedteMm: Number(layout?.breedte_mm ?? 210),
-                hoogteMm: Number(layout?.hoogte_mm ?? 297),
-                margeMm: Number(layout?.marge_boven ?? 10),
+                breedteMm: Number(layout?.breedte_mm ?? vf?.["breedte_mm"] ?? 210),
+                hoogteMm: Number(layout?.hoogte_mm ?? vf?.["hoogte_mm"] ?? 297),
+                margeMm: Number(layout?.marge_boven ?? vf?.["marge_boven"] ?? 10),
                 landschap: liggend,
             });
         }
+        // Virtuele PDF-printer: niets gaat naar een fysieke printer; de opgemaakte
+        // PDF wordt op de opdracht bewaard en is daarna te downloaden in de
+        // wachtrij. De opdracht is meteen voltooid.
+        if (isPdfPrinter) {
+            // In twee stappen: eerst de status (klein en altijd betrouwbaar), daarna
+            // pas de PDF zelf. Een grote PDF kan door de databaselimiet geweigerd
+            // worden; de opdracht mag daar nooit door blijven hangen op 'bezig'.
+            const { error: statusFout } = await db
+                .from("print_jobs")
+                .update({
+                printer_id: printer.id,
+                gebruikte_layout_id: uitkomst.bron === "extern_pdf" ? null : (layout?.id ?? null),
+                gebruikte_bron: uitkomst.bron,
+                status: "voltooid",
+                lokale_pdf_status: "gereed",
+                lokale_pdf_fout: null,
+                lokaal_opgeslagen_op: null,
+                foutmelding: null,
+                volgende_poging: null,
+                voltooid_op: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            })
+                .eq("id", job.id);
+            if (statusFout) {
+                await mislukt(db, job, `Opdracht afronden mislukt: ${statusFout.message}`, true);
+                return "mislukt";
+            }
+            const { error: pdfFout } = await db
+                .from("print_jobs")
+                .update({ resultaat_pdf_base64: pdfBase64 })
+                .eq("id", job.id);
+            if (pdfFout) {
+                await db
+                    .from("print_jobs")
+                    .update({
+                    lokale_pdf_status: "fout",
+                    lokale_pdf_fout: `PDF kon niet bewaard worden: ${pdfFout.message}`.slice(0, 500),
+                    updated_at: new Date().toISOString(),
+                })
+                    .eq("id", job.id);
+                await log(db, job.id, "mislukt", `PDF bewaren mislukt: ${pdfFout.message}`);
+                return "verstuurd";
+            }
+            await log(db, job.id, "pdf_gereed", `PDF gereed voor lokale opslag via ${printer.naam ?? "PDF-printer"}.`);
+            return "verstuurd";
+        }
         const formaten = await zorgVoorFormaten(db, printer);
-        const breedteMm = Number(layout?.breedte_mm ?? standaardMaat(printer).breedte);
-        const hoogteMm = Number(layout?.hoogte_mm ?? standaardMaat(printer).hoogte);
+        const vfPapier = (job.payload ?? {})["voorbeeld_formaat"];
+        const breedteMm = Number(layout?.breedte_mm ?? vfPapier?.["breedte_mm"] ?? standaardMaat(printer).breedte);
+        const hoogteMm = Number(layout?.hoogte_mm ?? vfPapier?.["hoogte_mm"] ?? standaardMaat(printer).hoogte);
         const papier = kiesPapier(formaten, breedteMm, hoogteMm);
         const externJobId = await stuurPdfNaarPrinter({
             externPrinterId: String(printer.extern_printer_id),
@@ -717,6 +988,10 @@ async function verwerkJob(db, job) {
         return "verstuurd";
     }
     catch (e) {
+        if (e instanceof WachtOpLayoutFout) {
+            await wachtOpLayout(db, job, e.message);
+            return "wachtend";
+        }
         // Ontbreekt er een document of layout? Dan heeft opnieuw proberen geen zin.
         const blijvend = e instanceof GeenDocumentFout;
         const tijdelijk = !blijvend && (e instanceof PdfRenderFout || e?.name === "PrintToegangFout");
@@ -812,6 +1087,7 @@ async function vervalControle(db) {
         .select("id, pogingen")
         .eq("status", "bezig")
         .is("extern_job_id", null)
+        .neq("lokale_pdf_status", "gereed")
         .or(`opgepakt_op.lt.${grensClaim},and(opgepakt_op.is.null,updated_at.lt.${grensClaim})`)
         .limit(50);
     for (const job of arr(vastgelopen)) {
@@ -844,16 +1120,31 @@ export async function verwerkWachtrij(db, max = 5) {
     catch (e) {
         console.warn(`[printwachtrij] vervalcontrole mislukt: ${e instanceof Error ? e.message : "onbekend"}`);
     }
-    const { data, error } = await db.rpc("claim_cloud_print_jobs", { _max: max });
-    if (error)
-        throw new Error(error.message);
-    const jobs = arr(data);
+    // PDF-opdrachten hebben een eigen claimroute. Daardoor kunnen oudere
+    // gepubliceerde moduleversies, die een PDF-printer nog als PrintNode-printer
+    // behandelen, deze opdrachten niet meer vóór de actuele runner oppakken.
+    const { data: pdfData, error: pdfError } = await db.rpc("claim_pdf_print_jobs", { _max: max });
+    if (pdfError)
+        throw new Error(pdfError.message);
+    const pdfJobs = arr(pdfData);
+    const resterend = Math.max(0, max - pdfJobs.length);
+    let gewoneJobs = [];
+    if (resterend > 0) {
+        const { data, error } = await db.rpc("claim_cloud_print_jobs", { _max: resterend });
+        if (error)
+            throw new Error(error.message);
+        gewoneJobs = arr(data);
+    }
+    const jobs = [...pdfJobs, ...gewoneJobs];
     let verstuurd = 0;
     let mislukteJobs = 0;
+    let wachtend = 0;
     for (const job of jobs) {
         const uitkomst = await verwerkJob(db, job);
         if (uitkomst === "verstuurd")
             verstuurd++;
+        else if (uitkomst === "wachtend")
+            wachtend++;
         else
             mislukteJobs++;
     }
@@ -861,6 +1152,7 @@ export async function verwerkWachtrij(db, max = 5) {
         opgepakt: jobs.length,
         verstuurd,
         mislukt: mislukteJobs,
+        wachtend,
         bijgewerkt: await synchroniseerStatussen(db),
     };
 }
@@ -871,16 +1163,18 @@ export async function verwerkWachtrij(db, max = 5) {
  */
 export async function bepaalDocumentKeuze(db, job) {
     let bron = await zoekBronregel(db, job);
-    if (await isFloridayLayoutKeuze(db, job)) {
+    // Engine-opdrachten houden hun eigen layout_id; nooit vervangen door een
+    // Floriday-PDF-keuze.
+    if (!isEngineOpdracht(job) && (await isFloridayLayoutKeuze(db, job))) {
         bron = "extern_pdf";
         job.layout_id = null;
     }
-    if (bron === "eigen_layout") {
+    if (bron === "eigen_layout" || isEngineOpdracht(job)) {
         job.pdf_base64 = null;
         job.pdf_url = null;
     }
-    const klaar = await kantEnKlarePdf(db, job);
-    if (!klaar && bron === "extern_pdf") {
+    const klaar = isEngineOpdracht(job) ? null : await kantEnKlarePdf(db, job);
+    if (!klaar && bron === "extern_pdf" && !isEngineOpdracht(job)) {
         throw new GeenDocumentFout("Voor dit document is ingesteld dat het aangeleverde document wordt " +
             "gebruikt, maar er is geen PDF meegestuurd.");
     }