@flowselections/layout-maker 1.36.7 → 1.45.8

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

@@ -4,8 +4,11 @@
 // 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 { bouwPakbonBarcodeVerzoek, geleverdeBarcodeVoorJob, vraagPakbonBarcodeAan, } from "./pakbonBarcodeVerzoek.js";
+import { deelkarRegels, leesAfleverbriefConfig, pakbonLayoutVariant } from "./pakbonBuilder.js";
 import { renderProductiebonDocument } from "./productiebonHtml.js";
-import { heeftOrderInhoud, laadOrderVanuitDatabase } from "./orderData.server.js";
+import { heeftOrderInhoud, laadOrderVanuitDatabase, laadPakbonData } from "./orderData.server.js";
 import { profielHeeftInhoud, renderProfielDocument } from "./profielHtml.js";
 import { bouwDocumentHtml, voorbeeldContext } from "./layoutPreview.js";
 import { htmlNaarPdfServer, PdfRenderFout } from "./htmlNaarPdf.server.js";
@@ -47,6 +50,20 @@ 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";
+    }
+}
+/** Blijvende contractfout: opnieuw proberen met dezelfde invoer kan niet slagen. */
+export class EngineContractFout extends GeenDocumentFout {
+    constructor() {
+        super(...arguments);
+        this.name = "EngineContractFout";
+    }
+}
 /**
  * Oudere/andere benamingen voor hetzelfde document. De Logistiek Engine noemt
  * de afleverbrief bijvoorbeeld nog "verzendbrief"; hier vertalen we dat naar
@@ -65,6 +82,149 @@ 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,
+        job.document_type_code,
+        p.document_code,
+        p.documentCode,
+        p.document_type_code,
+        p.documentTypeCode,
+        d.document_code,
+        d.document_type_code,
+        d.documentTypeCode,
+    ]) {
+        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;
+}
+/**
+ * Een herprint behoudt de eerder door de Engine aangeleverde barcode en kar.
+ * Er wordt nooit lokaal een barcode bedacht. We zoeken uitsluitend binnen
+ * dezelfde queue-/orderreferentie en hetzelfde documenttype.
+ */
+async function zoekHerprintBarcodeBron(db, job) {
+    if (!isHerprint(job))
+        return null;
+    const p = (job.payload ?? {});
+    const d = (p.data ?? {});
+    const bronJobId = String(job.bron_job_id ?? p.bron_job_id ?? "").trim();
+    if (bronJobId) {
+        const { data: bron } = await db
+            .from("print_jobs")
+            .select("payload")
+            .eq("id", bronJobId)
+            .maybeSingle();
+        const bp = (bron?.payload ?? {});
+        const bd = (bp.data ?? {});
+        const barcode = String(bp.barcode ?? bd.cart?.barcode ?? bp.cart?.barcode ?? "").trim();
+        if (barcode) {
+            const cart = (bd.cart ?? bp.cart ?? null);
+            return { barcode, cart: cart && typeof cart === "object" ? cart : null };
+        }
+    }
+    const queueItem = String(p.queue_item_id ?? d.queue_item_id ?? "").trim();
+    const orderNummer = String(p.order_number ?? p.ordernummer ?? d.order_number ?? d.ordernummer ?? "").trim();
+    if (!queueItem && !orderNummer)
+        return null;
+    const { data } = await db
+        .from("print_jobs")
+        .select("id, documenttype, payload, created_at")
+        .lt("created_at", String(job.created_at ?? new Date().toISOString()))
+        .order("created_at", { ascending: false })
+        .limit(30);
+    const type = normaliseerDocumenttype(leesDocumentCode(job) || job.documenttype);
+    for (const kandidaat of arr(data)) {
+        if (normaliseerDocumenttype(leesDocumentCode(kandidaat) || kandidaat.documenttype) !== type)
+            continue;
+        const kp = (kandidaat.payload ?? {});
+        const kd = (kp.data ?? {});
+        const zelfdeQueue = queueItem && String(kp.queue_item_id ?? kd.queue_item_id ?? "").trim() === queueItem;
+        const zelfdeOrder = orderNummer && String(kp.order_number ?? kp.ordernummer ?? kd.order_number ?? kd.ordernummer ?? "").trim() === orderNummer;
+        if (!zelfdeQueue && !zelfdeOrder)
+            continue;
+        const barcode = String(kp.barcode ?? kd.cart?.barcode ?? kp.cart?.barcode ?? "").trim();
+        if (!barcode)
+            continue;
+        const cart = (kd.cart ?? kp.cart ?? null);
+        return { barcode, cart: cart && typeof cart === "object" ? cart : null };
+    }
+    return null;
+}
+/** 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, payload, created_at")
+        .not("gebruikte_layout_id", "is", null)
+        .order("created_at", { ascending: false })
+        .limit(50);
+    for (const rij of arr(data)) {
+        if (normaliseerDocumenttype(rij.documenttype) !== type)
+            continue;
+        if (leesOrderRef(rij) !== orderRef)
+            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 +254,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 +277,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 +317,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 +328,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;
@@ -269,8 +440,37 @@ async function zoekPrintPlekId(db, job) {
             .select("print_plek_id")
             .eq("computer_naam", werkplek)
             .maybeSingle();
-        return String(data?.print_plek_id ?? "").trim();
+        const id = String(data?.print_plek_id ?? "").trim();
+        if (id)
+            return id;
     }
+    // Terugval: de opdracht kwam zonder plek binnen (bijvoorbeeld van de scanner
+    // bij "kar compleet"). Gebruik dan de plek die in de documentroutering voor
+    // deze documentsoort staat. Zo blijft een PDF-opdracht niet eindeloos op een
+    // werkplek wachten die niemand heeft toegewezen.
+    const documenttype = normaliseerDocumenttype(job.documenttype);
+    if (documenttype) {
+        const { data } = await db
+            .from("document_printplek_printers")
+            .select("print_plek_id")
+            .eq("documenttype", documenttype)
+            .not("print_plek_id", "is", null);
+        const plekken = Array.isArray(data) ? data : [];
+        const uniek = Array.from(new Set(plekken.map((r) => String(r?.print_plek_id ?? "").trim()).filter(Boolean)));
+        if (uniek.length === 1)
+            return uniek[0];
+    }
+    // Laatste terugval: is er in de hele routering maar één plek bekend, dan kan
+    // er niets misgaan door die te kiezen. Bij meerdere plekken raden we nooit.
+    const { data: alle } = await db
+        .from("document_printplek_printers")
+        .select("print_plek_id")
+        .not("print_plek_id", "is", null);
+    const alleUniek = Array.from(new Set((Array.isArray(alle) ? alle : [])
+        .map((r) => String(r?.print_plek_id ?? "").trim())
+        .filter(Boolean)));
+    if (alleUniek.length === 1)
+        return alleUniek[0];
     return "";
 }
 /** Naam van de printplek waar deze opdracht bij hoort, voor nette meldingen. */
@@ -329,13 +529,36 @@ async function zoekPrinter(db, job, layout) {
             .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 de centrale routering altijd leidend. De Engine
+    // kan een printer_id als momentopname meesturen, maar die kan inmiddels zijn
+    // gewijzigd (bijvoorbeeld van PDF naar een fysieke printer). Laat zo'n oud
+    // id daarom nooit de actuele printplek-, werkplek- of standaardregel
+    // overschrijven.
+    let printer = isEngineOpdracht(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) {
@@ -508,6 +731,40 @@ export async function bouwHtml(db, job, keuze, uitkomst) {
             throw new GeenDocumentFout("Deze layout gebruikt altijd het ontwerp van de klant, maar er is geen klantontwerp meegestuurd.");
         }
     }
+    // 0) Afleverbrief-/veilingbrieflayouts. Deze hebben hun eigen sectie-opbouw
+    // onder `afleverbrief`. Een afleverbrief hoort altijd bij precies één kar:
+    // hij vertelt wat er op díé kar staat.
+    const afleverType = String(layout.documenttype) === "afleverbrief" ||
+        String(layout.documenttype) === "veilingbrief";
+    if (afleverType || Array.isArray(cfg.afleverbrief?.secties)) {
+        const orderBron = p.order ?? p.data?.order ?? p.data ?? p;
+        const cartId = String(p.data?.cart?.cart_id ?? p.cart?.cart_id ?? p.data?.cart?.cartId ?? p.cart?.cartId ?? "").trim();
+        const uitDb = heeftOrderInhoud(orderBron)
+            ? null
+            : cartId
+                ? ((await laadPakbonData(db, { scope: "cart", id: cartId })) ??
+                    (await laadOrderVanuitDatabase(db, p)))
+                : await laadOrderVanuitDatabase(db, p);
+        const bron = uitDb ??
+            (p.voorbeeld === true && !heeftOrderInhoud(orderBron)
+                ? voorbeeldPakbonOrder()
+                : orderBron);
+        const volledig = maakPakbonOrder((bron && typeof bron === "object" ? bron : {}));
+        // Beperk tot de aangewezen kar; zonder aanwijzing tot de eerste kar, zodat
+        // een afleverbrief nooit de inhoud van meerdere karren door elkaar toont.
+        const karren = arr(volledig.karren);
+        const gekozen = (cartId ? karren.find((k) => String(k?.cart_id ?? "").trim() === cartId) : null) ??
+            karren[0] ??
+            null;
+        const order = { ...volledig, karren: gekozen ? [gekozen] : [] };
+        return renderPakbonDocument(leesAfleverbriefConfig(layout.config), order, {
+            breedteMm,
+            hoogteMm,
+            margeMm: Number(layout.marge_boven ?? 10),
+            titel: job.documentnaam ?? String(layout.naam ?? "Afleverbrief"),
+            logos: await logosVoor(db, layout),
+        });
+    }
     // 1) Pakbon-layouts. De secties staan onder `pakbon.secties`; oudere
     // layouts hebben ze op het hoogste niveau. Beide vormen tellen mee.
     const pakbonSecties = Array.isArray(cfg.secties)
@@ -517,21 +774,154 @@ 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 uitDb = heeftOrderInhoud(orderBron) ? null : await laadOrderVanuitDatabase(db, 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.");
+        }
+        // Barcode en kargegevens van de Engine mogen niet verloren gaan wanneer
+        // de ordergegevens uit een subobject komen.
+        const herprintBron = await zoekHerprintBarcodeBron(db, job);
+        const engineBarcode = p.barcode ?? p.data?.cart?.barcode ?? p.cart?.barcode ?? herprintBron?.barcode ?? null;
+        const ruweEngineCart = p.data?.cart ?? p.cart ?? herprintBron?.cart ?? null;
+        const engineCart = ruweEngineCart && typeof ruweEngineCart === "object"
+            ? {
+                ...ruweEngineCart,
+                cart_id: ruweEngineCart.cart_id ?? ruweEngineCart.cartId,
+                cart_label: ruweEngineCart.cart_label ?? ruweEngineCart.cartLabel,
+                cart_index: ruweEngineCart.cart_index ?? ruweEngineCart.cartIndex,
+                cart_total: ruweEngineCart.cart_total ?? ruweEngineCart.cartTotal,
+                cart_items: ruweEngineCart.cart_items ?? ruweEngineCart.items,
+                barcode: ruweEngineCart.barcode ?? engineBarcode,
+            }
+            : null;
+        const engineCartId = String(engineCart?.cart_id ?? "").trim();
+        // Wijst de Engine één kar aan, dan halen we de producten rechtstreeks bij
+        // díé kar op. Zo staan altijd exact de artikelen op de pakbon die fysiek op
+        // de kar liggen — ook bij gedeelde karren met regels van meerdere orders.
+        const uitDb = heeftOrderInhoud(orderBron)
+            ? null
+            : engineCartId
+                ? ((await laadPakbonData(db, { scope: "cart", id: engineCartId })) ??
+                    (await laadOrderVanuitDatabase(db, p)))
+                : await laadOrderVanuitDatabase(db, p);
         // Een voorbeeldafdruk zonder ordergegevens krijgt een voorbeeldorder, zodat
         // je ziet hoe het document er in de praktijk uitziet.
         const bron = uitDb ??
             (p.voorbeeld === true && !heeftOrderInhoud(orderBron)
                 ? voorbeeldPakbonOrder()
                 : orderBron);
-        const order = maakPakbonOrder(bron);
-        return renderPakbonDocument(layout.config, order, {
+        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)) {
+            let barcode = String(engineBarcode ?? "").trim();
+            if (!barcode) {
+                // De Engine heeft (nog) geen barcode meegestuurd. Heeft zij er
+                // inmiddels één geleverd op ons eerdere verzoek, dan gebruiken we die.
+                barcode = (await geleverdeBarcodeVoorJob(db, String(job.id ?? ""))) ?? "";
+            }
+            if (!barcode) {
+                // Zelf een barcode bedenken mag nooit. Wél laten we de Engine expliciet
+                // weten dat er voor deze pakbon een barcode ontbreekt, zodat zij er één
+                // kan aanleveren in plaats van dat de opdracht stil blijft hangen.
+                try {
+                    await vraagPakbonBarcodeAan(db, bouwPakbonBarcodeVerzoek(order, {
+                        printJobId: String(job.id ?? ""),
+                        documentnaam: job.documentnaam,
+                        cart: engineCart,
+                        layoutVariant: pakbonLayoutVariant(engineVariant),
+                        layoutId: String(layout.id ?? "") || null,
+                        isHerprint: isHerprint(job),
+                    }));
+                }
+                catch (e) {
+                    await log(db, job.id, "barcode_verzoek_niet_opgeslagen", e instanceof Error ? e.message : "Barcodeverzoek kon niet worden vastgelegd");
+                }
+                throw new WachtOpLayoutFout("Barcode opgevraagd bij de Logistics Engine: deze kar heeft nog geen pakbonbarcode.");
+            }
+            // Restpakbon: zonder meegestuurde restregels weten we niet wát er nog
+            // verzameld moet worden. Dan liever geen pakbon dan een pakbon met de
+            // volledige karinhoud erop.
+            if (pakbonLayoutVariant(engineVariant) === "partial_order" && !deelkarRegels(order).length) {
+                throw new EngineContractFout("Restpakbon zonder restregels: stuur de resterende regels mee als cart_items.");
+            }
+            const cartId = engineCartId;
+            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.");
+            }
+            // Wijst de Engine een kar aan die niet in de gegevens voorkomt, dan mag
+            // er nóóit een andere kar worden afgedrukt: dan staan er producten op de
+            // pakbon die er niet op horen. De opdracht mislukt dan bewust.
+            if (cartId && passendeKarren.length === 0) {
+                throw new EngineContractFout("De door de Logistics Engine gekozen kar is niet gevonden in de pakbongegevens.");
+            }
+            const gekozenKar = passendeKarren[0] ?? (karren.length === 1 ? karren[0] : null);
+            // Een kar zonder productregels levert een lege pakbon op. Liever een
+            // duidelijke fout dan een pakbon zonder de producten die erop horen.
+            const heeftProducten = !!gekozenKar &&
+                arr(gekozenKar.lagen).some((laag) => arr(laag?.producten).length > 0);
+            if (gekozenKar && !heeftProducten) {
+                throw new EngineContractFout("De gekozen kar bevat geen productregels; de pakbon zou zonder producten worden afgedrukt.");
+            }
+            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: order?.cart?.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) ||
@@ -575,15 +965,30 @@ export async function bouwHtml(db, job, keuze, uitkomst) {
             "Zet in de layoutinstellingen minstens één onderdeel aan.");
     }
     const logos = await logosVoor(db, layout);
-    const gegevens = (p.data ?? p);
+    const meegegeven = (p.data ?? p);
+    // De opdracht bevat vaak alleen verwijzingen (order-id, kar-id). Zonder de
+    // echte ordergegevens zou het document als een lijst lege veldnamen worden
+    // afgedrukt, terwijl het ontwerp op het scherm wél gevuld is. Daarom halen
+    // we dezelfde ordergegevens op als de pakbon gebruikt.
+    const uitDatabase = heeftOrderInhoud(meegegeven)
+        ? null
+        : await laadOrderVanuitDatabase(db, p).catch(() => null);
+    const gegevens = { ...(uitDatabase ?? {}), ...(meegegeven ?? {}) };
     const profielData = p.voorbeeld === true ? { ...voorbeeldContext(), ...(gegevens ?? {}) } : gegevens;
-    return renderProfielDocument(String(layout.documenttype), cfg, profielData, {
+    const profielHtml = renderProfielDocument(String(layout.documenttype), cfg, profielData, {
         breedteMm,
         hoogteMm,
         margeMm: Number(layout.marge_boven ?? 8),
         titel: job.documentnaam ?? String(layout.naam ?? "Document"),
         logoUrl: logos[0]?.viewUrl ?? null,
     });
+    // Fail closed: liever een duidelijke fout dan een vel papier met alleen
+    // veldnamen en streepjes erop.
+    if (!/<div class="blok"/.test(profielHtml)) {
+        throw new GeenDocumentFout(`Voor "${String(layout.naam ?? "")}" zijn geen gegevens gevonden om af te drukken. ` +
+            "Controleer of de opdracht een order of kar meestuurt.");
+    }
+    return profielHtml;
 }
 /**
  * Controleert of het document echt iets afdrukt. Zonder deze controle kan een
@@ -623,6 +1028,22 @@ function plattePayload(payload) {
     loop(payload, "", 0);
     return uit;
 }
+async function wachtOpLayout(db, job, reden) {
+    await db
+        .from("print_jobs")
+        .update({
+        status: "wachtend",
+        lokale_pdf_status: "wachtend",
+        lokale_pdf_fout: reden.slice(0, 500),
+        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;
@@ -632,6 +1053,9 @@ async function mislukt(db, job, reden, terugNaarWachtend) {
         .from("print_jobs")
         .update({
         status: opnieuw ? "wachtend" : "mislukt",
+        verwerkingsfase: opnieuw ? "retry_wacht" : "mislukt",
+        fase_voltooid_op: opnieuw ? null : new Date().toISOString(),
+        foutcode: opnieuw ? "tijdelijke_fout" : "blijvende_fout",
         foutmelding: reden.slice(0, 500),
         volgende_poging: opnieuw ? new Date(Date.now() + wachtMin * 60000).toISOString() : null,
         voltooid_op: opnieuw ? null : new Date().toISOString(),
@@ -640,7 +1064,67 @@ async function mislukt(db, job, reden, terugNaarWachtend) {
         .eq("id", job.id);
     await log(db, job.id, opnieuw ? "opnieuw_proberen" : "mislukt", reden);
 }
+function pdfBytes(base64) {
+    const bron = Buffer.from(base64, "base64");
+    const inhoud = new Uint8Array(new ArrayBuffer(bron.byteLength));
+    inhoud.set(bron);
+    return inhoud;
+}
+async function bewaarPdfArtefact(db, jobId, base64) {
+    const inhoud = pdfBytes(base64);
+    const pad = `${jobId}.pdf`;
+    const digest = await crypto.subtle.digest("SHA-256", inhoud);
+    const sha256 = Array.from(new Uint8Array(digest), (waarde) => waarde.toString(16).padStart(2, "0")).join("");
+    const { error } = await db.storage
+        .from("print-artifacts")
+        .upload(pad, inhoud, { contentType: "application/pdf", upsert: true });
+    if (error)
+        throw new PdfRenderFout("mislukt", `Het PDF-bestand kon niet veilig worden opgeslagen: ${error.message}`);
+    return { pad, sha256, bytes: inhoud.byteLength };
+}
+/**
+ * Kleine faseklok: meet per opdracht hoe lang claimen, layout kiezen, printer
+ * kiezen, renderen en versturen duren. Eén logregel per opdracht, zodat de
+ * meting zelf het printpad niet vertraagt.
+ */
+class Faseklok {
+    constructor(job) {
+        this.start = Date.now();
+        this.vorige = Date.now();
+        this.fasen = [];
+        const aangemaakt = job.created_at ? Date.parse(String(job.created_at)) : NaN;
+        if (Number.isFinite(aangemaakt))
+            this.fasen.push(`claimed=${this.start - aangemaakt}ms`);
+    }
+    markeer(fase) {
+        const nu = Date.now();
+        this.fasen.push(`${fase}=${nu - this.vorige}ms`);
+        this.vorige = nu;
+    }
+    samenvatting() {
+        return [...this.fasen, `totaal=${Date.now() - this.start}ms`].join(" ");
+    }
+}
+/**
+ * Verwerkt items met een vaste maximale gelijktijdigheid. Geen onbeperkte
+ * Promise.all: één trage of mislukte opdracht mag de rest niet meeslepen.
+ */
+async function metPool(items, max, fn) {
+    const uit = new Array(items.length);
+    let volgende = 0;
+    const werkers = Array.from({ length: Math.max(1, Math.min(max, items.length)) }, async () => {
+        for (;;) {
+            const i = volgende++;
+            if (i >= items.length)
+                return;
+            uit[i] = await fn(items[i]);
+        }
+    });
+    await Promise.all(werkers);
+    return uit;
+}
 async function verwerkJob(db, job) {
+    const klok = new Faseklok(job);
     try {
         // Dubbel printen voorkomen: deze opdracht staat al bij de printer.
         if (job.extern_job_id) {
@@ -650,26 +1134,29 @@ 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";
         }
         const keuze = klaar ? { layout: null, ontwerpWint: false } : await zoekLayout(db, job);
+        klok.markeer("layout_resolved");
         const layout = keuze.layout;
         const printerKeuze = await zoekPrinter(db, job, layout);
+        klok.markeer("printer_resolved");
         const printer = printerKeuze.printer;
         // Virtuele PDF-printer: geen PrintNode nodig; de PDF wordt bewaard.
         const isPdfPrinter = String(printer?.afdrukmethode ?? "") === "pdf";
@@ -701,26 +1188,38 @@ async function verwerkJob(db, job) {
                 landschap: liggend,
             });
         }
+        klok.markeer("rendered");
         // 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'.
+            // Bewaar de PDF één keer als binair artefact. De wachtrij en Realtime
+            // vervoeren daarna alleen metadata; de werkplek downloadt precies dit bestand.
+            const artefact = await bewaarPdfArtefact(db, String(job.id), pdfBase64);
+            // De opdracht blijft bewust op 'bezig' staan: hij is pas voltooid als de
+            // werkplek het bestand echt in de PDF-map heeft gezet. De lokale service
+            // zet daarna 'opgeslagen' + 'voltooid', of 'mislukt' met een leesbare zin.
             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",
+                status: "bezig",
+                verwerkingsfase: "pdf_gereed",
+                fase_voltooid_op: new Date().toISOString(),
+                foutcode: null,
                 lokale_pdf_status: "gereed",
+                lokale_pdf_print_plek_id: (await zoekPrintPlekId(db, job)) || null,
                 lokale_pdf_fout: null,
                 lokaal_opgeslagen_op: null,
                 foutmelding: null,
+                artefact_pad: artefact.pad,
+                artefact_sha256: artefact.sha256,
+                artefact_bytes: artefact.bytes,
+                artefact_gereed_op: new Date().toISOString(),
+                resultaat_pdf_base64: null,
                 volgende_poging: null,
-                voltooid_op: new Date().toISOString(),
                 updated_at: new Date().toISOString(),
             })
                 .eq("id", job.id);
@@ -728,23 +1227,8 @@ async function verwerkJob(db, job) {
                 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"}.`);
+            klok.markeer("pdf_ready");
+            await log(db, job.id, "pdf_gereed", `PDF gereed voor lokale opslag via ${printer.naam ?? "PDF-printer"}. ${klok.samenvatting()}`);
             return "verstuurd";
         }
         const formaten = await zorgVoorFormaten(db, printer);
@@ -768,15 +1252,23 @@ async function verwerkJob(db, job) {
             gebruikte_layout_id: uitkomst.bron === "extern_pdf" ? null : (layout?.id ?? null),
             gebruikte_bron: uitkomst.bron,
             extern_job_id: externJobId,
+            verwerkingsfase: "afleveren",
+            fase_voltooid_op: new Date().toISOString(),
+            foutcode: null,
             foutmelding: null,
             volgende_poging: null,
             updated_at: new Date().toISOString(),
         })
             .eq("id", job.id);
-        await log(db, job.id, "verstuurd", `Naar printer ${printer.naam ?? ""}. ${papier.uitleg}`);
+        klok.markeer("submitted");
+        await log(db, job.id, "verstuurd", `Naar printer ${printer.naam ?? ""}. ${papier.uitleg} ${klok.samenvatting()}`);
         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");
@@ -788,16 +1280,26 @@ async function verwerkJob(db, job) {
 const VERVAL_BEZIG_MIN = 30;
 /** Een claim zonder verzending mag hooguit zo lang blijven hangen. */
 const VERVAL_CLAIM_MIN = 10;
-/** Werkt de status bij van opdrachten die al naar een printer zijn gestuurd. */
+/** Hoeveel statuscontroles hooguit per ronde, en met welke gelijktijdigheid. */
+const STATUS_MAX_PER_RONDE = 12;
+const STATUS_PARALLEL = 3;
+/**
+ * Werkt de status bij van opdrachten die al naar een printer zijn gestuurd.
+ * Dit is historisch werk: het draait pas nadat nieuwe opdrachten zijn
+ * afgehandeld, met een begrensde pool en een vaste limiet per ronde.
+ */
 async function synchroniseerStatussen(db) {
     const { data } = await db
         .from("print_jobs")
         .select("id, extern_job_id, pogingen, opgepakt_op")
         .eq("status", "bezig")
         .not("extern_job_id", "is", null)
-        .limit(25);
-    let bijgewerkt = 0;
-    for (const job of arr(data)) {
+        .order("created_at", { ascending: true })
+        .limit(STATUS_MAX_PER_RONDE);
+    const jobs = arr(data);
+    if (!jobs.length)
+        return 0;
+    const uitkomsten = await metPool(jobs, STATUS_PARALLEL, async (job) => {
         try {
             const status = await opdrachtStatus(String(job.extern_job_id));
             if (status === "voltooid" || status === "mislukt") {
@@ -811,8 +1313,9 @@ async function synchroniseerStatussen(db) {
                 })
                     .eq("id", job.id);
                 await log(db, job.id, status);
-                bijgewerkt++;
+                return 1;
             }
+            return 0;
         }
         catch (e) {
             // Een onbereikbare printdienst mag niet stil blijven: tel hem als poging
@@ -828,9 +1331,10 @@ async function synchroniseerStatussen(db) {
                 .eq("id", job.id);
             await log(db, job.id, "status_onbekend", reden);
             console.warn(`[printwachtrij] status ophalen mislukt voor job ${job.id}: ${reden}`);
+            return 0;
         }
-    }
-    return bijgewerkt;
+    });
+    return uitkomsten.reduce((n, v) => n + v, 0);
 }
 /**
  * Vangnet voor opdrachten die blijven hangen op 'bezig'. Twee gevallen:
@@ -872,7 +1376,8 @@ async function vervalControle(db) {
         .select("id, pogingen")
         .eq("status", "bezig")
         .is("extern_job_id", null)
-        .neq("lokale_pdf_status", "gereed")
+        // PDF-opdrachten die op de werkplek wachten zijn niet vastgelopen.
+        .or("lokale_pdf_status.is.null,lokale_pdf_status.not.in.(wachtend,bezig,gereed)")
         .or(`opgepakt_op.lt.${grensClaim},and(opgepakt_op.is.null,updated_at.lt.${grensClaim})`)
         .limit(50);
     for (const job of arr(vastgelopen)) {
@@ -896,46 +1401,116 @@ async function vervalControle(db) {
     }
     return aantal;
 }
+/** Hoeveel opdrachten tegelijk worden gerenderd binnen één ronde. */
+const JOB_PARALLEL = 3;
+/** Zo lang mag één ronde het slot houden; daarna is hij vanzelf herstelbaar. */
+const LEASE_SECONDEN = 120;
+const LEASE_NAAM = "print-queue-worker";
+/** Rustpauze voordat een volgende ronde wordt gewekt. */
+const VERVOLG_COOLDOWN_MS = 1500;
+/**
+ * Wekt de wachtrij opnieuw, maar uitsluitend wanneer er aantoonbaar wachtend
+ * werk overblijft. Het adres van de runner staat in de database, nooit in code.
+ */
+async function wekVervolgRonde(db) {
+    const { count } = await db
+        .from("print_jobs")
+        .select("id", { count: "exact", head: true })
+        .eq("status", "wachtend")
+        .or(`volgende_poging.is.null,volgende_poging.lte.${new Date().toISOString()}`);
+    if (!count)
+        return;
+    await new Promise((r) => setTimeout(r, VERVOLG_COOLDOWN_MS));
+    const { error } = await db.rpc("wake_print_queue", { _min_interval_ms: 1000 });
+    if (error)
+        console.warn(`[printwachtrij] vervolgronde wekken mislukt: ${error.message}`);
+}
 /** Eén ronde: vastgelopen opdrachten opruimen, afdrukken en statussen bijwerken. */
 export async function verwerkWachtrij(db, max = 5) {
-    // Eerst het vangnet: dit draait ook als er niets te claimen valt.
+    const leeg = {
+        opgepakt: 0,
+        verstuurd: 0,
+        mislukt: 0,
+        wachtend: 0,
+        bijgewerkt: 0,
+    };
+    // Single-flight: hooguit één ronde tegelijk. Het slot verloopt vanzelf, dus
+    // een gecrashte ronde blokkeert de wachtrij nooit langer dan de leasetijd.
+    const houder = crypto.randomUUID();
+    const { data: slot, error: slotFout } = await db.rpc("claim_print_queue_lease", {
+        _naam: LEASE_NAAM,
+        _houder: houder,
+        _seconden: LEASE_SECONDEN,
+    });
+    if (slotFout)
+        throw new Error(`Printronde kon niet starten: ${slotFout.message}`);
+    if (slot !== true)
+        return { ...leeg, overgeslagen: "Er draait al een printronde." };
+    let vervolgNodig = false;
     try {
-        await vervalControle(db);
+        // Eerst het vangnet: dit draait ook als er niets te claimen valt.
+        try {
+            await vervalControle(db);
+        }
+        catch (e) {
+            console.warn(`[printwachtrij] vervalcontrole mislukt: ${e instanceof Error ? e.message : "onbekend"}`);
+        }
+        // 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);
+        }
+        // Begrensd parallel: meerdere pakbonnen van één order lopen gelijktijdig,
+        // maar één mislukte opdracht annuleert de andere nooit.
+        const jobs = [...pdfJobs, ...gewoneJobs];
+        const uitkomsten = await metPool(jobs, JOB_PARALLEL, async (job) => {
+            try {
+                return await verwerkJob(db, job);
+            }
+            catch (e) {
+                console.error(`[printwachtrij] opdracht ${job.id} viel onverwacht uit: ${e instanceof Error ? e.message : "onbekend"}`);
+                return "mislukt";
+            }
+        });
+        const resultaat = {
+            opgepakt: jobs.length,
+            verstuurd: uitkomsten.filter((u) => u === "verstuurd").length,
+            wachtend: uitkomsten.filter((u) => u === "wachtend").length,
+            mislukt: uitkomsten.filter((u) => u === "mislukt").length,
+            // Historische statuscontrole komt ná het nieuwe werk.
+            bijgewerkt: await synchroniseerStatussen(db),
+        };
+        // Alleen wanneer de batchlimiet vol zat kan er nog werk klaarstaan.
+        vervolgNodig = jobs.length >= max;
+        return resultaat;
     }
-    catch (e) {
-        console.warn(`[printwachtrij] vervalcontrole mislukt: ${e instanceof Error ? e.message : "onbekend"}`);
-    }
-    // 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 });
+    finally {
+        const { error } = await db.rpc("release_print_queue_lease", {
+            _naam: LEASE_NAAM,
+            _houder: houder,
+        });
         if (error)
-            throw new Error(error.message);
-        gewoneJobs = arr(data);
-    }
-    const jobs = [...pdfJobs, ...gewoneJobs];
-    let verstuurd = 0;
-    let mislukteJobs = 0;
-    for (const job of jobs) {
-        const uitkomst = await verwerkJob(db, job);
-        if (uitkomst === "verstuurd")
-            verstuurd++;
-        else
-            mislukteJobs++;
+            console.warn(`[printwachtrij] slot vrijgeven mislukt: ${error.message}`);
+        if (vervolgNodig) {
+            try {
+                await wekVervolgRonde(db);
+            }
+            catch (fout) {
+                const melding = fout instanceof Error ? fout.message : "onbekend";
+                console.warn(`[printwachtrij] vervolgronde mislukt: ${melding}`);
+            }
+        }
     }
-    return {
-        opgepakt: jobs.length,
-        verstuurd,
-        mislukt: mislukteJobs,
-        bijgewerkt: await synchroniseerStatussen(db),
-    };
 }
 /**
  * Dezelfde documentkeuze als de printwachtrij maakt, maar zonder printer en
@@ -944,16 +1519,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.");
     }