@flowselections/logistiek-engine 1.0.34 → 1.0.89

package/dist-lib/lib/flowRoute.js

@@ -0,0 +1,583 @@
+// ============================================================================
+// src/lib/flowRoute.ts — de route van één herberekening (versie) van een order
+// over de flowkaart
+// ============================================================================
+// Uit de logboekgegevens van één versie leiden we af tot welke stap de order
+// is gekomen en waar hij eventueel is vastgelopen. Die informatie leggen we als
+// laag over de flowkaart: de gelopen route wordt blauw, de rest licht, en het
+// vastgelopen vakje krijgt een rode markering.
+//
+// Belangrijk: de kaart zelf blijft de actuele werkwijze. Welke keuze binnen een
+// stap gold, komt uit de instellingen van nú; het logboek bewaart (nog) geen
+// momentopname van de werkwijze per herberekening. Dat melden we in de kaart.
+// ============================================================================
+import { WIZARD_STEPS } from "./ruleEngineWizard";
+import { FLOW_NODE, bronNodeVoor } from "./flowNodes";
+import { vakUitleg } from "./vakUitleg";
+import { stopReden, samenkomstStop } from "./stopReden";
+const STEP_IDS = WIZARD_STEPS.map((s) => s.id);
+const STAP = {
+    combineren: STEP_IDS[0] ?? "orders_combineren",
+    indeling: STEP_IDS[1] ?? "beladingindeling",
+    picken: STEP_IDS[2] ?? "picken",
+    drukte: STEP_IDS[3] ?? "drukte_vertraging",
+    stations: STEP_IDS[4] ?? "pickstations",
+    controle: STEP_IDS[5] ?? "controle",
+};
+export const REASON_LABEL = {
+    afmetingen_onbekend: "Afmetingen van fust/product onbekend",
+    kargrens_overschreden: "Kargrens overschreden (te veel lagen/karren)",
+    bufferdekking_onvolledig: "Buffer nog niet compleet: niet alle orders binnen",
+    werktijden_ontbreken: "Werktijden van de klant ontbreken",
+    fust_onbekend: "Fusttype onbekend",
+    geen_regels: "Order heeft geen regels",
+    dubbele_regels: "Order heeft dubbele bestelregels; er is niets ingedeeld",
+};
+export function redenTekst(code, error) {
+    const label = code ? REASON_LABEL[code] ?? code.replace(/_/g, " ") : null;
+    if (label && error && !error.includes(code ?? ""))
+        return `${label} — ${error}`;
+    return label ?? error ?? "Onbekende reden";
+}
+const AFGEROND = new Set(["verzonden", "gereed voor facturatie", "afgehandeld", "gefactureerd", "afgemeld"]);
+/** Leidt uit één versie + de huidige stand van de order de gelopen route af. */
+export function bepaalRoute(versie, order, carts, isLaatste) {
+    const bron = order?.orderSource ? bronNodeVoor(order.orderSource) : null;
+    const source = bron === FLOW_NODE.bronFloriday
+        ? "floriday"
+        : bron === FLOW_NODE.bronMail
+            ? "mail"
+            : bron === FLOW_NODE.bronActiemail
+                ? "actiemail"
+                : bron === FLOW_NODE.bronHandmatig
+                    ? "handmatig"
+                    : null;
+    const reached = [];
+    let stuck = null;
+    let busy = null;
+    let finished = false;
+    if (!versie) {
+        return {
+            source,
+            reached,
+            stuck: null,
+            busy: { stepId: STAP.combineren, reason: "Order is binnen, maar nog nooit ingedeeld" },
+            finished: false,
+            summary: "Nog geen herberekening bekend voor deze order.",
+        };
+    }
+    // 1. Ontvangen en combineren: zodra er een wachtrijrij is, is de order binnen.
+    reached.push(STAP.combineren);
+    // 2. Karindeling: de uitkomst van de planwachtrij.
+    const status = (versie.status ?? "pending").toLowerCase();
+    if (status === "pending") {
+        busy = { stepId: STAP.indeling, reason: "Wacht op de planronde" };
+    }
+    else if (status === "running") {
+        reached.push(STAP.indeling);
+        busy = { stepId: STAP.indeling, reason: "Karindeling wordt nu berekend" };
+    }
+    else if (status === "failed" || status === "geblokkeerd") {
+        reached.push(STAP.indeling);
+        stuck = {
+            stepId: STAP.indeling,
+            reason: (status === "geblokkeerd" ? "Geblokkeerd: " : "Mislukt: ") +
+                redenTekst(versie.reasonCode, versie.error ?? versie.lastError),
+        };
+    }
+    else {
+        reached.push(STAP.indeling);
+    }
+    if (!stuck && !busy) {
+        // 3–5. Picken, vrijgave en pickstations: pakbonnen/printopdrachten.
+        if (versie.printJobs > 0) {
+            reached.push(STAP.picken, STAP.drukte, STAP.stations);
+            if (versie.printFailed > 0 && versie.printFailed >= versie.printJobs) {
+                stuck = { stepId: STAP.stations, reason: "Printopdracht mislukt of geannuleerd" };
+            }
+        }
+        else if (versie.lastErrorStep && versie.errors > 0 && (versie.lastPhase ?? "").includes("verzendbrief")) {
+            reached.push(STAP.picken, STAP.drukte, STAP.stations);
+            stuck = { stepId: STAP.stations, reason: `Verzendbrief: ${versie.lastError ?? "fout"}` };
+        }
+        else {
+            reached.push(STAP.picken);
+            busy = { stepId: STAP.drukte, reason: "Ingedeeld; wacht op vrijgave/aanmeldmoment" };
+        }
+        const ship = (versie.shippingStatus ?? "").toLowerCase();
+        if (!stuck && (ship === "mislukt" || ship === "geblokkeerd")) {
+            stuck = { stepId: STAP.stations, reason: `Verzendbrief ${ship}${versie.lastError ? `: ${versie.lastError}` : ""}` };
+        }
+        // 6. Controle en afronding: alleen aantoonbaar voor de laatste versie
+        //    (de karrenstand is een stand van nú).
+        if (!stuck && isLaatste && carts && carts.total > 0) {
+            if (carts.printed > 0) {
+                if (!reached.includes(STAP.stations))
+                    reached.push(STAP.drukte, STAP.stations);
+                busy = null;
+                if (carts.controlled >= carts.total) {
+                    reached.push(STAP.controle);
+                    finished = true;
+                }
+                else {
+                    reached.push(STAP.controle);
+                    busy = {
+                        stepId: STAP.controle,
+                        reason: `${carts.controlled} van ${carts.total} karren gecontroleerd`,
+                    };
+                }
+            }
+        }
+        if (isLaatste && order?.status && AFGEROND.has(order.status.toLowerCase())) {
+            if (!reached.includes(STAP.controle))
+                reached.push(STAP.drukte, STAP.stations, STAP.controle);
+            busy = null;
+            finished = true;
+        }
+    }
+    if (isLaatste && order?.cancelledAt) {
+        stuck = { stepId: stuck?.stepId ?? busy?.stepId ?? STAP.combineren, reason: "Order is geannuleerd" };
+        busy = null;
+        finished = false;
+    }
+    const uniek = [...new Set(reached)];
+    const summary = finished
+        ? "Route volledig doorlopen: order is gecontroleerd en afgemeld."
+        : stuck
+            ? `Vastgelopen bij "${stapLabel(stuck.stepId)}": ${stuck.reason}`
+            : busy
+                ? `Nu bij "${stapLabel(busy.stepId)}": ${busy.reason}`
+                : `Gekomen tot "${stapLabel(uniek[uniek.length - 1] ?? STAP.combineren)}".`;
+    return { source, reached: uniek, stuck, busy, finished, summary };
+}
+export function stapLabel(stepId) {
+    return WIZARD_STEPS.find((s) => s.id === stepId)?.label ?? stepId;
+}
+// ── Route over de kaart leggen ──────────────────────────────────────────────
+/**
+ * Twee extra vakjes tussen "Pickstations en documenten" en "Controle en
+ * afmelden": die horen niet bij de instellingenstappen, maar hebben wel een
+ * vaste plek in de volgorde.
+ */
+const EXTRA_STAP_INDEX = {
+    "stap:pakbon_geprint": STEP_IDS.indexOf(STAP.stations) + 0.3,
+    "stap:kar_afgemeld": STEP_IDS.indexOf(STAP.stations) + 0.6,
+};
+/** Stapvolgorde-index van een knoop; -1 = vóór de eerste stap; 99 = einde. */
+function stapIndex(node, byId) {
+    if (!node)
+        return -1;
+    if (node.id === "__eind")
+        return 99;
+    if (node.id.startsWith("__"))
+        return -1;
+    const extra = EXTRA_STAP_INDEX[node.id];
+    if (extra !== undefined)
+        return extra;
+    const m = /^(?:samen:)?stap:(.+)$/.exec(node.id);
+    if (m)
+        return STEP_IDS.indexOf(m[1]);
+    if (node.stepId)
+        return STEP_IDS.indexOf(node.stepId);
+    for (const a of [...node.ancestors].reverse()) {
+        const anc = byId.get(a);
+        if (anc?.stepId)
+            return STEP_IDS.indexOf(anc.stepId);
+    }
+    return -1;
+}
+/** Zet op het laatste vakje van de route altijd een reden waarom het daar stopt. */
+function markeerEindpunt(markers, routeNodes, routeEdges, byId, groepen, stand) {
+    const heeftVervolg = new Set(routeEdges.filter((e) => routeNodes.has(e.to)).map((e) => e.from));
+    const kandidaten = [...routeNodes].filter((id) => id !== "__start" && !heeftVervolg.has(id));
+    const eindpunten = new Set(kandidaten);
+    if (kandidaten.length === 0)
+        return { eind: null, eindpunten };
+    let eind = null;
+    let besteIdx = -Infinity;
+    let besteTijd = "";
+    for (const id of kandidaten) {
+        const idx = stapIndex(byId.get(id), byId);
+        const tijd = groepen?.get(id)?.laatste ?? "";
+        if (idx > besteIdx || (idx === besteIdx && tijd > besteTijd)) {
+            eind = id;
+            besteIdx = idx;
+            besteTijd = tijd;
+        }
+    }
+    if (!eind)
+        return { eind: null, eindpunten };
+    const bestaand = markers.get(eind);
+    const stop = stopReden({
+        nodeId: eind,
+        groep: groepen?.get(eind) ?? null,
+        stand,
+        verouderd: bestaand?.verouderd === true,
+    });
+    markers.set(eind, {
+        kind: bestaand?.kind ?? (stop.soort === "mislukt" ? "stuck" : stop.soort === "klaar" ? "done" : "busy"),
+        text: bestaand?.text ?? stop.titel,
+        ...bestaand,
+        eindpunt: true,
+        // Een wachtpunt heeft al zijn eigen stopreden; die blijft staan.
+        stop: bestaand?.stop ?? stop,
+    });
+    return { eind, eindpunten };
+}
+/**
+ * Samenkomstpunten waar de route nog niet voorbij mag: de ingestelde
+ * voorwaarde ("alle lijnen" of een verplichte lijn) is nog niet gehaald.
+ * Loopt de maximale wachttijd af, dan gaat de route alsnog verder; zo kan een
+ * tak die nooit gebeurt de flow niet voor altijd vastzetten.
+ */
+function bepaalWachtpunten(nodes, edges, routeNodes, routeEdges, echt, markers) {
+    const wachtpunten = new Set();
+    const nu = Date.now();
+    for (const node of nodes) {
+        const wacht = node.wacht;
+        if (node.kind !== "merge" || !wacht || !routeNodes.has(node.id))
+            continue;
+        const inkomend = edges.filter((e) => e.kind === "flow" && e.to === node.id && e.state !== "disabled");
+        const nodig = wacht.wanneer === "specifiek"
+            ? inkomend.filter((e) => e.id === wacht.verplichteLijn)
+            : inkomend;
+        if (nodig.length === 0)
+            continue;
+        const naam = (id) => nodes.find((n) => n.id === id)?.label || "een eerdere tak";
+        const klaar = [];
+        const open = [];
+        const mislukt = [];
+        let eerste = "";
+        for (const e of nodig) {
+            const groep = echt.get(e.from);
+            const gelopen = routeEdges.has(e.id) || !!groep;
+            if (groep?.status === "mislukt")
+                mislukt.push(naam(e.from));
+            if (gelopen) {
+                klaar.push(naam(e.from));
+                const t = groep?.laatste ?? "";
+                if (t && (!eerste || t < eerste))
+                    eerste = t;
+            }
+            else {
+                open.push(naam(e.from));
+            }
+        }
+        if (open.length === 0 && mislukt.length === 0)
+            continue;
+        // Vangnet: na de maximale wachttijd loopt de route alsnog door.
+        const start = eerste ? new Date(eerste).getTime() : NaN;
+        const verlopen = Number.isFinite(start) && nu - start > wacht.maxWachtMinuten * 60000;
+        if (verlopen && mislukt.length === 0) {
+            const bestaand = markers.get(node.id);
+            markers.set(node.id, {
+                kind: bestaand?.kind ?? "busy",
+                text: "Doorgegaan na maximale wachttijd",
+                beslissing: "Doorgegaan na maximale wachttijd",
+                waarom: `Er is langer dan ${wacht.maxWachtMinuten} minuten gewacht op ${open.join(", ")}; de flow is daarna verdergegaan.`,
+                feiten: [`Voorwaarde: ${wacht.label}`, `Nog niet klaar: ${open.join(", ")}`],
+                ...bestaand,
+            });
+            continue;
+        }
+        wachtpunten.add(node.id);
+        markers.set(node.id, {
+            kind: mislukt.length > 0 ? "stuck" : "busy",
+            text: mislukt.length > 0 ? "Verplichte tak is mislukt" : "Wacht op andere takken",
+            beslissing: mislukt.length > 0 ? "Verplichte tak is mislukt" : "Wacht op andere takken",
+            eindpunt: true,
+            stop: samenkomstStop({
+                wachtOp: open,
+                mislukt,
+                voorwaarde: wacht.label,
+                maxWachtMinuten: wacht.maxWachtMinuten,
+            }),
+            feiten: klaar.length > 0 ? [`Al klaar: ${klaar.join(", ")}`] : [],
+        });
+    }
+    return wachtpunten;
+}
+/**
+ * Maakt een kopie van de kaart waarin alleen de gelopen route "active" is.
+ * Knopen/pijlen die de order (nog) niet heeft bereikt worden "possible".
+ *
+ * Zijn er echte gebeurtenissen per vakje (`groepen`), dan winnen die: de reis
+ * komt dan uit wat de Engine heeft vastgelegd. De heuristiek hieronder blijft
+ * de terugval voor oudere gebeurtenissen zonder vakje.
+ */
+export function applyRoute(tree, route, groepen, stand) {
+    const markers = new Map();
+    const nodes = Array.isArray(tree?.nodes) ? tree.nodes : [];
+    const edges = Array.isArray(tree?.edges) ? tree.edges : [];
+    if (!route)
+        return { tree: { nodes, edges }, markers, wachtpunten: new Set() };
+    const echt = groepen && groepen.size > 0 ? groepen : null;
+    const byId = new Map(nodes.map((n) => [n.id, n]));
+    const maxIdx = route.reached.reduce((m, id) => Math.max(m, STEP_IDS.indexOf(id)), -1);
+    const bereikt = (idx) => (idx === 99 ? route.finished : idx <= maxIdx);
+    // Het bronvakje van deze order (Floriday, mail, actiemail of handmatig).
+    const bronNode = route.source === "floriday"
+        ? FLOW_NODE.bronFloriday
+        : route.source === "mail"
+            ? FLOW_NODE.bronMail
+            : route.source === "actiemail"
+                ? FLOW_NODE.bronActiemail
+                : route.source === "handmatig"
+                    ? FLOW_NODE.bronHandmatig
+                    : null;
+    const bronTak = (id) => id === FLOW_NODE.bronFloriday ||
+        id === FLOW_NODE.bronMail ||
+        id === FLOW_NODE.bronActiemail ||
+        id === FLOW_NODE.bronHandmatig;
+    /** Hoort dit bronvakje (of de samenvoegstap erna) bij deze order? */
+    const bronOk = (id) => {
+        if (bronTak(id))
+            return id === bronNode;
+        if (id === FLOW_NODE.samenvoegen)
+            return bronNode === FLOW_NODE.bronFloriday;
+        return true;
+    };
+    const demote = (s) => (s === "active" ? "possible" : s);
+    // ── Route uit echte gebeurtenissen: altijd een aaneengesloten pad ──────────
+    if (echt) {
+        // Alleen lijnen die volgens de huidige werkwijze bestaan en bij deze bron horen.
+        const bruikbaar = (e) => e.kind === "flow" &&
+            e.state === "active" &&
+            bronOk(e.from) &&
+            bronOk(e.to) &&
+            byId.get(e.from)?.state === "active" &&
+            byId.get(e.to)?.state === "active";
+        const uit = new Map();
+        for (const e of edges) {
+            if (!bruikbaar(e))
+                continue;
+            const lijst = uit.get(e.from);
+            if (lijst)
+                lijst.push({ to: e.to, edgeId: e.id });
+            else
+                uit.set(e.from, [{ to: e.to, edgeId: e.id }]);
+        }
+        // Kortste pad vanaf het startvakje naar elk bereikbaar vakje.
+        const vorige = new Map();
+        const gezien = new Set(["__start"]);
+        const rij = ["__start"];
+        for (let i = 0; i < rij.length; i++) {
+            const huidig = rij[i];
+            for (const stap of uit.get(huidig) ?? []) {
+                if (gezien.has(stap.to))
+                    continue;
+                gezien.add(stap.to);
+                vorige.set(stap.to, { from: huidig, edgeId: stap.edgeId });
+                rij.push(stap.to);
+            }
+        }
+        // Bewijs: vakjes waarvoor daadwerkelijk iets is vastgelegd, plus het bronvakje.
+        const bewijs = new Set([...echt.keys()]);
+        if (bronNode)
+            bewijs.add(bronNode);
+        const routeNodes = new Set(["__start"]);
+        const routeEdges = new Set();
+        const onbereikbaar = new Set();
+        for (const id of bewijs) {
+            if (!byId.has(id) || !gezien.has(id)) {
+                onbereikbaar.add(id);
+                continue;
+            }
+            let stap = id;
+            while (stap && stap !== "__start") {
+                routeNodes.add(stap);
+                const p = vorige.get(stap);
+                if (!p)
+                    break;
+                routeEdges.add(p.edgeId);
+                stap = p.from;
+            }
+        }
+        // Samenkomstpunten met een eigen voorwaarde kunnen de route hier stoppen.
+        const wachtpunten = bepaalWachtpunten(nodes, edges, routeNodes, routeEdges, echt, markers);
+        // Een stap die nog loopt (wachtend/waarschuwing) houdt alleen de volgende
+        // echte stap tegen. De keuze-, uitkomst- en samenkomstvakjes van diezelfde
+        // stap staan al vast en blijven dus wel blauw.
+        const lopend = new Set();
+        for (const g of echt.values()) {
+            if (g.status !== "wachtend" && g.status !== "waarschuwing")
+                continue;
+            if (!routeNodes.has(g.nodeId))
+                continue;
+            lopend.add(g.nodeId);
+        }
+        const isStapVak = (id) => id.startsWith("stap:") || byId.get(id)?.kind === "step";
+        /** Een volgende stap mag alsnog blauw worden als die zelf geslaagd is. */
+        const isGeslaagdeStap = (id) => echt.get(id)?.status === "geslaagd";
+        // Voorbij een samenkomst-wachtpunt loopt de blauwe route niet meer; het
+        // grijze vervolg daarachter blijft gewoon staan (er wordt niets weggesnoeid).
+        const kandidaatEdges = edges.filter((e) => routeEdges.has(e.id) && !wachtpunten.has(e.from));
+        const verdereStap = new Map();
+        for (const e of kandidaatEdges) {
+            const lijst = verdereStap.get(e.from);
+            if (lijst)
+                lijst.push({ to: e.to, id: e.id });
+            else
+                verdereStap.set(e.from, [{ to: e.to, id: e.id }]);
+        }
+        const routeTot = new Set(["__start"]);
+        const routeEdgeIds = new Set();
+        /** Per knoop: welke lopende stappen liggen er vóór dit punt op de route? */
+        const naLopend = new Map();
+        /** Lopende stappen waar de route toch langs mocht (latere stap is geslaagd). */
+        const doorgelaten = new Set();
+        const rijRoute = ["__start"];
+        for (let i = 0; i < rijRoute.length; i++) {
+            const huidig = rijRoute[i];
+            const oorsprongen = new Set(naLopend.get(huidig) ?? []);
+            if (lopend.has(huidig))
+                oorsprongen.add(huidig);
+            const na = oorsprongen.size > 0;
+            for (const { to: volgend, id: edgeId } of verdereStap.get(huidig) ?? []) {
+                // Na een lopende stap stopt de blauwe route bij het eerstvolgende
+                // stapvakje — tenzij van die stap zelf iets geslaagds is vastgelegd.
+                if (na && isStapVak(volgend)) {
+                    if (!isGeslaagdeStap(volgend))
+                        continue;
+                    for (const o of oorsprongen)
+                        doorgelaten.add(o);
+                    routeEdgeIds.add(edgeId);
+                    if (!routeTot.has(volgend)) {
+                        routeTot.add(volgend);
+                        rijRoute.push(volgend);
+                    }
+                    continue;
+                }
+                routeEdgeIds.add(edgeId);
+                let veranderd = false;
+                if (na) {
+                    const set = naLopend.get(volgend) ?? new Set();
+                    for (const o of oorsprongen) {
+                        if (!set.has(o)) {
+                            set.add(o);
+                            veranderd = true;
+                        }
+                    }
+                    naLopend.set(volgend, set);
+                }
+                if (routeTot.has(volgend)) {
+                    if (veranderd)
+                        rijRoute.push(volgend);
+                    continue;
+                }
+                routeTot.add(volgend);
+                rijRoute.push(volgend);
+            }
+        }
+        const routeEdgeLijst = kandidaatEdges.filter((e) => routeEdgeIds.has(e.id));
+        // Alleen lopende stappen waar de route écht stopt gelden als wachtpunt.
+        for (const id of lopend)
+            if (!doorgelaten.has(id))
+                wachtpunten.add(id);
+        const newNodes = nodes.map((n) => routeTot.has(n.id) && n.state === "active"
+            ? { ...n, route: true }
+            : { ...n, state: demote(n.state), route: false });
+        const newEdges = edges.map((e) => routeEdgeIds.has(e.id) ? { ...e, route: true } : { ...e, state: demote(e.state), route: false });
+        /** Waar hoort bewijs heen dat niet meer op de kaart bereikbaar is? */
+        const vervangend = (id) => {
+            const n = byId.get(id);
+            const stapId = n?.stepId ? `stap:${n.stepId}` : null;
+            if (stapId && routeTot.has(stapId))
+                return stapId;
+            for (const a of [...(n?.ancestors ?? [])].reverse()) {
+                if (routeTot.has(a))
+                    return a;
+            }
+            return null;
+        };
+        for (const g of echt.values()) {
+            const kind = g.status === "mislukt" ? "stuck" : g.status === "wachtend" || g.status === "waarschuwing" ? "busy" : "done";
+            const uitleg = vakUitleg(g);
+            const verouderd = onbereikbaar.has(g.nodeId);
+            const doel = verouderd ? vervangend(g.nodeId) : g.nodeId;
+            if (!doel)
+                continue;
+            const bestaand = markers.get(doel);
+            const marker = {
+                kind: bestaand && bestaand.kind === "stuck" ? bestaand.kind : kind,
+                text: uitleg.beslissing,
+                beslissing: uitleg.beslissing,
+                waarom: uitleg.waarom,
+                feiten: uitleg.feiten,
+                at: g.laatste,
+                durationMs: g.duurMs,
+                count: (bestaand?.count ?? 0) + g.aantal,
+                attempts: Math.max(bestaand?.attempts ?? 0, g.pogingen),
+                errorClass: g.errorClass ?? bestaand?.errorClass ?? null,
+                nextStep: g.volgendeStap,
+                verouderd: verouderd || bestaand?.verouderd === true,
+            };
+            markers.set(doel, marker);
+        }
+        // Een lopende stap waar de route stopt is een stoppunt met eigen uitleg.
+        for (const id of lopend) {
+            if (!routeTot.has(id) || doorgelaten.has(id))
+                continue;
+            const bestaand = markers.get(id);
+            markers.set(id, {
+                kind: bestaand?.kind ?? "busy",
+                text: bestaand?.text ?? "Deze stap loopt nog",
+                ...bestaand,
+                eindpunt: true,
+                stop: bestaand?.stop ??
+                    stopReden({
+                        nodeId: id,
+                        groep: echt.get(id) ?? null,
+                        stand: stand ?? null,
+                        verouderd: bestaand?.verouderd === true,
+                    }),
+            });
+        }
+        markeerEindpunt(markers, routeTot, routeEdgeLijst.map((e) => ({ from: e.from, to: e.to })), byId, echt, stand ?? null);
+        return {
+            // Een geselecteerde order kleurt alleen de gelopen route. De volledige
+            // flowchart blijft zichtbaar, ook na een fout of definitief stoppunt.
+            tree: { nodes: newNodes, edges: newEdges },
+            markers,
+            wachtpunten,
+        };
+    }
+    /** Ligt dit vakje op de reis volgens de heuristiek? */
+    const opReis = (n) => {
+        if (bronTak(n.id) || n.id === FLOW_NODE.samenvoegen) {
+            return bronOk(n.id) && bereikt(-1);
+        }
+        return bereikt(stapIndex(n, byId));
+    };
+    const newNodes = nodes.map((n) => {
+        const ok = n.state === "active" && opReis(n);
+        return ok ? { ...n, route: true } : { ...n, state: demote(n.state), route: false };
+    });
+    const nodeState = new Map(newNodes.map((n) => [n.id, n.state]));
+    const newEdges = edges.map((e) => {
+        if (e.state !== "active")
+            return e;
+        const to = byId.get(e.to);
+        const from = byId.get(e.from);
+        const ok = nodeState.get(e.from) === "active" &&
+            nodeState.get(e.to) === "active" &&
+            bereikt(Math.max(stapIndex(from, byId), stapIndex(to, byId))) &&
+            bronOk(e.from) &&
+            bronOk(e.to);
+        return ok ? { ...e, route: true } : { ...e, state: "possible", route: false };
+    });
+    if (route.stuck)
+        markers.set(`stap:${route.stuck.stepId}`, { kind: "stuck", text: route.stuck.reason });
+    else if (route.busy)
+        markers.set(`stap:${route.busy.stepId}`, { kind: "busy", text: route.busy.reason });
+    if (route.finished)
+        markers.set("__eind", { kind: "done", text: "Afgehandeld" });
+    const heuristischeRoute = new Set(newNodes.filter((n) => n.route).map((n) => n.id));
+    markeerEindpunt(markers, heuristischeRoute, newEdges.filter((e) => e.route).map((e) => ({ from: e.from, to: e.to })), byId, null, stand ?? null);
+    return {
+        // Ook oudere orders houden de volledige grijze vervolgstructuur in beeld.
+        tree: { nodes: newNodes, edges: newEdges },
+        markers,
+        wachtpunten: new Set(),
+    };
+}