@flowselections/logistiek-engine 1.0.34 → 1.0.89

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

@@ -0,0 +1 @@
+{"version":3,"file":"stopReden.d.ts","sourceRoot":"","sources":["../../src/lib/stopReden.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAG7E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAGlD,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,UAAU,GAAG,WAAW,GAAG,gBAAgB,GAAG,OAAO,CAAC;AAE1F,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,SAAS,CAAC;IACjB,8DAA8D;IAC9D,KAAK,EAAE,MAAM,CAAC;IACd,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,4CAA4C;IAC5C,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,mCAAmC;IACnC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,oEAAoE;IACpE,SAAS,EAAE,OAAO,CAAC;CACpB;AAiBD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE;IACpC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;CACzB,GAAG,SAAS,CA+BZ;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;IAC9B,KAAK,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,GAAG,SAAS,CA+FZ;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,oBAAoB,GAAG,IAAI,GAAG,SAAS,GAAG,SAAS,GAAG,IAAI,CAsC7F"}

package/dist-lib/lib/stopReden.js

@@ -0,0 +1,197 @@
+// ============================================================================
+// src/lib/stopReden.ts — waarom houdt de reis van deze order hier op?
+// ============================================================================
+// Eén bron van waarheid voor de tekst "Hier stopt de flow", die op het vakje in
+// de kaart, in het zijpaneel en in de balk boven de kaart wordt getoond.
+// Alleen lezen: hier wordt niets bepaald of gewijzigd.
+// ============================================================================
+import { FLOW_NODE, flowNodeLabel } from "./flowNodes";
+import { foutSoort, foutTekst } from "./foutTekst";
+import { vakUitleg } from "./vakUitleg";
+const WACHTRIJ_TEKST = {
+    pending: "de berekening staat in de wachtrij en is nog niet opgepakt",
+    queued: "de berekening staat in de wachtrij en is nog niet opgepakt",
+    running: "de berekening is op dit moment bezig",
+    blocked: "de berekening is geblokkeerd",
+    failed: "de laatste berekening is mislukt",
+};
+function tijdTekst(waarde) {
+    if (!waarde)
+        return null;
+    const d = new Date(waarde);
+    if (Number.isNaN(d.getTime()))
+        return null;
+    return d.toLocaleString("nl-NL", { day: "2-digit", month: "2-digit", hour: "2-digit", minute: "2-digit" });
+}
+/**
+ * Waarom de flow bij een samenkomstpunt blijft staan: de ingestelde voorwaarde
+ * is nog niet gehaald, of een verplichte tak is mislukt.
+ */
+export function samenkomstStop(input) {
+    const wachtOp = Array.isArray(input.wachtOp) ? input.wachtOp : [];
+    const mislukt = Array.isArray(input.mislukt) ? input.mislukt : [];
+    const feiten = [
+        `Voorwaarde: ${input.voorwaarde}`,
+        `Maximale wachttijd: ${input.maxWachtMinuten} minuten`,
+    ];
+    if (wachtOp.length > 0)
+        feiten.push(`Nog niet klaar: ${wachtOp.join(", ")}`);
+    if (mislukt.length > 0) {
+        return {
+            soort: "mislukt",
+            titel: "Hier wacht de flow op een tak die is mislukt",
+            reden: `De verplichte tak ${mislukt.join(", ")} is mislukt, dus dit samenkomstpunt laat de order niet door.`,
+            feiten,
+            volgendeStap: "Oorzaak in die tak oplossen, of de voorwaarde van dit samenkomstpunt aanpassen",
+            verouderd: false,
+        };
+    }
+    return {
+        soort: "handeling",
+        titel: "De flow wacht hier op andere takken",
+        reden: wachtOp.length > 0
+            ? `Dit samenkomstpunt laat de order pas door als ${input.voorwaarde} klaar is. Nog niet klaar: ${wachtOp.join(", ")}.`
+            : `Dit samenkomstpunt laat de order pas door als ${input.voorwaarde} klaar is.`,
+        feiten,
+        volgendeStap: `Wachten tot die tak klaar is; na ${input.maxWachtMinuten} minuten gaat de flow alsnog verder`,
+        verouderd: false,
+    };
+}
+/**
+ * Bepaalt in gewone taal waarom de blauwe route bij dit vakje ophoudt.
+ * Werkt ook als er voor dit vakje nog niets is vastgelegd.
+ */
+export function stopReden(input) {
+    const { nodeId, groep = null, stand = null } = input;
+    const verouderd = input.verouderd === true;
+    const uitleg = groep ? vakUitleg(groep) : null;
+    const feiten = uitleg ? [...uitleg.feiten] : [];
+    const vervolg = groep?.volgendeStap ?? stand?.nextStep ?? null;
+    const vakNaam = flowNodeLabel(nodeId);
+    const queue = (stand?.queueStatus ?? "").toLowerCase();
+    const standHier = !stand?.stuckNode || stand.stuckNode === nodeId;
+    // 1. Mislukt: er is een echte fout vastgelegd.
+    const foutmelding = groep?.status === "mislukt"
+        ? foutTekst(groep.reden ?? null)
+        : standHier && stand?.stuckStatus === "mislukt"
+            ? foutTekst(stand.stuckReason ?? stand.stuckError ?? stand.queueError ?? null)
+            : null;
+    if (foutmelding || queue === "failed") {
+        const soortFout = groep?.errorClass ?? foutSoort(stand?.stuckReason ?? stand?.queueError ?? null) ?? null;
+        if (soortFout)
+            feiten.push(`Foutsoort: ${soortFout}`);
+        if (stand?.tries && stand.tries > 0)
+            feiten.push(`Automatische pogingen: ${stand.tries}`);
+        const volgende = tijdTekst(stand?.nextAttemptAt);
+        if (volgende)
+            feiten.push(`Volgende poging: ${volgende}`);
+        const sinds = tijdTekst(stand?.blockedSince);
+        if (sinds)
+            feiten.push(`Geblokkeerd sinds: ${sinds}`);
+        return {
+            soort: "mislukt",
+            titel: "Hier is de order vastgelopen",
+            reden: foutmelding ??
+                foutTekst(stand?.queueError ?? null) ??
+                `De berekening van ${vakNaam} is mislukt.`,
+            feiten,
+            volgendeStap: vervolg ?? "Oorzaak oplossen en de order opnieuw aanmelden in de wachtrij",
+            verouderd,
+        };
+    }
+    // 2. Helemaal klaar.
+    if (nodeId === FLOW_NODE.eind) {
+        return {
+            soort: "klaar",
+            titel: "Hier eindigt de reis: de order is afgehandeld",
+            reden: uitleg?.waarom ?? "Alle karren zijn gepickt en gecontroleerd.",
+            feiten,
+            volgendeStap: null,
+            verouderd,
+        };
+    }
+    // 3. De berekening loopt nog of staat in de wachtrij.
+    if (queue && WACHTRIJ_TEKST[queue]) {
+        if (stand?.attempts && stand.attempts > 0)
+            feiten.push(`Pogingen: ${stand.attempts}`);
+        const volgende = tijdTekst(stand?.nextAttemptAt);
+        if (volgende)
+            feiten.push(`Volgende poging: ${volgende}`);
+        return {
+            soort: "wachtrij",
+            titel: "De flow staat hier stil: de berekening is nog niet klaar",
+            reden: `De reis houdt op bij ${vakNaam} omdat ${WACHTRIJ_TEKST[queue]}.`,
+            feiten,
+            volgendeStap: vervolg,
+            verouderd,
+        };
+    }
+    // 4. Wacht op een handeling (picken, printen, scannen, controle).
+    if (groep?.status === "wachtend" || groep?.status === "waarschuwing") {
+        return {
+            soort: "handeling",
+            titel: "De flow wacht hier",
+            reden: uitleg?.waarom ??
+                `${vakNaam} is nog niet afgerond; de order wacht op de volgende handeling.`,
+            feiten,
+            volgendeStap: vervolg,
+            verouderd,
+        };
+    }
+    // 5. Deze stap is geslaagd, maar van de vervolgstap is nog niets vastgelegd.
+    return {
+        soort: "nietvastgelegd",
+        titel: "De flow stopt hier: verder is nog niets vastgelegd",
+        reden: vervolg
+            ? `${vakNaam} is afgerond, maar de volgende stap "${vervolg}" heeft voor deze order nog geen start, status of resultaat vastgelegd. Daarom kan de blauwe route nog niet aantonen dat de order daar is aangekomen.`
+            : `${vakNaam} is afgerond, maar er is voor deze order geen volgende stap of vervolgstatus vastgelegd. Daarom eindigt de aantoonbare blauwe route hier.`,
+        feiten,
+        volgendeStap: vervolg
+            ? `De stap "${vervolg}" moet starten en voor deze order een status of resultaat vastleggen.`
+            : "Controleer welke vervolgstap na dit vakje hoort te starten en waarom die nog geen status heeft vastgelegd.",
+        verouderd,
+    };
+}
+/**
+ * Waarom is de verzendbrief bij deze order nog niet opgehaald? Zet de
+ * alleen-lezen diagnose om naar dezelfde stoptekst als de rest van de kaart.
+ */
+export function verzendbriefStop(d) {
+    if (!d || !d.gevonden)
+        return null;
+    const status = (d.status ?? "").toLowerCase();
+    if (status === "geprint" || status === "klaar")
+        return null;
+    const feiten = [];
+    if (d.status)
+        feiten.push(`Status: ${d.status}`);
+    feiten.push(d.isFloriday
+        ? `Aanvragen naar Floriday: ${d.aanvragenVerstuurd}`
+        : "Eigen verzendbrief (geen Floriday-order)");
+    if (d.pogingen > 0)
+        feiten.push(`Pogingen: ${d.pogingen}`);
+    const laatste = tijdTekst(d.laatsteAanvraag);
+    if (laatste)
+        feiten.push(`Laatste aanvraag: ${laatste}`);
+    if (d.afleveropdracht)
+        feiten.push(`Afleveropdracht: ${d.afleveropdracht}`);
+    if (d.wachtreden)
+        feiten.push(`Wachtreden: ${d.wachtreden}`);
+    // Een Floriday-order die wacht zonder ook maar één aanvraag is een fout in de
+    // omgeving, geen normale toestand. Ook een mislukte status is een fout.
+    const fout = status === "failed" ||
+        status === "mislukt" ||
+        status === "error" ||
+        (d.isFloriday && d.aanvragenVerstuurd === 0 && d.pogingen > 0);
+    return {
+        soort: fout ? "mislukt" : "handeling",
+        titel: fout ? "Hier loopt de verzendbrief vast" : "De verzendbrief is nog niet opgehaald",
+        reden: d.reden ??
+            (d.isFloriday
+                ? "Er is nog geen officiele Floriday-afleverbrief opgehaald voor deze order."
+                : "De verzendbrief voor deze order is nog niet aangemaakt."),
+        feiten,
+        volgendeStap: d.actie ?? null,
+        verouderd: false,
+    };
+}

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

@@ -0,0 +1,2 @@
+export declare function tellOpenTaken(rows: unknown): Record<string, number>;
+//# sourceMappingURL=taskCounts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"taskCounts.d.ts","sourceRoot":"","sources":["../../src/lib/taskCounts.ts"],"names":[],"mappings":"AAEA,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAUnE"}

package/dist-lib/lib/taskCounts.js

@@ -0,0 +1,15 @@
+// Takenteller: zet de databasetelling (open/geplande taken per module) om naar een map.
+// Fail-closed: onleesbare invoer levert een lege telling op, geen verzonnen aantallen.
+export function tellOpenTaken(rows) {
+    const out = {};
+    if (!Array.isArray(rows))
+        return out;
+    for (const r of rows) {
+        const mod = typeof r?.owner_module === "string" ? r.owner_module : null;
+        const n = Number(r?.open_count);
+        if (!mod || !Number.isFinite(n) || n < 0)
+            continue;
+        out[mod] = (out[mod] ?? 0) + n;
+    }
+    return out;
+}

package/dist-lib/lib/taskCounts.test.d.ts

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

package/dist-lib/lib/taskCounts.test.d.ts.map

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

package/dist-lib/lib/taskCounts.test.js

@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import { tellOpenTaken } from "./taskCounts";
+describe("tellOpenTaken", () => {
+    it("telt per module", () => {
+        expect(tellOpenTaken([{ owner_module: "verkoop", open_count: "36" }, { owner_module: "afhandeling", open_count: 136 }]))
+            .toEqual({ verkoop: 36, afhandeling: 136 });
+    });
+    it("onleesbare invoer geeft lege telling", () => {
+        expect(tellOpenTaken(null)).toEqual({});
+        expect(tellOpenTaken([{ owner_module: "x", open_count: "abc" }, { open_count: 3 }])).toEqual({});
+    });
+});

package/dist-lib/lib/trace.server.d.ts

@@ -0,0 +1,75 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+export type TraceStatus = "geslaagd" | "wachtend" | "waarschuwing" | "overgeslagen" | "mislukt";
+/**
+ * Foutsoort — zodat het logboek onderscheid maakt tussen een storing en een
+ * bewuste regel.
+ *  technisch            = database/API/printer/integratie ging stuk
+ *  ontbrekende_gegevens = de order of stamgegevens missen iets
+ *  configuratie         = een instelling of koppeling staat niet goed
+ *  regel                = de Engine mag bewust niet verder (business rule)
+ *  extern               = een extern systeem heeft (nog) niet geleverd
+ */
+export type TraceErrorClass = "technisch" | "ontbrekende_gegevens" | "configuratie" | "regel" | "extern";
+/** Berekening achter een beslissing, in begrijpelijke stappen. */
+export interface TraceCalc {
+    /** Welke instelling(en) meespeelden. */
+    setting?: string;
+    /** De gebruikte waarden, bijv. { lagen: 7, maxPerKar: 5 }. */
+    values?: Record<string, unknown>;
+    /** De rekenstap zelf, bijv. "7 / 5". */
+    formula?: string;
+    /** De uitkomst, bijv. "1 volle kar + 1 deelkar". */
+    result?: string;
+    /** Conclusie in gewone taal. */
+    conclusion?: string;
+}
+export interface TraceEvent {
+    traceId?: string | null;
+    orderRef?: string | null;
+    orderSource?: "floriday" | "eigen" | null;
+    cartRef?: string | null;
+    slipRef?: string | null;
+    phase: string;
+    step: string;
+    status: TraceStatus;
+    actor?: string;
+    /** Vakje in de flowkaart waar deze stap hoort (id uit flowTree). */
+    nodeId?: string;
+    input?: unknown;
+    output?: unknown;
+    reads?: unknown;
+    decision?: string;
+    reason?: string;
+    values?: unknown;
+    rule?: string;
+    /** Berekening achter de beslissing. */
+    calc?: TraceCalc;
+    /** Wat de order hierna gaat doen. */
+    nextStep?: string;
+    errorClass?: TraceErrorClass;
+    dbTable?: string;
+    dbRecord?: string;
+    dbAction?: string;
+    dbOld?: unknown;
+    dbNew?: unknown;
+    externalSystem?: string;
+    externalAction?: string;
+    externalRef?: string;
+    externalStatus?: string;
+    externalResponse?: unknown;
+    error?: string;
+    attempts?: number;
+    nextAttemptAt?: string | null;
+    durationMs?: number;
+}
+/** Bepaalt de foutsoort uit een reden-code of foutmelding. */
+export declare function classifyError(reasonCode?: string | null, message?: string | null): TraceErrorClass;
+/** Nieuw trace-id voor één volledige verwerkingsronde van een order. */
+export declare function newTraceId(): string;
+/** Eén gebeurtenis vastleggen. Faalt nooit hard. */
+export declare function trace(sb: SupabaseClient, event: TraceEvent): Promise<void>;
+/** Meerdere gebeurtenissen in één keer vastleggen. */
+export declare function traceBatch(sb: SupabaseClient, events: TraceEvent[]): Promise<void>;
+/** Meet de duur van een stap en legt uitkomst of fout vast. */
+export declare function traced<T>(sb: SupabaseClient, event: Omit<TraceEvent, "status">, run: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=trace.server.d.ts.map

package/dist-lib/lib/trace.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.server.d.ts","sourceRoot":"","sources":["../../src/lib/trace.server.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,78 @@
+// ============================================================================
+// src/lib/trace.server.ts — audittrail vanuit de Engine zelf
+// ============================================================================
+// Elke stap, beslissing, databasewijziging en externe aanvraag wordt hier
+// vastgelegd via public.logistics_trace. Loggen mag de verwerking nooit
+// blokkeren: fouten worden bewust ingeslikt.
+// ============================================================================
+/** Bepaalt de foutsoort uit een reden-code of foutmelding. */
+export function classifyError(reasonCode, message) {
+    const t = `${reasonCode ?? ""} ${message ?? ""}`.toLowerCase();
+    // Een volle planronde of een tijdslimiet bij het opslaan is druk, geen stukloop.
+    if (/deadline|statement timeout|deadlock/.test(t))
+        return "regel";
+    if (/afmeting|ontbreek|onbekend|geen regels|mist|niet gevuld|leeg/.test(t))
+        return "ontbrekende_gegevens";
+    if (/instelling|configurat|layout|mapping|niet ingesteld|werktijden/.test(t))
+        return "configuratie";
+    if (/kargrens|regel|niet toegestaan|geblokkeerd|vrijgave|aanmeldmoment|bevroren/.test(t))
+        return "regel";
+    if (/floriday|api|http|timeout|extern|printer/.test(t))
+        return "extern";
+    return "technisch";
+}
+/** Nieuw trace-id voor één volledige verwerkingsronde van een order. */
+export function newTraceId() {
+    return globalThis.crypto?.randomUUID?.() ?? "";
+}
+function clean(event) {
+    const out = {};
+    for (const [key, value] of Object.entries(event)) {
+        if (value !== undefined && value !== null && value !== "")
+            out[key] = value;
+    }
+    return out;
+}
+/** Eén gebeurtenis vastleggen. Faalt nooit hard. */
+export async function trace(sb, event) {
+    try {
+        await sb.rpc("logistics_trace", { p: clean(event) });
+    }
+    catch {
+        /* loggen mag de verwerking niet blokkeren */
+    }
+}
+/** Meerdere gebeurtenissen in één keer vastleggen. */
+export async function traceBatch(sb, events) {
+    if (!Array.isArray(events) || events.length === 0)
+        return;
+    try {
+        await sb.rpc("logistics_trace_batch", { p: events.map(clean) });
+    }
+    catch {
+        /* loggen mag de verwerking niet blokkeren */
+    }
+}
+/** Meet de duur van een stap en legt uitkomst of fout vast. */
+export async function traced(sb, event, run) {
+    const start = Date.now();
+    try {
+        const result = await run();
+        await trace(sb, {
+            ...event,
+            status: "geslaagd",
+            durationMs: Date.now() - start,
+            output: event.output ?? result,
+        });
+        return result;
+    }
+    catch (e) {
+        await trace(sb, {
+            ...event,
+            status: "mislukt",
+            durationMs: Date.now() - start,
+            error: String(e?.message ?? e),
+        });
+        throw e;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { type NodeTraceGroep } from "./nodeTrace";
+export interface VakUitleg {
+    /** Welke keuze de Engine hier maakte. */
+    beslissing: string;
+    /** Waarom die keuze is gemaakt. */
+    waarom: string | null;
+    /** De bepalende gegevens en instellingen, als korte paren. */
+    feiten: string[];
+    /** Regel/instelling waarop de keuze steunt. */
+    regel: string | null;
+    /** Is dit afgeleid uit de registraties in plaats van vastgelegd? */
+    afgeleid: boolean;
+}
+/**
+ * Maakt van de gebeurtenissen van één vakje een vaste uitleg:
+ * welke keuze is gemaakt, waarom, en welke gegevens dat bepaalden.
+ */
+export declare function vakUitleg(groep: NodeTraceGroep): VakUitleg;
+//# sourceMappingURL=vakUitleg.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vakUitleg.d.ts","sourceRoot":"","sources":["../../src/lib/vakUitleg.ts"],"names":[],"mappings":"AAUA,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAEjE,MAAM,WAAW,SAAS;IACxB,yCAAyC;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,mCAAmC;IACnC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,8DAA8D;IAC9D,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,+CAA+C;IAC/C,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,oEAAoE;IACpE,QAAQ,EAAE,OAAO,CAAC;CACnB;AA6DD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,CAoD1D"}

package/dist-lib/lib/vakUitleg.js

@@ -0,0 +1,133 @@
+// ============================================================================
+// src/lib/vakUitleg.ts — wat is er in dit vakje besloten, en waarom
+// ============================================================================
+// Eén bron van uitleg voor zowel het vakje op de flowkaart als het zijpaneel.
+// Alleen lezen: hier wordt niets bepaald, alleen leesbaar gemaakt.
+// ============================================================================
+import { FLOW_NODE } from "./flowNodes";
+import { foutTekst } from "./foutTekst";
+import { isAutomatisch } from "./nodeTrace";
+const LABELS = {
+    aanmeldmoment: "Aanmeldmoment",
+    nu: "Huidige tijd",
+    huidigeTijd: "Huidige tijd",
+    lagen: "Lagen",
+    maxPerKar: "Max. per kar",
+    karren: "Karren",
+    methode: "Methode",
+    deelkar: "Deelkar",
+    pickdatum: "Pickdatum",
+    pogingen: "Pogingen",
+    buffer: "Buffer",
+    klant: "Klant",
+};
+function labelVan(sleutel) {
+    if (LABELS[sleutel])
+        return LABELS[sleutel];
+    const met = sleutel.replace(/[_-]+/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2");
+    return met.charAt(0).toUpperCase() + met.slice(1);
+}
+function waardeVan(v) {
+    if (v === null || v === undefined || v === "")
+        return null;
+    if (typeof v === "boolean")
+        return v ? "ja" : "nee";
+    if (typeof v === "number")
+        return String(v);
+    if (typeof v === "string")
+        return v.length > 60 ? `${v.slice(0, 57)}…` : v;
+    return null;
+}
+function paren(bron, uit, gezien) {
+    if (!bron || typeof bron !== "object" || Array.isArray(bron))
+        return;
+    for (const [sleutel, waarde] of Object.entries(bron)) {
+        const tekst = waardeVan(waarde);
+        if (!tekst)
+            continue;
+        const label = labelVan(sleutel);
+        if (gezien.has(label))
+            continue;
+        gezien.add(label);
+        uit.push(`${label}: ${tekst}`);
+    }
+}
+/** Leesbare zin wanneer de Engine (nog) geen besluit vastlegde. */
+function afgeleideBeslissing(groep, laatste) {
+    const tabel = (laatste?.dbTable ?? "").toLowerCase();
+    const actie = (laatste?.dbAction ?? "").toUpperCase();
+    if (tabel === "logistics_plan_queue") {
+        if (actie === "INSERT")
+            return "Order aangemeld voor indeling";
+        if (groep.status === "mislukt")
+            return "Indeling mislukt";
+        if (groep.status === "wachtend")
+            return "Wacht op de planronde";
+        return "Indeling bijgewerkt";
+    }
+    if (groep.nodeId === FLOW_NODE.eind)
+        return "Order afgehandeld";
+    if (groep.status === "mislukt")
+        return "Hier is de order vastgelopen";
+    if (groep.status === "wachtend")
+        return "Order wacht in deze stap";
+    if (groep.status === "overgeslagen")
+        return "Deze stap is overgeslagen";
+    return "Deze stap is doorlopen";
+}
+/**
+ * Maakt van de gebeurtenissen van één vakje een vaste uitleg:
+ * welke keuze is gemaakt, waarom, en welke gegevens dat bepaalden.
+ */
+export function vakUitleg(groep) {
+    const events = Array.isArray(groep.events) ? groep.events : [];
+    const engine = events.filter((e) => !isAutomatisch(e));
+    const relevant = engine.length > 0 ? engine : events;
+    const laatste = relevant[relevant.length - 1] ?? null;
+    const laatsteMet = (kies) => {
+        for (let i = relevant.length - 1; i >= 0; i--) {
+            const ev = relevant[i];
+            if (!ev)
+                continue;
+            const v = kies(ev);
+            if (v !== null && v !== undefined && v !== "")
+                return v;
+        }
+        return null;
+    };
+    const besluit = laatsteMet((e) => e.decision);
+    const fout = [...relevant].reverse().find((e) => e.status === "mislukt") ?? null;
+    const reden = foutTekst(laatsteMet((e) => e.reason) ?? fout?.error ?? groep.reden ?? null);
+    const regel = laatsteMet((e) => e.rule);
+    const calc = laatsteMet((e) => (e.calc && typeof e.calc === "object" ? e.calc : null));
+    const feiten = [];
+    const gezien = new Set();
+    if (calc) {
+        paren(calc["values"], feiten, gezien);
+        const rekenstap = waardeVan(calc["formula"]);
+        if (rekenstap && !gezien.has("Rekenstap")) {
+            gezien.add("Rekenstap");
+            feiten.push(`Rekenstap: ${rekenstap}`);
+        }
+        const uitkomst = waardeVan(calc["result"]);
+        if (uitkomst && !gezien.has("Uitkomst")) {
+            gezien.add("Uitkomst");
+            feiten.push(`Uitkomst: ${uitkomst}`);
+        }
+        const instelling = waardeVan(calc["setting"]);
+        if (instelling && !gezien.has("Instelling")) {
+            gezien.add("Instelling");
+            feiten.push(`Instelling: ${instelling}`);
+        }
+    }
+    paren(laatsteMet((e) => e.values), feiten, gezien);
+    if (groep.pogingen > 1)
+        feiten.push(`Pogingen: ${groep.pogingen}`);
+    return {
+        beslissing: besluit ?? afgeleideBeslissing(groep, laatste),
+        waarom: reden,
+        feiten,
+        regel: regel ?? null,
+        afgeleid: !besluit,
+    };
+}