@flowselections/logistiek-engine 1.0.34 → 1.0.89

package/dist-lib/lib/flowTree.js

@@ -0,0 +1,908 @@
+// ============================================================================
+// src/lib/flowTree.ts — vertakkende beslisboom van de Logistiek Engine
+// ============================================================================
+// Bouwt uit WIZARD_STEPS en de opgeslagen werkwijze een boom waarin ELK
+// beslismoment al zijn uitkomsten laat zien. De vertakkingen komen uit de
+// `dependsOn`-regels van het schema: een instelling die alleen geldt bij een
+// bepaalde keuze hangt onder de pijl van die keuze. De actieve route wordt met
+// dezelfde `fieldVisible`-logica bepaald die de engine en het instelscherm
+// gebruiken. Er staat hier geen aparte flowlogica.
+// ============================================================================
+import { fieldVisible, optionLabel, } from "./ruleEngineSchema";
+import { WIZARD_STEPS, fieldHelp } from "./ruleEngineWizard";
+export const NODE_SIZE = {
+    start: { w: 240, h: 60 },
+    end: { w: 240, h: 60 },
+    source: { w: 260, h: 96 },
+    step: { w: 300, h: 88 },
+    decision: { w: 280, h: 118 },
+    setting: { w: 240, h: 66 },
+    option: { w: 150, h: 30 },
+    merge: { w: 14, h: 14 },
+};
+const DAY_SHORT = {
+    mon: "ma",
+    tue: "di",
+    wed: "wo",
+    thu: "do",
+    fri: "vr",
+    sat: "za",
+    sun: "zo",
+};
+function isDecision(field) {
+    if (field.type === "toggle")
+        return true;
+    if (field.type === "select" || field.type === "radio") {
+        return Array.isArray(field.options) && field.options.length >= 2;
+    }
+    return false;
+}
+function rulesOf(field) {
+    if (!field.dependsOn)
+        return [];
+    return Array.isArray(field.dependsOn) ? field.dependsOn : [field.dependsOn];
+}
+function optionsOf(field) {
+    if (field.type === "toggle") {
+        return [
+            { value: "true", label: "ja" },
+            { value: "false", label: "nee" },
+        ];
+    }
+    return (field.options ?? []).map((o) => ({ value: o.value, label: o.label }));
+}
+function currentOf(field, value) {
+    if (field.type === "toggle")
+        return value === true ? "true" : "false";
+    return String(value ?? "");
+}
+/**
+ * Zoekt de schemavelden op die bij een vakje horen. Gebruikt dezelfde
+ * WIZARD_STEPS als het instelscherm, zodat er geen tweede definitie ontstaat.
+ */
+export function fieldsFor(storeId, keys) {
+    const veiligeKeys = Array.isArray(keys) ? keys : [];
+    if (!storeId || !veiligeKeys.length)
+        return [];
+    const stappen = Array.isArray(WIZARD_STEPS) ? WIZARD_STEPS : [];
+    const alle = [];
+    for (const stap of stappen) {
+        if (stap.storeId !== storeId)
+            continue;
+        for (const group of Array.isArray(stap.groups) ? stap.groups : []) {
+            for (const field of Array.isArray(group.fields) ? group.fields : [])
+                alle.push(field);
+        }
+    }
+    return veiligeKeys
+        .map((k) => alle.find((f) => f.key === k))
+        .filter((f) => Boolean(f));
+}
+export function valueText(field, value) {
+    if (value === undefined || value === null || value === "")
+        return "niet ingesteld";
+    switch (field.type) {
+        case "toggle":
+            return value === true ? "aan" : "uit";
+        case "select":
+        case "radio":
+            return optionLabel(field, value);
+        case "days": {
+            const days = Array.isArray(value) ? value : [];
+            return days.length ? days.map((d) => DAY_SHORT[d] ?? d).join(", ") : "geen";
+        }
+        case "number":
+            return `${String(value)}${field.unit ? ` ${field.unit}` : ""}`;
+        case "priority": {
+            const entries = Array.isArray(value) ? value : [];
+            return `${entries.filter((e) => e?.enabled).length} actief`;
+        }
+        case "textarea":
+        case "text": {
+            const t = String(value);
+            return t.length > 40 ? `${t.slice(0, 39)}…` : t;
+        }
+        default:
+            return String(value);
+    }
+}
+/** Toestand van een tak-pijl uit een beslissing. */
+function edgeState(decision, isCurrent) {
+    if (decision === "active")
+        return isCurrent ? "active" : "possible";
+    if (decision === "possible")
+        return isCurrent ? "possible" : "disabled";
+    return "disabled";
+}
+function weakest(a, b) {
+    const rank = { active: 0, possible: 1, disabled: 2 };
+    return rank[a] >= rank[b] ? a : b;
+}
+/** Bouwt de complete beslisboom van binnenkomst tot afgehandelde order. */
+export function buildFlowTree(settings, overrides) {
+    const veilig = settings && typeof settings === "object" ? settings : {};
+    const nodes = [];
+    const edges = [];
+    const decisionIds = new Map();
+    const pendingRefs = [];
+    const add = (node) => {
+        const size = NODE_SIZE[node.kind];
+        const n = { ...node, ancestors: node.ancestors ?? [], w: size.w, h: size.h };
+        nodes.push(n);
+        return n;
+    };
+    const link = (from, to, state, label, ancestors = [], kind = "flow") => {
+        edges.push({ id: `${kind}:${from}->${to}:${label ?? ""}`, from, to, label, state, kind, ancestors });
+    };
+    // ── Start en herkomst ──────────────────────────────────────────────────────
+    add({
+        id: "__start",
+        kind: "start",
+        label: "Order komt binnen",
+        sublabel: "Floriday of eigen verkoop",
+        state: "active",
+        help: [
+            "Hier begint de route. Elke order die binnenkomt start bovenaan deze kaart en loopt via alle stappen naar 'Order afgehandeld'.",
+            "Gekleurde vakjes en dikke pijlen zijn de route die nu geldt. Lichte vakjes zijn keuzes die je ook kunt maken; grijze, gestippelde takken zijn op dit moment niet bereikbaar door een keuze eerder in de route.",
+        ],
+    });
+    add({
+        id: "__bron",
+        kind: "source",
+        label: "Waar komt de order vandaan?",
+        sublabel: "vaste regel — geen instelling",
+        state: "active",
+        help: [
+            "De engine herkent zelf waar een order vandaan komt: Floriday, de mailbox voor bestellingen, de actiemail of handmatige invoer. Dit is geen instelling; alle vier de routes bestaan altijd.",
+            "Het verschil zit vooral bij de verzendbrief: een Floriday-order krijgt uitsluitend de officiële Floriday-afleverbrief, de overige orders de eigen verzendbrieflayout uit de Layout maker.",
+            "Verder doorlopen alle orders dezelfde stappen en dezelfde regels hieronder.",
+        ],
+    });
+    link("__start", "__bron", "active");
+    add({ id: "__bron_merge", kind: "merge", label: "", state: "active", help: [] });
+    const bronnen = [
+        {
+            id: "__bron_floriday",
+            label: "Bestellingen uit Floriday",
+            sub: "order_source: floriday",
+            help: [
+                "Floriday levert per artikel een eigen verkooporder aan. Eén bestelling van één klant komt daardoor binnen als losse regels met elk een eigen FO-nummer.",
+                "Daarom volgt hierna eerst de stap 'Bestelregels samenvoegen'.",
+            ],
+        },
+        {
+            id: "__bron_mail",
+            label: "Bestellingen uit de mail",
+            sub: "mailbox voor bestellingen",
+            help: [
+                "Bestellingen die per e-mail binnenkomen en via de mailboxmodule als ordervoorstel worden goedgekeurd.",
+                "Een goedgekeurd voorstel wordt één order en loopt daarna dezelfde route als alle andere orders.",
+            ],
+        },
+        {
+            id: "__bron_actiemail",
+            label: "Bestellingen uit de actiemail",
+            sub: "actiemail kwekers",
+            help: [
+                "Bestellingen die voortkomen uit een actiemail aan kwekers/klanten.",
+                "Ook deze orders lopen daarna dezelfde route als alle andere orders.",
+            ],
+        },
+        {
+            id: "__bron_handmatig",
+            label: "Handmatige bestellingen",
+            sub: "ingevoerd in verkoop",
+            help: [
+                "Orders die een medewerker zelf aanmaakt in het verkoopscherm.",
+                "Deze orders zijn al één bestelling met één ordernummer en worden niet samengevoegd.",
+            ],
+        },
+    ];
+    for (const b of bronnen) {
+        add({ id: b.id, kind: "source", label: b.label, sublabel: b.sub, state: "active", help: b.help });
+        link("__bron", b.id, "active");
+    }
+    // ── Floriday: bestelregels eerst samenvoegen tot één bestelling ────────────
+    const ovFields = (veilig["order_verwerking"]?.fields ?? {});
+    const samenvoegenAan = ovFields["floriday_merge_lines"] !== false;
+    add({
+        id: "stap:bestelregels_samenvoegen",
+        kind: "step",
+        label: "Bestelregels samenvoegen",
+        sublabel: samenvoegenAan
+            ? "aan — regels van dezelfde klant en levermoment worden één bestelling"
+            : "uit — elke Floriday-regel blijft een eigen order",
+        state: samenvoegenAan ? "active" : "disabled",
+        storeId: "order_verwerking",
+        fieldKeys: ["floriday_merge_lines"],
+        lines: [
+            samenvoegenAan
+                ? "Samenvoegen: aan (zelfde klant, levermoment en afleverlocatie)"
+                : "Samenvoegen: uit",
+            "Laagste FO-nummer blijft het ordernummer",
+            "Al ingedeelde, geprinte of gecontroleerde orders blijven ongewijzigd",
+        ],
+        help: [
+            "Floriday stuurt elke bestelregel als een eigen verkooporder. Deze stap bundelt de regels van dezelfde klant, hetzelfde levermoment en dezelfde afleverlocatie tot één bestelling met één ordernummer.",
+            "Het laagste FO-nummer van de groep blijft staan; de andere nummers worden als herkomst bewaard, zodat documenten en terugkoppeling naar Floriday blijven kloppen.",
+            "Orders die al vastliggen (ingedeeld, geprint, gescand of afgehandeld) worden nooit alsnog samengevoegd.",
+        ],
+    });
+    link("__bron_floriday", "stap:bestelregels_samenvoegen", samenvoegenAan ? "active" : "possible");
+    link("stap:bestelregels_samenvoegen", "__bron_merge", samenvoegenAan ? "active" : "possible");
+    link("__bron_mail", "__bron_merge", "active");
+    link("__bron_actiemail", "__bron_merge", "active");
+    link("__bron_handmatig", "__bron_merge", "active");
+    let tail = "__bron_merge";
+    // ── Stappen ────────────────────────────────────────────────────────────────
+    WIZARD_STEPS.forEach((step, index) => {
+        const values = (veilig?.[step.storeId]?.fields ?? {});
+        const groups = Array.isArray(step.groups) ? step.groups : [];
+        const fieldsInOrder = [];
+        for (const group of groups) {
+            for (const field of Array.isArray(group.fields) ? group.fields : []) {
+                if (field.type === "guidance")
+                    continue;
+                fieldsInOrder.push({ field, group });
+            }
+        }
+        const keysHere = new Set(fieldsInOrder.map((f) => f.field.key));
+        const order = new Map(fieldsInOrder.map((f, i) => [f.field.key, i]));
+        // Elk veld hangt onder de "diepste" beslissing uit dezelfde stap waar het
+        // van afhangt (de regel waarvan het bronveld het laatst in de volgorde staat).
+        const childrenOf = new Map();
+        const roots = [];
+        for (const item of fieldsInOrder) {
+            const local = rulesOf(item.field).filter((r) => !r.step && keysHere.has(r.key));
+            if (!local.length) {
+                roots.push(item);
+                continue;
+            }
+            const parentRule = local.reduce((best, r) => (order.get(r.key) ?? -1) > (order.get(best.key) ?? -1) ? r : best);
+            const list = childrenOf.get(parentRule.key) ?? [];
+            list.push({ ...item, rule: parentRule });
+            childrenOf.set(parentRule.key, list);
+        }
+        const ctx = {
+            nodes,
+            edges,
+            settings: veilig,
+            step,
+            values,
+            fieldsInOrder,
+            childrenOf,
+            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",
+            label: `${index + 1}. ${step.label}`,
+            sublabel: step.description,
+            stepId: step.id,
+            storeId: step.storeId,
+            state: "active",
+            help: [
+                step.description,
+                `Achter deze stap staan ${fieldsInOrder.length} instellingen. Klik op het vakje om ze allemaal in het zijpaneel te openen.`,
+                "De vertakkingen hieronder laten zien welke instellingen alleen gelden bij een bepaalde keuze.",
+            ],
+        });
+        link(tail, stepNode.id, "active");
+        const stapMerge = `samen:stap:${step.id}`;
+        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({
+        id: "__eind",
+        kind: "end",
+        label: "Order afgehandeld",
+        sublabel: "gecontroleerd en afgemeld",
+        state: "active",
+        help: [
+            "Dit is het einde van de route: de order is gepickt, gecontroleerd en afgemeld.",
+            "Pas als alle stappen hierboven doorlopen zijn, komt een order hier terecht.",
+        ],
+    });
+    link(tail, "__eind", "active");
+    // ── Verwijspijlen tussen stappen ───────────────────────────────────────────
+    for (const ref of pendingRefs) {
+        const from = decisionIds.get(`${ref.storeId}:${ref.key}`);
+        if (!from)
+            continue;
+        const fromNode = nodes.find((n) => n.id === from);
+        const label = fromNode
+            ? ref.values
+                .map((v) => fromNode.options?.find((o) => o.value === String(v))?.label ?? String(v))
+                .join(" / ")
+            : undefined;
+        link(from, ref.toNode, ref.state, label, ref.ancestors, "ref");
+    }
+    // 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
+ * met al haar keuzes; losse instellingen worden per blok gebundeld in één
+ * vakje. Alle armen komen samen in `mergeId`.
+ */
+function fan(ctx, from, fromState, items, ancestors, mergeId) {
+    const size = NODE_SIZE;
+    // `from` is uniek per tak (stap, of het tussenpunt van een keuze).
+    const takSleutel = from.replace(/[^a-z0-9_]+/gi, "_");
+    const push = (e) => {
+        ctx.edges.push({
+            id: `${e.kind ?? "flow"}:${e.from}->${e.to}:${e.suffix ?? e.label ?? ""}`,
+            from: e.from,
+            to: e.to,
+            label: e.label,
+            state: e.state,
+            kind: e.kind ?? "flow",
+            ancestors: e.ancestors,
+        });
+    };
+    const uitlegVoor = (field, group, state) => {
+        const help = [];
+        const uitleg = fieldHelp(field);
+        if (uitleg)
+            help.push(uitleg);
+        help.push(`Onderdeel van stap "${ctx.step.label}", blok "${group.label}".`);
+        help.push(`Nu ingesteld op: ${valueText(field, ctx.values[field.key])}.`);
+        if (ancestors.length) {
+            help.push(`Deze tak geldt alleen onder: ${ancestors
+                .map((a) => ctx.nodes.find((n) => n.id === a)?.label ?? a)
+                .join(" → ")}.`);
+        }
+        if (state === "disabled") {
+            help.push("Deze tak is op dit moment niet bereikbaar door een keuze eerder in de route.");
+        }
+        else if (state === "possible") {
+            help.push("Deze tak is mogelijk, maar niet de keuze die nu geldt.");
+        }
+        return help;
+    };
+    const verwijzingen = (field, toNode, state, help) => {
+        for (const rule of rulesOf(field)) {
+            if (!rule.step)
+                continue;
+            ctx.pendingRefs.push({ toNode, storeId: rule.step, key: rule.key, values: rule.in, state, ancestors });
+            help.push("De gestippelde pijl laat zien van welke keuze uit een andere stap dit vakje afhangt.");
+        }
+    };
+    const stateVan = (field) => fieldVisible(field, ctx.values, ctx.settings) ? fromState : weakest(fromState, "disabled");
+    let armen = 0;
+    // ── Losse instellingen: per blok één vakje ────────────────────────────────
+    const losse = items.filter((i) => !isDecision(i.field));
+    const perBlok = new Map();
+    for (const { field, group } of losse) {
+        const b = perBlok.get(group.id) ?? { group, fields: [] };
+        b.fields.push(field);
+        perBlok.set(group.id, b);
+    }
+    for (const { group, fields } of perBlok.values()) {
+        const id = `blok:${ctx.step.storeId}:${group.id}:${takSleutel}`;
+        const states = fields.map(stateVan);
+        const state = states.some((s) => s !== "disabled") ? fromState : weakest(fromState, "disabled");
+        const lines = fields.map((f) => `${f.label}: ${valueText(f, ctx.values[f.key])}`);
+        const help = [];
+        if (group.description)
+            help.push(group.description);
+        help.push(`Vaste instellingen in blok "${group.label}" van stap "${ctx.step.label}":`);
+        help.push(...lines);
+        help.push("Dubbelklik op het vakje om deze instellingen hier meteen aan te passen.");
+        for (const f of fields)
+            verwijzingen(f, id, state, help);
+        const h = Math.min(6, lines.length) * 16 + 44;
+        ctx.nodes.push({
+            id,
+            kind: "setting",
+            label: group.label,
+            sublabel: `${fields.length} instelling${fields.length === 1 ? "" : "en"}`,
+            lines,
+            fieldKeys: fields.map((f) => f.key),
+            state,
+            stepId: ctx.step.id,
+            storeId: ctx.step.storeId,
+            ancestors,
+            help,
+            w: size.setting.w,
+            h,
+        });
+        push({ from, to: id, state, ancestors });
+        push({ from: id, to: mergeId, state, ancestors });
+        armen++;
+    }
+    // ── Beslissingen: elke keuze een eigen tak ────────────────────────────────
+    for (const { field, group } of items) {
+        if (!isDecision(field))
+            continue;
+        const state = stateVan(field);
+        const id = `keuze:${ctx.step.storeId}:${field.key}`;
+        const value = ctx.values[field.key];
+        const options = optionsOf(field);
+        const current = currentOf(field, value);
+        const eigenMerge = `samen:${ctx.step.storeId}:${field.key}`;
+        const help = uitlegVoor(field, group, state);
+        help.push(`Mogelijke keuzes: ${options.map((o) => o.label).join(" · ")}. Kies je hier iets anders, dan wordt meteen een andere tak actief én werkt de engine daarna volgens die keuze.`);
+        verwijzingen(field, id, state, help);
+        ctx.nodes.push({
+            id,
+            kind: "decision",
+            label: field.label,
+            sublabel: group.label,
+            state,
+            stepId: ctx.step.id,
+            storeId: ctx.step.storeId,
+            fieldKey: field.key,
+            fieldKeys: [field.key],
+            options,
+            currentValue: current,
+            isBoolean: field.type === "toggle",
+            mergeId: eigenMerge,
+            ancestors,
+            help,
+            w: size.decision.w,
+            h: size.decision.h,
+        });
+        ctx.decisionIds.set(`${ctx.step.storeId}:${field.key}`, id);
+        push({ from, to: id, state, ancestors });
+        const kinderen = ctx.childrenOf.get(field.key) ?? [];
+        const takAncestors = [...ancestors, id];
+        // Takken: één per verzameling keuzes waar dezelfde kinderen onder hangen,
+        // zodat een instelling die bij "scanner" én "scan_only" geldt één vakje blijft.
+        const takken = new Map();
+        for (const k of kinderen) {
+            const waarden = options.map((o) => o.value).filter((v) => k.rule.in.some((r) => String(r) === v));
+            if (!waarden.length)
+                continue;
+            const sleutel = waarden.join("|");
+            const tak = takken.get(sleutel) ?? { waarden, kinderen: [] };
+            tak.kinderen.push(k);
+            takken.set(sleutel, tak);
+        }
+        const gedekt = new Set([...takken.values()].flatMap((t) => t.waarden));
+        const labelVan = (waarden) => waarden.map((v) => options.find((o) => o.value === v)?.label ?? v).join(" / ");
+        for (const option of options) {
+            if (gedekt.has(option.value))
+                continue;
+            // Keuze zonder eigen vervolg: een klein label-vakje, zodat alle uitkomsten
+            // naast elkaar zichtbaar blijven.
+            const optState = edgeState(state, option.value === current);
+            const optId = `optie:${ctx.step.storeId}:${field.key}:${option.value}`;
+            ctx.nodes.push({
+                id: optId,
+                kind: "option",
+                label: option.label,
+                state: optState,
+                stepId: ctx.step.id,
+                storeId: ctx.step.storeId,
+                fieldKey: field.key,
+                ancestors: takAncestors,
+                help: [
+                    `Uitkomst "${option.label}" van "${field.label}".`,
+                    optState === "active"
+                        ? "Dit is de keuze die nu geldt."
+                        : "Deze keuze geldt nu niet; kies hem in de beslistegel om deze tak actief te maken.",
+                    "Er hangen geen extra instellingen onder deze uitkomst; de route gaat direct verder.",
+                ],
+                w: size.option.w,
+                h: size.option.h,
+            });
+            push({ from: id, to: optId, state: optState, ancestors: takAncestors });
+            push({ from: optId, to: eigenMerge, state: optState, ancestors: takAncestors });
+        }
+        for (const [sleutel, tak] of takken) {
+            const takState = edgeState(state, tak.waarden.includes(current));
+            // Klein tussenpunt met het keuzelabel; daarachter waaieren de kinderen uit.
+            const takId = `tak:${ctx.step.storeId}:${field.key}:${sleutel}`;
+            ctx.nodes.push({
+                id: takId,
+                kind: "merge",
+                label: "",
+                state: takState,
+                ancestors: takAncestors,
+                help: [],
+                w: size.merge.w,
+                h: size.merge.h,
+            });
+            push({ from: id, to: takId, label: labelVan(tak.waarden), suffix: sleutel, state: takState, ancestors: takAncestors });
+            const sub = { ...ctx };
+            fan(sub, takId, takState, tak.kinderen, takAncestors, eigenMerge);
+        }
+        ctx.nodes.push({ id: eigenMerge, kind: "merge", label: "", state, ancestors, help: [], w: size.merge.w, h: size.merge.h });
+        push({ from: eigenMerge, to: mergeId, state, ancestors });
+        armen++;
+    }
+    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 };
+}