@flowselections/logistiek-engine 1.0.53 → 1.0.90

package/dist-lib/lib/flowTree.js

@@ -119,7 +119,7 @@ function weakest(a, b) {
     return rank[a] >= rank[b] ? a : b;
 }
 /** Bouwt de complete beslisboom van binnenkomst tot afgehandelde order. */
-export function buildFlowTree(settings) {
+export function buildFlowTree(settings, overrides) {
     const veilig = settings && typeof settings === "object" ? settings : {};
     const nodes = [];
     const edges = [];
@@ -274,6 +274,32 @@ export function buildFlowTree(settings) {
             decisionIds,
             pendingRefs,
         };
+        // ── Klaar om te picken ───────────────────────────────────────────────────
+        // Vlak vóór het pickscherm: pas doorlopen als alle documenten die volgens
+        // de instellingen nodig zijn ook echt klaarstaan. Documenten die deze order
+        // niet nodig heeft, tellen meteen als klaar.
+        if (step.id === "pickstations") {
+            add({
+                id: "stap:klaar_om_te_picken",
+                kind: "step",
+                label: "Klaar om te picken",
+                sublabel: "staan alle benodigde documenten klaar?",
+                state: "active",
+                lines: [
+                    "Pakbon: elke kar heeft een barcode",
+                    "Verzendbrief: alleen als die samen met de pakbon geprint wordt",
+                    "Stickers: alleen als deze order stickers heeft",
+                    "Niet nodig telt meteen als klaar",
+                ],
+                help: [
+                    "De order komt pas op het pickscherm als alle verplichte documenten van deze order klaarstaan.",
+                    "Ontbreekt er iets, dan wacht de order hier met vermelding van wat er nog mist.",
+                    "Kan de controle niet worden uitgevoerd, dan blijft de order bewust wachten.",
+                ],
+            });
+            link(tail, "stap:klaar_om_te_picken", "active");
+            tail = "stap:klaar_om_te_picken";
+        }
         const stepNode = add({
             id: `stap:${step.id}`,
             kind: "step",
@@ -293,6 +319,45 @@ export function buildFlowTree(settings) {
         fan(ctx, stepNode.id, "active", roots, [], stapMerge);
         nodes.push({ id: stapMerge, kind: "merge", label: "", state: "active", ancestors: [], help: [], w: NODE_SIZE.merge.w, h: NODE_SIZE.merge.h });
         tail = stapMerge;
+        // ── Terugmelding uit de pickstraat: geprint en afgemeld ──────────────────
+        // Twee eigen vakjes, zodat in één oogopslag zichtbaar is of de pakbonnen
+        // echt uit de printer zijn gekomen en of de karren zijn afgemeld.
+        if (step.id === "pickstations") {
+            add({
+                id: "stap:pakbon_geprint",
+                kind: "step",
+                label: "Pakbon geprint",
+                sublabel: "is de pakbon echt uit de printer gekomen?",
+                state: "active",
+                lines: [
+                    "Ja: er staat een printmoment vastgelegd op de pakbonregel",
+                    "Nee: er is nog niets geprint voor deze order",
+                    "Printen verandert de status van de order niet",
+                ],
+                help: [
+                    "Dit vakje laat alleen zien of de pakbonnen en verzendbrieven van deze order geprint zijn, en hoeveel van het totaal.",
+                    "Het printmoment komt uit de pickstraat zelf; er wordt hier niets geprint en geen status gewijzigd.",
+                ],
+            });
+            link(tail, "stap:pakbon_geprint", "active");
+            add({
+                id: "stap:kar_afgemeld",
+                kind: "step",
+                label: "Kar afgemeld",
+                sublabel: "is de kar afgemeld op het pickscherm?",
+                state: "active",
+                lines: [
+                    "Ja: alle pakbonregels van de order zijn afgerond",
+                    "Nee: er staan nog karren open op het pickscherm",
+                ],
+                help: [
+                    "Dit vakje laat zien of de karren van deze order zijn afgemeld, met de stand (bijvoorbeeld 0 van 2).",
+                    "Zolang er nog een kar openstaat, wacht de order hier; er wordt niets afgemeld vanuit dit vakje.",
+                ],
+            });
+            link("stap:pakbon_geprint", "stap:kar_afgemeld", "active");
+            tail = "stap:kar_afgemeld";
+        }
     });
     // ── Einde ──────────────────────────────────────────────────────────────────
     add({
@@ -320,7 +385,210 @@ export function buildFlowTree(settings) {
             : undefined;
         link(from, ref.toNode, ref.state, label, ref.ancestors, "ref");
     }
-    return { nodes, edges };
+    // Ruitjes met een eigen voorwaarde blijven staan: die hebben betekenis.
+    const behoud = new Set(Object.entries(overrides ?? {})
+        .filter(([, k]) => k && ((k.wanneer ?? "een") !== "een" || k.verwijderd))
+        .map(([id]) => id));
+    return vereenvoudigMerges({ nodes, edges }, behoud);
+}
+/** Standaard vangnet: na een half uur gaat de flow alsnog verder. */
+export const MERGE_MAX_WACHT_MINUTEN = 30;
+function lijnNaam(tree, edge) {
+    const n = tree.nodes.find((x) => x.id === edge.from);
+    const basis = n?.label ? n.label : n?.kind === "merge" ? "samenkomst" : edge.from;
+    return edge.label ? `${basis} — ${edge.label}` : basis;
+}
+/**
+ * De voorwaarde van één samenkomstpunt, met de lijnen die meetellen.
+ * Lijnen die volgens de huidige werkwijze uitgeschakeld zijn of op "Stopt hier"
+ * staan tellen nooit mee: een tak die nooit gelopen kan worden mag de flow niet
+ * tegenhouden.
+ */
+export function mergeVoorwaarde(tree, mergeId, override) {
+    const standen = override?.lijnen ?? {};
+    const lijnen = (Array.isArray(tree?.edges) ? tree.edges : [])
+        .filter((e) => e.kind === "flow" && e.to === mergeId)
+        .map((e) => ({
+        id: e.id,
+        from: e.from,
+        naam: lijnNaam(tree, e),
+        telt: e.state !== "disabled" && standen[e.id] !== "stop",
+    }));
+    // Sluiten de meetellende lijnen elkaar uit? Dat is zo wanneer ze onder
+    // verschillende takken van dezelfde bovenliggende keuze (of verschillende
+    // herkomsten) hangen: geen enkele order loopt via meer dan één van die takken.
+    const meetellend = lijnen.filter((l) => l.telt);
+    let uitsluitend = false;
+    if (meetellend.length >= 2) {
+        const knopen = Array.isArray(tree?.nodes) ? tree.nodes : [];
+        const eigenaar = mergeId === "__bron_merge"
+            ? "__bron"
+            : mergeId.startsWith("samen:") && !mergeId.startsWith("samen:stap:")
+                ? (knopen.find((n) => n.kind === "decision" && n.mergeId === mergeId)?.id ?? null)
+                : null;
+        if (eigenaar) {
+            const naar = new Map();
+            for (const e of Array.isArray(tree?.edges) ? tree.edges : []) {
+                if (e.kind !== "flow")
+                    continue;
+                const lijst = naar.get(e.to);
+                if (lijst)
+                    lijst.push(e.from);
+                else
+                    naar.set(e.to, [e.from]);
+            }
+            // Welke directe takken van de eigenaar kunnen dit vakje bereiken?
+            const takkenVoor = (van) => {
+                const takken = new Set();
+                const gezien = new Set([van]);
+                const rij = [van];
+                while (rij.length > 0) {
+                    const cur = rij.shift();
+                    for (const vorige of naar.get(cur) ?? []) {
+                        if (vorige === eigenaar) {
+                            takken.add(cur);
+                            continue;
+                        }
+                        if (gezien.has(vorige))
+                            continue;
+                        gezien.add(vorige);
+                        rij.push(vorige);
+                    }
+                }
+                return takken;
+            };
+            const sets = meetellend.map((l) => takkenVoor(l.from));
+            // Alleen concluderen als elke lijn onder de eigenaar hangt.
+            if (sets.every((s) => s.size > 0)) {
+                const gemeenschappelijk = sets.reduce((a, b) => {
+                    const over = new Set();
+                    for (const x of a)
+                        if (b.has(x))
+                            over.add(x);
+                    return over;
+                });
+                uitsluitend = gemeenschappelijk.size === 0;
+            }
+        }
+    }
+    const gevraagd = override?.wanneer ?? "een";
+    const verplicht = override?.verplichteLijn ?? null;
+    const geldig = verplicht ? lijnen.find((l) => l.id === verplicht && l.telt) : undefined;
+    const terugval = (gevraagd === "specifiek" && !geldig) || (gevraagd === "alle" && uitsluitend);
+    const wanneer = terugval ? "een" : gevraagd;
+    const minuten = Number(override?.maxWachtMinuten);
+    const maxWachtMinuten = Number.isFinite(minuten) && minuten > 0 ? Math.round(minuten) : MERGE_MAX_WACHT_MINUTEN;
+    const label = wanneer === "alle" ? "alle lijnen" : wanneer === "specifiek" ? (geldig?.naam ?? "één lijn") : "één lijn";
+    return {
+        wanneer,
+        lijnen,
+        verplichteLijn: wanneer === "specifiek" ? (geldig?.id ?? null) : null,
+        maxWachtMinuten,
+        terugval,
+        uitsluitend,
+        label,
+    };
+}
+/** Ruitjes die de kaart altijd nodig heeft om de route heel te houden. */
+function vastRuitje(id) {
+    return id.startsWith("samen:stap:") || id === "__bron_merge";
+}
+/** Eén ruitje uit de kaart halen: inkomende en uitgaande lijnen aan elkaar knopen. */
+function haalMergeWeg(tree, mergeId, lijnen) {
+    const node = tree.nodes.find((n) => n.id === mergeId);
+    if (!node || node.kind !== "merge")
+        return tree;
+    const inkomend = tree.edges.filter((e) => e.kind === "flow" && e.to === mergeId);
+    const uitgaand = tree.edges.filter((e) => e.kind === "flow" && e.from === mergeId);
+    const rest = tree.edges.filter((e) => e.from !== mergeId && e.to !== mergeId);
+    const nieuw = [];
+    for (const i of inkomend) {
+        if (lijnen[i.id] === "stop")
+            continue;
+        for (const u of uitgaand) {
+            const label = i.label ?? u.label;
+            const id = `flow:${i.from}->${u.to}:${label ?? ""}`;
+            if (nieuw.some((e) => e.id === id) || rest.some((e) => e.id === id))
+                continue;
+            nieuw.push({
+                id,
+                from: i.from,
+                to: u.to,
+                label,
+                state: weakest(i.state, u.state),
+                kind: "flow",
+                ancestors: i.ancestors,
+            });
+        }
+    }
+    const vervanger = uitgaand[0]?.to;
+    const nodes = tree.nodes
+        .filter((n) => n.id !== mergeId)
+        .map((n) => (n.mergeId === mergeId ? { ...n, mergeId: vervanger } : n));
+    return { nodes, edges: [...rest, ...nieuw] };
+}
+/**
+ * Overbodige ruitjes wegrekenen: een ruitje met één lijn erin en één lijn eruit
+ * voegt niets toe, en een ruitje waar niets meer op uitkomt hoort er niet te
+ * staan. De vaste verzamelpunten per stap blijven altijd staan.
+ */
+export function vereenvoudigMerges(tree, behoud) {
+    let huidig = { nodes: [...(tree?.nodes ?? [])], edges: [...(tree?.edges ?? [])] };
+    for (let ronde = 0; ronde < 20; ronde++) {
+        const kandidaat = huidig.nodes.find((n) => {
+            if (n.kind !== "merge" || vastRuitje(n.id) || behoud?.has(n.id))
+                return false;
+            const inkomend = huidig.edges.filter((e) => e.kind === "flow" && e.to === n.id).length;
+            const uitgaand = huidig.edges.filter((e) => e.kind === "flow" && e.from === n.id).length;
+            return inkomend <= 1 && uitgaand <= 1;
+        });
+        if (!kandidaat)
+            break;
+        huidig = haalMergeWeg(huidig, kandidaat.id, {});
+    }
+    return huidig;
+}
+/** Handmatige keuzes van de gebruiker op de ruitjes toepassen. */
+export function pasMergeOverridesToe(tree, overrides) {
+    if (!overrides || typeof overrides !== "object")
+        return tree;
+    let huidig = { nodes: [...(tree?.nodes ?? [])], edges: [...(tree?.edges ?? [])] };
+    for (const [mergeId, keuze] of Object.entries(overrides)) {
+        if (!keuze || typeof keuze !== "object")
+            continue;
+        const lijnen = keuze.lijnen ?? {};
+        if (keuze.verwijderd) {
+            if (vastRuitje(mergeId))
+                continue;
+            huidig = haalMergeWeg(huidig, mergeId, lijnen);
+            continue;
+        }
+        // Ruitje blijft staan: gesloten lijnen lopen niet door.
+        huidig = {
+            nodes: huidig.nodes,
+            edges: huidig.edges.map((e) => e.to === mergeId && lijnen[e.id] === "stop" ? { ...e, state: "disabled" } : e),
+        };
+    }
+    // Voorwaarde per ruitje op de knoop zetten, zodat de kaart en de route met
+    // dezelfde gegevens werken.
+    const metWacht = huidig.nodes.map((n) => {
+        if (n.kind !== "merge")
+            return n;
+        const keuze = overrides[n.id];
+        if (!keuze || (keuze.wanneer ?? "een") === "een")
+            return n.wacht ? { ...n, wacht: undefined } : n;
+        const v = mergeVoorwaarde(huidig, n.id, keuze);
+        if (v.wanneer === "een")
+            return n.wacht ? { ...n, wacht: undefined } : n;
+        const wacht = {
+            wanneer: v.wanneer,
+            verplichteLijn: v.verplichteLijn,
+            maxWachtMinuten: v.maxWachtMinuten,
+            label: v.label,
+        };
+        return { ...n, wacht };
+    });
+    return { nodes: metWacht, edges: huidig.edges };
 }
 /**
  * Waaiert een lijst velden uit vanaf `from`: elke beslissing wordt een eigen arm
@@ -517,3 +785,124 @@ function fan(ctx, from, fromState, items, ancestors, mergeId) {
     if (armen === 0)
         push({ from, to: mergeId, state: fromState, ancestors });
 }
+/**
+ * Zonder geselecteerde order: vakjes waar de route ophoudt krijgen geen
+ * doorlopende lijnen meer.
+ *
+ * Eindstation is:
+ *  - een vakje waarvan élk vervolg uitgeschakeld is, en
+ *  - een uitkomst-tegel (`option`): daar hangt per definitie niets meer onder.
+ *
+ * Het samenkomstpunt van een beslissing waar daarna niets meer op uitkomt,
+ * verdwijnt mee. De doorgaande route tussen de stappen blijft altijd heel.
+ */
+export function verbergEindnodeLijnen(tree) {
+    const nodes = Array.isArray(tree?.nodes) ? tree.nodes : [];
+    const edges = Array.isArray(tree?.edges) ? tree.edges : [];
+    const byId = new Map(nodes.map((n) => [n.id, n]));
+    const uit = new Map();
+    for (const e of edges) {
+        if (e.kind !== "flow")
+            continue;
+        const doel = byId.get(e.to);
+        const open = e.state !== "disabled" && doel !== undefined && doel.state !== "disabled";
+        const lijst = uit.get(e.from);
+        if (lijst)
+            lijst.push({ edge: e, open });
+        else
+            uit.set(e.from, [{ edge: e, open }]);
+    }
+    const eindstations = new Set();
+    for (const n of nodes) {
+        if (n.kind === "option")
+            eindstations.add(n.id);
+    }
+    for (const [id, lijst] of uit) {
+        const bron = byId.get(id);
+        if (!bron || bron.state === "disabled")
+            continue;
+        if (lijst.length > 0 && lijst.every((l) => !l.open))
+            eindstations.add(id);
+    }
+    if (eindstations.size === 0)
+        return { nodes, edges };
+    const weg = new Set();
+    for (const e of edges) {
+        if (e.kind === "flow" && eindstations.has(e.from))
+            weg.add(e.id);
+    }
+    // Beslissingspunten waar niets meer op uitkomt, lopen ook niet meer verder.
+    const beslisMerge = (id) => id.startsWith("samen:") && !id.startsWith("samen:stap:");
+    for (let ronde = 0; ronde < 10; ronde++) {
+        const binnen = new Set();
+        for (const e of edges) {
+            if (e.kind === "flow" && !weg.has(e.id))
+                binnen.add(e.to);
+        }
+        let gewijzigd = false;
+        for (const e of edges) {
+            if (e.kind !== "flow" || weg.has(e.id))
+                continue;
+            if (beslisMerge(e.from) && !binnen.has(e.from)) {
+                weg.add(e.id);
+                gewijzigd = true;
+            }
+        }
+        if (!gewijzigd)
+            break;
+    }
+    // Waarborg: elk stap-samenkomstpunt houdt minstens één inkomende lijn, zodat
+    // de doorgaande route tussen de stappen nooit onderbroken raakt.
+    for (const n of nodes) {
+        if (!n.id.startsWith("samen:stap:"))
+            continue;
+        const inkomend = edges.filter((e) => e.kind === "flow" && e.to === n.id);
+        if (inkomend.length === 0 || inkomend.some((e) => !weg.has(e.id)))
+            continue;
+        const herstel = inkomend.filter((e) => e.state === "active");
+        for (const e of herstel.length > 0 ? herstel : inkomend)
+            weg.delete(e.id);
+    }
+    const nieuweEdges = edges.filter((e) => !weg.has(e.id));
+    const gebruikt = new Set();
+    for (const e of nieuweEdges) {
+        gebruikt.add(e.from);
+        gebruikt.add(e.to);
+    }
+    return {
+        nodes: nodes.filter((n) => !(beslisMerge(n.id) && !gebruikt.has(n.id))),
+        edges: nieuweEdges,
+    };
+}
+/**
+ * Het vakje "Verzendbrief" per herkomst juist tonen.
+ *
+ * Bij een Floriday-order geldt uitsluitend het officiele Floriday-document;
+ * de regel over de eigen layout hoort daar niet te staan. Alleen tekst: de
+ * kaartstructuur, instellingen en route blijven ongewijzigd.
+ */
+export function verduidelijkVerzendbrief(tree, source) {
+    const nodes = Array.isArray(tree?.nodes) ? tree.nodes : [];
+    const edges = Array.isArray(tree?.edges) ? tree.edges : [];
+    const isFloriday = source === "floriday";
+    const aangepast = nodes.map((n) => {
+        if (!n.id.includes(":verzendbrief:") && !n.id.endsWith(":verzendbrief"))
+            return n;
+        const lines = Array.isArray(n.lines) ? n.lines : [];
+        const eigenLayout = (regel) => regel.toLowerCase().startsWith("verzendbrief voor bvo");
+        const nieuweLines = isFloriday
+            ? [
+                ...lines.filter((r) => !eigenLayout(r)),
+                "Floriday-order: officiele Floriday-afleverbrief (aanvragen en ophalen)",
+            ]
+            : lines.map((r) => (eigenLayout(r) ? `Alleen niet-Floriday orders — ${r}` : r));
+        if (nieuweLines.length === lines.length && nieuweLines.every((r, i) => r === lines[i]))
+            return n;
+        const help = [...(Array.isArray(n.help) ? n.help : [])];
+        help.push(isFloriday
+            ? "Deze order komt uit Floriday: er wordt uitsluitend de officiele Floriday-afleverbrief gebruikt. De eigen layout geldt hier niet."
+            : "De eigen verzendbrieflayout geldt alleen voor orders die niet uit Floriday komen.");
+        return { ...n, lines: nieuweLines, help };
+    });
+    return { nodes: aangepast, edges };
+}

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

@@ -0,0 +1,4 @@
+export declare function foutTekst(ruw: string | null | undefined): string | null;
+/** Of de melding een technische stukloop is, of "alleen" een tijdslimiet/regel. */
+export declare function foutSoort(ruw: string | null | undefined): string | null;
+//# sourceMappingURL=foutTekst.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"foutTekst.d.ts","sourceRoot":"","sources":["../../src/lib/foutTekst.ts"],"names":[],"mappings":"AAQA,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAwBvE;AAED,mFAAmF;AACnF,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAMvE"}

package/dist-lib/lib/foutTekst.js

@@ -0,0 +1,43 @@
+// ============================================================================
+// src/lib/foutTekst.ts — technische foutmeldingen in gewone taal
+// ============================================================================
+// Dezelfde vertaling als in de database (logistics_plan_error_text), zodat ook
+// oudere, al vastgelegde meldingen leesbaar op het scherm komen. De ruwe tekst
+// blijft altijd beschikbaar onder "Technische details".
+// ============================================================================
+export function foutTekst(ruw) {
+    const t = typeof ruw === "string" ? ruw.trim() : "";
+    if (!t)
+        return null;
+    const l = t.toLowerCase();
+    if (l === "deadline") {
+        return "De planronde was vol voordat deze order aan de beurt was. De order schuift door naar de volgende ronde.";
+    }
+    if (l.includes("statement timeout")) {
+        return "Het opslaan van de karrenindeling duurde te lang en is door de database afgebroken. Er is niets half opgeslagen; de order wordt opnieuw geprobeerd.";
+    }
+    if (l.includes("order_cart_items_cart_id_fkey")) {
+        return "Een kar uit deze indeling bestond niet meer toen de inhoud werd weggeschreven. De indeling wordt opnieuw gemaakt.";
+    }
+    if (l.includes("order_carts_buffer_id_fkey")) {
+        return "De buffer waarop deze karren stonden bestaat niet meer. De order wordt los ingedeeld.";
+    }
+    if (l.includes("foreign key constraint")) {
+        return "Een gegeven waar de indeling naar verwees bestond niet meer op het moment van opslaan. De indeling wordt opnieuw gemaakt.";
+    }
+    if (l.includes("deadlock")) {
+        return "Twee bewerkingen wachtten op elkaar bij het opslaan. De order wordt opnieuw geprobeerd.";
+    }
+    return t;
+}
+/** Of de melding een technische stukloop is, of "alleen" een tijdslimiet/regel. */
+export function foutSoort(ruw) {
+    const l = (ruw ?? "").toLowerCase();
+    if (!l.trim())
+        return null;
+    if (l === "deadline" || l.includes("statement timeout") || l.includes("deadlock"))
+        return "regel";
+    if (l.includes("grens van") || l.includes("geen enkele kar"))
+        return "configuratie";
+    return "technisch";
+}

package/dist-lib/lib/handlers/logistics-tick.server.d.ts

@@ -1,3 +1,5 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
 export declare function handleLogisticsTick(request: Request, supabase: SupabaseClient): Promise<Response>;
+/** Vaste sleutel van het rondeslot; gelijk aan de check in logistics_plan_kick(). */
+export declare const TICK_ROUND_LOCK_KEY = "tick:ronde";
 //# sourceMappingURL=logistics-tick.server.d.ts.map

package/dist-lib/lib/handlers/logistics-tick.server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logistics-tick.server.d.ts","sourceRoot":"","sources":["../../../src/lib/handlers/logistics-tick.server.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAQ5D,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,QAAQ,CAAC,CAuRnB"}
+{"version":3,"file":"logistics-tick.server.d.ts","sourceRoot":"","sources":["../../../src/lib/handlers/logistics-tick.server.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAQ5D,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,QAAQ,CAAC,CA2EnB;AAED,qFAAqF;AACrF,eAAO,MAAM,mBAAmB,eAAe,CAAC"}

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

@@ -39,6 +39,51 @@ export async function handleLogisticsTick(request, supabase) {
     catch {
         // Een ontbrekende hartslag mag de verwerking nooit tegenhouden.
     }
+    // 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
+    // volgende minuut-ronde is het vangnet.
+    const roundId = crypto.randomUUID();
+    let held = false;
+    let lockUnknown = false;
+    try {
+        const { data, error } = await supabase.rpc("logistics_plan_lock_acquire", {
+            _key: TICK_ROUND_LOCK_KEY,
+            _owner: roundId,
+            _ttl_seconds: 120,
+        });
+        if (error)
+            lockUnknown = true;
+        held = !error && data === true;
+    }
+    catch {
+        lockUnknown = true;
+        held = false;
+    }
+    if (!held) {
+        if (lockUnknown) {
+            console.warn("[logistics-tick] rondeslot kon niet worden vastgesteld; ronde overgeslagen");
+        }
+        return Response.json({ ok: true, skipped: lockUnknown ? "slot_onbekend" : "ronde_loopt_al" }, { status: 200, headers: CORS_HEADERS });
+    }
+    try {
+        return await runTickRound(supabase, tickJob);
+    }
+    finally {
+        try {
+            await supabase.rpc("logistics_plan_lock_release", {
+                _key: TICK_ROUND_LOCK_KEY,
+                _owner: roundId,
+            });
+        }
+        catch {
+            // Vrijgeven mag de uitkomst niet omgooien; de lease verloopt vanzelf.
+        }
+    }
+}
+/** 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) {
     // Meerdere batches per aanroep, met een ruime marge tot de time-out.
     const deadline = Date.now() + 8000;
     let last = null;
@@ -72,6 +117,16 @@ export async function handleLogisticsTick(request, supabase) {
     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) };
+    }
     // Planwachtrij: nieuwe/gewijzigde orders incrementeel indelen.
     let plan = null;
     try {
@@ -243,6 +298,7 @@ export async function handleLogisticsTick(request, supabase) {
         status: last?.status ?? "idle",
         phase: last?.phase ?? null,
         processed: last?.processed ?? 0,
+        reconciledOrders,
         plan,
         orphans,
         bufferQueue,

package/dist-lib/lib/handlers/logistics-tick.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=logistics-tick.test.d.ts.map

package/dist-lib/lib/handlers/logistics-tick.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logistics-tick.test.d.ts","sourceRoot":"","sources":["../../../src/lib/handlers/logistics-tick.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,63 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+const tickJob = vi.fn(async () => null);
+const runPlanQueue = vi.fn(async () => ({}));
+vi.mock("../logisticsRecalcJob.server.js", () => ({ tickJob }));
+vi.mock("../planQueue.server.js", () => ({ runPlanQueue, prunePlanQueue: vi.fn() }));
+import { handleLogisticsTick, TICK_ROUND_LOCK_KEY } from "./logistics-tick.server";
+const KEY = "test-key";
+function makeClient(acquire) {
+    const calls = [];
+    const rpc = vi.fn(async (fn, args) => {
+        calls.push({ fn, args });
+        if (fn === "logistics_plan_lock_acquire")
+            return acquire();
+        return { data: null, error: null };
+    });
+    return { client: { rpc }, calls };
+}
+const req = () => new Request("http://x/api/public/hooks/logistics-recalc-tick", {
+    method: "POST",
+    headers: { apikey: KEY },
+});
+beforeEach(() => {
+    process.env["SUPABASE_PUBLISHABLE_KEY"] = KEY;
+    tickJob.mockClear();
+    runPlanQueue.mockClear();
+});
+describe("tick-rondeslot", () => {
+    it("slaat een tweede ronde over als er al een ronde loopt", async () => {
+        const { client, calls } = makeClient(async () => ({ data: false, error: null }));
+        const res = await handleLogisticsTick(req(), client);
+        expect(await res.json()).toMatchObject({ skipped: "ronde_loopt_al" });
+        expect(tickJob).not.toHaveBeenCalled();
+        expect(runPlanQueue).not.toHaveBeenCalled();
+        const fns = calls.map((c) => c.fn);
+        expect(fns).not.toContain("logistics_buffer_detach_late_orders");
+        expect(fns).not.toContain("logistics_sync_pick_queue");
+        expect(fns).not.toContain("logistics_plan_lock_release");
+    });
+    it("slaat over (fail-closed) als het slot niet kan worden vastgesteld", async () => {
+        const { client } = makeClient(async () => ({ data: null, error: { message: "boom" } }));
+        const res = await handleLogisticsTick(req(), client);
+        expect(await res.json()).toMatchObject({ skipped: "slot_onbekend" });
+        expect(tickJob).not.toHaveBeenCalled();
+        expect(runPlanQueue).not.toHaveBeenCalled();
+    });
+    it("draait de ronde met slot en geeft het slot daarna vrij, ook bij een fout", async () => {
+        tickJob.mockImplementationOnce(async () => {
+            throw new Error("stap faalt");
+        });
+        const { client, calls } = makeClient(async () => ({ data: true, error: null }));
+        await expect(handleLogisticsTick(req(), client)).rejects.toThrow("stap faalt");
+        const acq = calls.find((c) => c.fn === "logistics_plan_lock_acquire");
+        const rel = calls.find((c) => c.fn === "logistics_plan_lock_release");
+        expect(rel).toBeTruthy();
+        expect(rel.args._key).toBe(TICK_ROUND_LOCK_KEY);
+        expect(rel.args._owner).toBe(acq.args._owner);
+    });
+    it("voert de planwachtrij uit als het slot is verkregen", async () => {
+        const { client } = makeClient(async () => ({ data: true, error: null }));
+        await handleLogisticsTick(req(), client);
+        expect(runPlanQueue).toHaveBeenCalledTimes(1);
+    });
+});