@flowselections/layout-maker 1.38.4 → 1.45.8

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

@@ -5,9 +5,10 @@
 // ============================================================================
 import { maakPakbonOrder, renderPakbonDocument, voorbeeldPakbonOrder, } from "./pakbonHtml.js";
 import { bouwPakbonScanInhoud, bewaarPakbonScanInhoud } from "./pakbonScan.js";
-import { pakbonLayoutVariant } from "./pakbonBuilder.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";
@@ -56,6 +57,13 @@ export class WachtOpLayoutFout extends Error {
         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
@@ -95,7 +103,17 @@ export function leesEngineLayoutId(job) {
 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]) {
+    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;
@@ -116,6 +134,59 @@ function isHerprint(job) {
     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 ?? {});
@@ -139,14 +210,15 @@ async function zoekHerprintLayoutId(db, job) {
     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)
+        .select("gebruikte_layout_id, documenttype, payload, created_at")
         .not("gebruikte_layout_id", "is", null)
         .order("created_at", { ascending: false })
-        .limit(10);
+        .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;
@@ -368,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. */
@@ -429,11 +530,12 @@ async function zoekPrinter(db, job, layout) {
         return data && data.actief !== false ? data : null;
     };
     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);
+    // 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();
@@ -629,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)
@@ -645,17 +781,38 @@ export async function bouwHtml(db, job, keuze, uitkomst) {
         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);
+        // 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);
-        // 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.
@@ -666,11 +823,38 @@ export async function bouwHtml(db, job, keuze, uitkomst) {
             ...(engineCart ? { cart: engineCart } : {}),
         });
         if (isEngineOpdracht(job)) {
-            const barcode = String(engineBarcode ?? "").trim();
+            let barcode = String(engineBarcode ?? "").trim();
             if (!barcode) {
-                throw new WachtOpLayoutFout("Wacht op barcode van de Logistics Engine: iedere kar moet een eigen pakbonbarcode krijgen.");
+                // 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 ?? ""))) ?? "";
             }
-            const cartId = String(engineCart?.cart_id ?? "").trim();
+            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)
@@ -681,10 +865,20 @@ export async function bouwHtml(db, job, keuze, uitkomst) {
             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.");
+            // 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,
@@ -713,7 +907,7 @@ export async function bouwHtml(db, job, keuze, uitkomst) {
         // 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,
+            barcode: order?.cart?.barcode ?? engineBarcode,
             layoutVariant: pakbonLayoutVariant(engineVariant),
             layoutId: String(layout.id ?? "") || null,
             printJobId: String(job.id ?? "") || null,
@@ -771,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
@@ -824,6 +1033,8 @@ async function wachtOpLayout(db, job, reden) {
         .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,
@@ -842,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(),
@@ -850,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) {
@@ -879,8 +1153,10 @@ async function verwerkJob(db, job) {
             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";
@@ -912,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);
@@ -939,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);
@@ -979,12 +1252,16 @@ 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) {
@@ -1003,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") {
@@ -1026,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
@@ -1043,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:
@@ -1087,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)) {
@@ -1111,50 +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);
-    }
-    catch (e) {
-        console.warn(`[printwachtrij] vervalcontrole mislukt: ${e instanceof Error ? e.message : "onbekend"}`);
+        // 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;
     }
-    // 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;
-    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++;
+            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,
-        wachtend,
-        bijgewerkt: await synchroniseerStatussen(db),
-    };
 }
 /**
  * Dezelfde documentkeuze als de printwachtrij maakt, maar zonder printer en