@flowselections/logistiek-engine 1.0.241 → 1.0.243

package/dist-lib/lib/handlers/logistics-tick.server.js

@@ -10,6 +10,7 @@
 // met SUPABASE_PUBLISHABLE_KEY / SUPABASE_ANON_KEY.
 // ============================================================================
 import { MODULE_VERSION } from "../moduleVersion.js";
+import { GEEN_WERKERS, werkersActief } from "../werkers.server.js";
 /** Herkenning in elk antwoord: de database ziet zo dat de Engine zelf antwoordde. */
 export function engineIdent(opts) {
     return { engine: "logistiek-engine", moduleVersion: MODULE_VERSION, moduleProject: opts?.moduleProject === true };
@@ -46,6 +47,8 @@ export async function handleLogisticsTick(request, supabase, opts) {
 export async function runLockedTickRound(supabase, ident) {
     // Alle databasetoegang loopt via de meegegeven client (geen gedeelde state).
     const { tickJob } = await import("../logisticsRecalcJob.server.js");
+    // Golf 1 stap 2: SQL-stappen die een databasewerker al doet, slaat deze ronde over.
+    const werkers = await werkersActief(supabase);
     // Hartslag: de schermen kunnen zo laten zien of de verwerking nog loopt.
     try {
         await supabase.rpc("logistics_tick_ping");
@@ -54,29 +57,32 @@ export async function runLockedTickRound(supabase, ident) {
         // Een ontbrekende hartslag mag de verwerking nooit tegenhouden.
     }
     // 1.0.172: ontbrekende standaardinstellingen aanvullen (bestaande waarden blijven).
-    try {
-        await supabase.rpc("logistics_ensure_runtime_defaults");
-    }
-    catch {
-        // Niet aanvullen = fail closed (verzendbrieven wachten); ronde loopt door.
-    }
+    if (!werkers.onderhoud)
+        try {
+            await supabase.rpc("logistics_ensure_runtime_defaults");
+        }
+        catch {
+            // Niet aanvullen = fail closed (verzendbrieven wachten); ronde loopt door.
+        }
     // 1.0.227: ontbrekende standaardgegevens (ladingdragers, Floriday-vertaling,
     // planinstellingen, tijdinstelling) aanvullen; schrijft niets als alles er is.
-    try {
-        await supabase.rpc("logistics_ensure_defaults");
-    }
-    catch {
-        // Ontbreekt de functie nog (schemasync), dan alleen geen zelfherstel.
-    }
+    if (!werkers.onderhoud)
+        try {
+            await supabase.rpc("logistics_ensure_defaults");
+        }
+        catch {
+            // Ontbreekt de functie nog (schemasync), dan alleen geen zelfherstel.
+        }
     // 1.0.194: "Opnieuw indelen bij wijziging" aanvullen gebeurt niet meer elke
     // ronde, maar hooguit 1x per uur in logistics_tick() (logistics_ensure_periodiek).
     // 1.0.190: open orders zonder kar opnieuw inplannen (max. 3 pogingen, daarna melding).
-    try {
-        await supabase.rpc("logistics_bewaak_zonder_kar");
-    }
-    catch {
-        // Ontbreekt de functie nog (schemasync), dan alleen geen bewaking.
-    }
+    if (!werkers.planning)
+        try {
+            await supabase.rpc("logistics_bewaak_zonder_kar");
+        }
+        catch {
+            // Ontbreekt de functie nog (schemasync), dan alleen geen bewaking.
+        }
     // Rondeslot: nooit twee tick-rondes tegelijk (minuut-cron én wek-aanroep
     // komen hier allebei binnen). Hergebruikt het bestaande planslot met
     // vervaltijd. Fail-closed: bij twijfel wordt de ronde overgeslagen; de
@@ -113,7 +119,7 @@ export async function runLockedTickRound(supabase, ident) {
         // Alleen meting; mag de ronde niet tegenhouden.
     }
     try {
-        return await runTickRound(supabase, tickJob, ident, roundStart);
+        return await runTickRound(supabase, tickJob, ident, roundStart, werkers);
     }
     finally {
         try {
@@ -129,10 +135,19 @@ export async function runLockedTickRound(supabase, ident) {
 }
 /** Vaste sleutel van het rondeslot; gelijk aan de check in logistics_plan_kick(). */
 export const TICK_ROUND_LOCK_KEY = "tick:ronde";
-async function runTickRound(supabase, tickJob, ident, roundStart = new Date().toISOString()) {
+/** Golf 1: hard budget van één HTTP-ronde (planwachtrij, karindeling, printen). */
+export const RONDE_BUDGET_MS = 20000;
+async function runTickRound(supabase, tickJob, ident, roundStart = new Date().toISOString(), werkers = { ...GEEN_WERKERS }) {
     const roundStartedMs = Date.now();
+    const VIA_WERKER = { via: "databasewerker" };
+    // Golf 1 (aanvulling A): hard budget voor de hele HTTP-ronde. Vóór elke stap
+    // wordt gekeken of er nog tijd is; wat niet past, loopt de volgende ronde.
+    const rondeEinde = roundStartedMs + RONDE_BUDGET_MS;
+    const resterend = () => rondeEinde - Date.now();
+    const UITGESTELD = { uitgesteld: "volgende ronde (tijdslimiet van de ronde bereikt)" };
+    const uitgesteld = [];
     // Meerdere batches per aanroep, met een ruime marge tot de time-out.
-    const deadline = Date.now() + 8000;
+    const deadline = Math.min(Date.now() + 8000, rondeEinde);
     let last = null;
     let ticks = 0;
     while (Date.now() < deadline) {
@@ -144,42 +159,45 @@ async function runTickRound(supabase, tickJob, ident, roundStart = new Date().to
             break;
     }
     // Ophaalmomenten rollend bijwerken vanuit de klantinstellingen (vervoerders).
-    let pickupMoments = null;
-    try {
-        const { data, error } = await supabase.rpc("logistics_refresh_pickup_moments", {
-            p_weeks: 4,
-        });
-        pickupMoments = error ? { error: error.message } : data;
-    }
-    catch (e) {
-        pickupMoments = { error: String(e?.message ?? e) };
-    }
+    let pickupMoments = werkers.planning ? VIA_WERKER : null;
+    if (!werkers.planning)
+        try {
+            const { data, error } = await supabase.rpc("logistics_refresh_pickup_moments", {
+                p_weeks: 4,
+            });
+            pickupMoments = error ? { error: error.message } : data;
+        }
+        catch (e) {
+            pickupMoments = { error: String(e?.message ?? e) };
+        }
     // Wees-taken van verwijderde orders afsluiten, zodat elke module dezelfde
     // verzameling orders ziet (één waarheid).
-    let orphans = null;
-    try {
-        const { data, error } = await supabase.rpc("logistics_cancel_orphan_tasks");
-        orphans = error ? { error: error.message } : data;
-    }
-    catch (e) {
-        orphans = { error: String(e?.message ?? e) };
-    }
+    let orphans = werkers.planning ? VIA_WERKER : null;
+    if (!werkers.planning)
+        try {
+            const { data, error } = await supabase.rpc("logistics_cancel_orphan_tasks");
+            orphans = error ? { error: error.message } : data;
+        }
+        catch (e) {
+            orphans = { error: String(e?.message ?? e) };
+        }
     // Vangnet: recente orders die nooit in de planwachtrij kwamen alsnog
     // aanmelden, zodat ze in deze zelfde ronde nog worden ingedeeld.
-    let reconciledOrders = null;
-    try {
-        const { data, error } = await supabase.rpc("logistics_reconcile_missing_plan_queue");
-        reconciledOrders = error ? { error: error.message } : data;
-    }
-    catch (e) {
-        reconciledOrders = { error: String(e?.message ?? e) };
-    }
+    let reconciledOrders = werkers.planning ? VIA_WERKER : null;
+    if (!werkers.planning)
+        try {
+            const { data, error } = await supabase.rpc("logistics_reconcile_missing_plan_queue");
+            reconciledOrders = error ? { error: error.message } : data;
+        }
+        catch (e) {
+            reconciledOrders = { error: String(e?.message ?? e) };
+        }
     // Planwachtrij: nieuwe/gewijzigde orders incrementeel indelen.
     let plan = null;
     let prune = null;
     try {
         const { runPlanQueue, prunePlanQueue } = await import("../planQueue.server.js");
-        plan = await runPlanQueue(supabase, { deadlineAt: Date.now() + 15000 });
+        plan = await runPlanQueue(supabase, { deadlineAt: Math.min(Date.now() + 15000, rondeEinde) });
         // M12: een wek-aanroep kan net vóór de order zichtbaar of vrij is binnenkomen
         // (rij nog vergrendeld door de aanmaakende transactie). Dan kort nawachten
         // in plaats van tot de volgende minuutronde te wachten. Begrensd: max. 3 x.
@@ -187,11 +205,13 @@ async function runTickRound(supabase, tickJob, ident, roundStart = new Date().to
             const claimed = Number(plan?.claimed ?? 0);
             if (claimed > 0)
                 break;
+            if (resterend() < 3000)
+                break;
             const { data: due, error: dueError } = await supabase.rpc("logistics_plan_due_count");
             if (dueError || Number(due ?? 0) === 0)
                 break;
             await new Promise((r) => setTimeout(r, 1500));
-            plan = await runPlanQueue(supabase, { deadlineAt: Date.now() + 15000 });
+            plan = await runPlanQueue(supabase, { deadlineAt: Math.min(Date.now() + 15000, rondeEinde) });
         }
         prune = await prunePlanQueue(supabase);
     }
@@ -211,16 +231,17 @@ async function runTickRound(supabase, tickJob, ident, roundStart = new Date().to
     // Afgehandelde orderbuffers sluiten, dat melden aan de andere modules en
     // orders die er ná de afhandeling in kwamen weer losmaken (fail closed:
     // karren met print-, scan- of controlebewijs blijven ongemoeid).
-    let buffers = null;
-    try {
-        const { data, error } = await supabase.rpc("logistics_buffer_detach_late_orders", {
-            p_buffer: null,
-        });
-        buffers = error ? { error: error.message } : data;
-    }
-    catch (e) {
-        buffers = { error: String(e?.message ?? e) };
-    }
+    let buffers = werkers.planning ? VIA_WERKER : null;
+    if (!werkers.planning)
+        try {
+            const { data, error } = await supabase.rpc("logistics_buffer_detach_late_orders", {
+                p_buffer: null,
+            });
+            buffers = error ? { error: error.message } : data;
+        }
+        catch (e) {
+            buffers = { error: String(e?.message ?? e) };
+        }
     // 1.0.194: de pickwachtrij wordt elke minuut in logistics_tick() (SQL) gevuld
     // en direct na elke indeling door de planwachtrij; niet meer in deze HTTP-ronde.
     const queueRefresh = "in_sql_ronde";
@@ -236,165 +257,210 @@ async function runTickRound(supabase, tickJob, ident, roundStart = new Date().to
     }
     // Floriday-pushwachtrij verwerken binnen dezelfde aanroep, met eigen marge.
     let push = null;
-    try {
-        const { runFloridayPushQueue, maybePruneFloridayPushes } = await import("../floridayPush.server.js");
-        push = await runFloridayPushQueue(supabase, { deadlineAt: Date.now() + 8000 });
-        await maybePruneFloridayPushes(supabase);
-    }
-    catch (e) {
-        push = { error: String(e?.message ?? e) };
+    if (resterend() <= 0) {
+        push = UITGESTELD;
+        uitgesteld.push("Floriday-pushwachtrij");
     }
+    else
+        try {
+            const { runFloridayPushQueue, maybePruneFloridayPushes } = await import("../floridayPush.server.js");
+            push = await runFloridayPushQueue(supabase, { deadlineAt: Math.min(Date.now() + 8000, rondeEinde) });
+            await maybePruneFloridayPushes(supabase);
+        }
+        catch (e) {
+            push = { error: String(e?.message ?? e) };
+        }
     // Controlepost: goedgekeurde scans afronden met de juiste afleverbrief.
     let control = null;
-    try {
-        const { runControlScanQueue } = await import("../controlScan.server.js");
-        control = await runControlScanQueue(supabase, { limit: 10 });
-    }
-    catch (e) {
-        control = { error: String(e?.message ?? e) };
+    if (resterend() <= 0) {
+        control = UITGESTELD;
+        uitgesteld.push("Controlepost");
     }
+    else
+        try {
+            const { runControlScanQueue } = await import("../controlScan.server.js");
+            control = await runControlScanQueue(supabase, { limit: 10 });
+        }
+        catch (e) {
+            control = { error: String(e?.message ?? e) };
+        }
     // Verzendbrief die meelift met een geprinte pakbon (Floriday-orders).
     // Deze verwerking is verplicht: ontbreekt zij, dan is de draaiende versie te
     // oud en moet de tick dat als fout melden in plaats van "succes".
     let shippingNotes = null;
     let shippingNotesOk = false;
     let shippingNotesBackfill = null;
-    try {
-        // Inhaalslag: pakbonnen die al in het pickstation staan alsnog van een
-        // verzendbrief voorzien. Idempotent, dus veilig bij elke tick.
-        const { data: backfill } = await supabase.rpc("logistics_ensure_shipping_notes", {
-            p_limit: 200,
-        });
-        shippingNotesBackfill = backfill ?? null;
-        // 1.0.168: verzendstatus van voorraadmails overnemen uit de outbox.
-        try {
-            await supabase.rpc("logistics_sync_stock_alert_email_status", { p_limit: 500 });
-        }
-        catch {
-            /* mag de ronde niet blokkeren */
-        }
-        // Zelfherstel: een eigen verzendbrief die bij een Floriday-order hoort wordt
-        // geannuleerd en vervangen door de officiele Floriday-aanvraag.
-        try {
-            await supabase.rpc("logistics_fix_wrong_shipping_notes");
-        }
-        catch {
-            /* zelfherstel mag de ronde niet blokkeren */
-        }
-        // Vrijgeven (alleen database): wachtende aanvragen van orders met een
-        // goedgekeurde controlescan, zodra de poort het aanmaken toestaat.
+    if (resterend() <= 0) {
+        // Tijdslimiet bereikt: geen fout, de verzendbrieven volgen in de volgende ronde.
+        shippingNotes = { ...UITGESTELD };
+        shippingNotesOk = true;
+        uitgesteld.push("Verzendbrieven");
+    }
+    else
         try {
-            await supabase.rpc("logistics_shipping_note_release", { _order_number: null });
-        }
-        catch {
-            /* vrijgeven mag de ronde niet blokkeren */
+            // Inhaalslag: pakbonnen die al in het pickstation staan alsnog van een
+            // verzendbrief voorzien. Idempotent, dus veilig bij elke tick.
+            if (werkers.pickwachtrij) {
+                shippingNotesBackfill = VIA_WERKER;
+            }
+            else {
+                const { data: backfill } = await supabase.rpc("logistics_ensure_shipping_notes", {
+                    p_limit: 200,
+                });
+                shippingNotesBackfill = backfill ?? null;
+                // 1.0.168: verzendstatus van voorraadmails overnemen uit de outbox.
+                try {
+                    await supabase.rpc("logistics_sync_stock_alert_email_status", { p_limit: 500 });
+                }
+                catch {
+                    /* mag de ronde niet blokkeren */
+                }
+                // Zelfherstel: een eigen verzendbrief die bij een Floriday-order hoort wordt
+                // geannuleerd en vervangen door de officiele Floriday-aanvraag.
+                try {
+                    await supabase.rpc("logistics_fix_wrong_shipping_notes");
+                }
+                catch {
+                    /* zelfherstel mag de ronde niet blokkeren */
+                }
+                // Vrijgeven (alleen database): wachtende aanvragen van orders met een
+                // goedgekeurde controlescan, zodra de poort het aanmaken toestaat.
+                try {
+                    await supabase.rpc("logistics_shipping_note_release", { _order_number: null });
+                }
+                catch {
+                    /* vrijgeven mag de ronde niet blokkeren */
+                }
+                // 1.0.153: belading door Floriday geaccepteerd (op welke manier ook
+                // verstuurd)? Dan per kar een verzendbriefaanvraag klaarzetten.
+                try {
+                    await supabase.rpc("logistics_shipping_note_ensure_accepted", { p_order_id: null, p_limit: 100 });
+                }
+                catch {
+                    /* mag de ronde niet blokkeren */
+                }
+            }
+            const { runShippingNoteQueue } = await import("../shippingNoteQueue.server.js");
+            if (typeof runShippingNoteQueue !== "function") {
+                throw new Error("Deze versie van de Logistiek Engine bevat geen verzendbriefverwerking. Werk de module bij.");
+            }
+            const result = (await runShippingNoteQueue(supabase, { limit: 10 }));
+            const verwacht = ["claimed", "printed", "waiting", "retrying", "failed"];
+            const ontbreekt = verwacht.filter((k) => typeof result?.[k] !== "number");
+            if (ontbreekt.length > 0) {
+                throw new Error(`De verzendbriefverwerking levert geen volledige telling (mist: ${ontbreekt.join(", ")}). Werk de module bij.`);
+            }
+            shippingNotes = {
+                found: result["claimed"],
+                printed: result["printed"],
+                waitingForFloriday: result["waiting"],
+                retrying: result["retrying"],
+                failed: result["failed"],
+                printJobsCreated: result["printed"],
+                backfill: shippingNotesBackfill,
+                errors: result["errors"] ?? [],
+            };
+            shippingNotesOk = true;
         }
-        // 1.0.153: belading door Floriday geaccepteerd (op welke manier ook
-        // verstuurd)? Dan per kar een verzendbriefaanvraag klaarzetten.
-        try {
-            await supabase.rpc("logistics_shipping_note_ensure_accepted", { p_order_id: null, p_limit: 100 });
+        catch (e) {
+            shippingNotes = { error: String(e?.message ?? e) };
+            shippingNotesOk = false;
         }
-        catch {
-            /* mag de ronde niet blokkeren */
-        }
-        const { runShippingNoteQueue } = await import("../shippingNoteQueue.server.js");
-        if (typeof runShippingNoteQueue !== "function") {
-            throw new Error("Deze versie van de Logistiek Engine bevat geen verzendbriefverwerking. Werk de module bij.");
-        }
-        const result = (await runShippingNoteQueue(supabase, { limit: 10 }));
-        const verwacht = ["claimed", "printed", "waiting", "retrying", "failed"];
-        const ontbreekt = verwacht.filter((k) => typeof result?.[k] !== "number");
-        if (ontbreekt.length > 0) {
-            throw new Error(`De verzendbriefverwerking levert geen volledige telling (mist: ${ontbreekt.join(", ")}). Werk de module bij.`);
-        }
-        shippingNotes = {
-            found: result["claimed"],
-            printed: result["printed"],
-            waitingForFloriday: result["waiting"],
-            retrying: result["retrying"],
-            failed: result["failed"],
-            printJobsCreated: result["printed"],
-            backfill: shippingNotesBackfill,
-            errors: result["errors"] ?? [],
-        };
-        shippingNotesOk = true;
-    }
-    catch (e) {
-        shippingNotes = { error: String(e?.message ?? e) };
-        shippingNotesOk = false;
-    }
     // Stickerronde: klant- en tray-stickers (Engine is eigenaar).
     let stickers = null;
-    try {
-        const { runStickerQueue } = await import("../stickerQueue.server.js");
-        stickers = await runStickerQueue(supabase, { limit: 10 });
-    }
-    catch (e) {
-        stickers = { error: String(e?.message ?? e) };
+    if (resterend() <= 0) {
+        stickers = UITGESTELD;
+        uitgesteld.push("Stickerronde");
     }
+    else
+        try {
+            const { runStickerQueue } = await import("../stickerQueue.server.js");
+            stickers = await runStickerQueue(supabase, { limit: 10 });
+        }
+        catch (e) {
+            stickers = { error: String(e?.message ?? e) };
+        }
     // Automatisch versturen (1.0.149): alleen Floriday-orders, alleen als de werkwijze het aanzet.
     let autoSend = null;
-    try {
-        const { runAutoSendQueue } = await import("../autoSend.server.js");
-        autoSend = await runAutoSendQueue(supabase, { limit: 10 });
-    }
-    catch (e) {
-        autoSend = { error: String(e?.message ?? e) };
+    if (resterend() <= 0) {
+        autoSend = UITGESTELD;
+        uitgesteld.push("Automatisch versturen");
     }
+    else
+        try {
+            const { runAutoSendQueue } = await import("../autoSend.server.js");
+            autoSend = await runAutoSendQueue(supabase, { limit: 10 });
+        }
+        catch (e) {
+            autoSend = { error: String(e?.message ?? e) };
+        }
     // Seintjes van de pickschermen: karplan ontbreekt. Direct oppakken.
     let cartPlanRequests = null;
-    try {
-        const { runCartPlanRequests } = await import("../cartPlanRequests.server.js");
-        cartPlanRequests = await runCartPlanRequests(supabase, { limit: 20 });
-    }
-    catch (e) {
-        cartPlanRequests = { error: String(e?.message ?? e) };
+    if (resterend() <= 0) {
+        cartPlanRequests = UITGESTELD;
+        uitgesteld.push("Seintjes pickschermen");
     }
+    else
+        try {
+            const { runCartPlanRequests } = await import("../cartPlanRequests.server.js");
+            cartPlanRequests = await runCartPlanRequests(supabase, { limit: 20 });
+        }
+        catch (e) {
+            cartPlanRequests = { error: String(e?.message ?? e) };
+        }
     // In de karwerkwijze vervangen concrete karregels de oude orderregel. Een
     // reeds geprinte orderregel blijft als historie bestaan, maar mag niet meer
     // als actieve printregel met een verouderde status op het scherm staan.
     let queueCleanup = null;
-    try {
-        const { retireSupersededOrderRows } = await import("../pickQueueCleanup.server.js");
-        queueCleanup = await retireSupersededOrderRows(supabase);
-    }
-    catch (e) {
-        queueCleanup = { error: String(e?.message ?? e) };
+    if (resterend() <= 0) {
+        queueCleanup = UITGESTELD;
+        uitgesteld.push("Oude orderregels in pickwachtrij");
     }
+    else
+        try {
+            const { retireSupersededOrderRows } = await import("../pickQueueCleanup.server.js");
+            queueCleanup = await retireSupersededOrderRows(supabase);
+        }
+        catch (e) {
+            queueCleanup = { error: String(e?.message ?? e) };
+        }
     // Blokkades van verzonden orders sluiten, niet-geleverde verlopen orders
     // archiveren en meldingen sluiten waarvan de oorzaak weg is.
-    let housekeeping = null;
-    try {
-        const { data, error } = await supabase.rpc("logistics_plan_housekeeping");
-        housekeeping = error ? { error: error.message } : data;
-    }
-    catch (e) {
-        housekeeping = { error: String(e?.message ?? e) };
-    }
+    let housekeeping = werkers.planning ? VIA_WERKER : null;
+    if (!werkers.planning)
+        try {
+            const { data, error } = await supabase.rpc("logistics_plan_housekeeping");
+            housekeeping = error ? { error: error.message } : data;
+        }
+        catch (e) {
+            housekeeping = { error: String(e?.message ?? e) };
+        }
     // Pakbonnen zonder kar, of van een kar die na een herindeling niet meer
     // bestaat, kunnen nooit een barcode krijgen. Die worden hier afgesloten met
     // een leesbare reden in plaats van eeuwig te blijven wachten.
-    let orphanPrintJobs = null;
-    try {
-        const { data, error } = await supabase.rpc("logistics_cleanup_orphan_print_jobs");
-        orphanPrintJobs = error ? { error: error.message } : data;
-    }
-    catch (e) {
-        orphanPrintJobs = { error: String(e?.message ?? e) };
-    }
+    let orphanPrintJobs = werkers.pickwachtrij ? VIA_WERKER : null;
+    if (!werkers.pickwachtrij)
+        try {
+            const { data, error } = await supabase.rpc("logistics_cleanup_orphan_print_jobs");
+            orphanPrintJobs = error ? { error: error.message } : data;
+        }
+        catch (e) {
+            orphanPrintJobs = { error: String(e?.message ?? e) };
+        }
     // Barcodeverzoeken van de Layout maker: de Engine bepaalt de kar en levert
     // de vaste barcode terug in het verzoek én in de printopdracht. Kan het
     // niet, dan wordt het verzoek geannuleerd met een reden (fail closed).
-    let barcodes = null;
-    try {
-        const { data, error } = await supabase.rpc("logistics_fulfill_barcode_requests", {
-            p_limit: 100,
-        });
-        barcodes = error ? { error: error.message } : data;
-    }
-    catch (e) {
-        barcodes = { error: String(e?.message ?? e) };
-    }
+    let barcodes = werkers.pickwachtrij ? VIA_WERKER : null;
+    if (!werkers.pickwachtrij)
+        try {
+            const { data, error } = await supabase.rpc("logistics_fulfill_barcode_requests", {
+                p_limit: 100,
+            });
+            barcodes = error ? { error: error.message } : data;
+        }
+        catch (e) {
+            barcodes = { error: String(e?.message ?? e) };
+        }
     // 1.0.194: laadtoestand draait in logistics_tick() (SQL), alleen bij wijziging.
     const planState = "in_sql_ronde";
     // 1.0.194 (B1): kwam er tijdens deze ronde een wek-aanroep binnen, dan nog
@@ -405,9 +471,14 @@ async function runTickRound(supabase, tickJob, ident, roundStart = new Date().to
         if (pendingError) {
             kickPending = { error: pendingError.message };
         }
+        else if (pending === true && resterend() < 2000) {
+            // Geen tijd meer: de wek-aanroep wordt in de volgende ronde opgepakt.
+            kickPending = { extraRonde: false, ...UITGESTELD };
+            uitgesteld.push("Extra indeelronde na wek-aanroep");
+        }
         else if (pending === true) {
             const { runPlanQueue } = await import("../planQueue.server.js");
-            kickPending = { extraRonde: await runPlanQueue(supabase, { deadlineAt: Date.now() + 10000 }) };
+            kickPending = { extraRonde: await runPlanQueue(supabase, { deadlineAt: Math.min(Date.now() + 10000, rondeEinde) }) };
         }
         else {
             kickPending = { extraRonde: false };
@@ -433,6 +504,8 @@ async function runTickRound(supabase, tickJob, ident, roundStart = new Date().to
                 stickerSyncFouten,
                 kickPending,
                 shippingNotesOk,
+                werkers,
+                uitgesteld,
             },
         });
     }
@@ -442,6 +515,8 @@ async function runTickRound(supabase, tickJob, ident, roundStart = new Date().to
     return Response.json({
         ...ident,
         ok: shippingNotesOk,
+        werkers,
+        uitgesteld,
         stickerSyncFouten,
         kickPending,
         planState,

package/dist-lib/lib/karindelingBewakingTeksten.d.ts

@@ -0,0 +1,9 @@
+export type KarindelingBewaking = {
+    achterstand?: number;
+    productmatenMs?: number | null;
+    tijdelijkOpnieuw?: number;
+    herstelTijdelijk?: number | null;
+};
+export declare function karindelingMeldingen(info: KarindelingBewaking): string[];
+export declare function karindelingInfo(info: KarindelingBewaking): string[];
+//# sourceMappingURL=karindelingBewakingTeksten.d.ts.map

package/dist-lib/lib/karindelingBewakingTeksten.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"karindelingBewakingTeksten.d.ts","sourceRoot":"","sources":["../../src/lib/karindelingBewakingTeksten.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,mBAAmB,GAAG,MAAM,EAAE,CAYxE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,MAAM,EAAE,CAWnE"}

package/dist-lib/lib/karindelingBewakingTeksten.js

@@ -0,0 +1,26 @@
+// Meldingen in gewone taal voor de bewaking van de karindeling in Engine-status (alleen beheer).
+export function karindelingMeldingen(info) {
+    const uit = [];
+    const achter = Number(info.achterstand ?? 0);
+    if (achter > 0) {
+        uit.push(`De karindeling loopt achter: ${achter} ${achter === 1 ? "order wacht" : "orders wachten"} langer dan 10 minuten.`);
+    }
+    const ms = Number(info.productmatenMs ?? 0);
+    if (ms > 3000) {
+        const s = (ms / 1000).toFixed(1).replace(".", ",");
+        uit.push(`Het lezen van productmaten duurt te lang (${s} s).`);
+    }
+    return uit;
+}
+export function karindelingInfo(info) {
+    const uit = [];
+    const opnieuw = Number(info.tijdelijkOpnieuw ?? 0);
+    if (opnieuw > 0) {
+        uit.push(`${opnieuw} ${opnieuw === 1 ? "order wordt" : "orders worden"} na een tijdslimiet automatisch opnieuw ingedeeld.`);
+    }
+    const herstel = Number(info.herstelTijdelijk ?? 0);
+    if (herstel > 0) {
+        uit.push(`Bij de update ${herstel === 1 ? "is 1 order" : `zijn ${herstel} orders`} die door een tijdslimiet vaststond${herstel === 1 ? "" : "en"} opnieuw aangeboden.`);
+    }
+    return uit;
+}