@flowselections/logistiek-engine 1.0.34 → 1.0.89

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

@@ -0,0 +1,65 @@
+import type { TraceEventRow } from "../hooks/useLogisticsTrace";
+export type NodeStatus = "geslaagd" | "wachtend" | "waarschuwing" | "overgeslagen" | "mislukt";
+export interface NodeTraceGroep {
+    nodeId: string;
+    events: TraceEventRow[];
+    aantal: number;
+    eerste: string | null;
+    laatste: string | null;
+    duurMs: number | null;
+    status: NodeStatus;
+    pogingen: number;
+    reden: string | null;
+    errorClass: string | null;
+    volgendeStap: string | null;
+    /** Auditpunt 5: dit vakje staat niet in het logboek, maar is uit de kaart afgeleid. */
+    afgeleid?: boolean;
+}
+/** Terugval voor oude gebeurtenissen zonder vastgelegd vakje. */
+export declare function gokNode(e: TraceEventRow): string | null;
+/** Groepeert de gebeurtenissen van één order per vakje van de flowkaart. */
+export declare function groepeerPerNode(events: TraceEventRow[] | null | undefined): Map<string, NodeTraceGroep>;
+/** De vakjes op volgorde van de eerste gebeurtenis: de reis van de order. */
+export declare function reisVolgorde(groepen: Map<string, NodeTraceGroep>): NodeTraceGroep[];
+export interface VakSamenvatting {
+    beslissing: string | null;
+    reden: string | null;
+    regel: string | null;
+    berekening: {
+        setting?: string;
+        formula?: string;
+        result?: string;
+        conclusion?: string;
+        values?: Record<string, unknown>;
+    } | null;
+    volgendeStap: string | null;
+    /** Auditpunt 5: dit vakje staat niet in het logboek, maar is uit de kaart afgeleid. */
+    afgeleid?: boolean;
+    fout: string | null;
+    errorClass: string | null;
+    pogingen: number;
+    volgendePoging: string | null;
+    aantalBeslissingen: number;
+    aantalAutomatisch: number;
+}
+/** Is dit een automatische database-regel (trigger) in plaats van een engine-beslissing? */
+export declare function isAutomatisch(e: TraceEventRow): boolean;
+/** Korte samenvatting van wat de Engine in dit vakje besliste. */
+export declare function samenvatVak(groep: NodeTraceGroep): VakSamenvatting;
+export interface Gebundeld {
+    key: string;
+    /** Eén losse engine-gebeurtenis, of null bij een bundel. */
+    event: TraceEventRow | null;
+    /** Bij een bundel: alle gelijksoortige automatische regels. */
+    events: TraceEventRow[];
+    aantal: number;
+    laatste: string | null;
+    label: string;
+}
+/**
+ * Engine-gebeurtenissen blijven los; automatische database-regels worden
+ * per soort (stap + tabel + actie) samengevoegd tot één regel met telling.
+ * Nieuwste eerst.
+ */
+export declare function bundelGebeurtenissen(events: TraceEventRow[] | null | undefined): Gebundeld[];
+//# sourceMappingURL=nodeTrace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nodeTrace.d.ts","sourceRoot":"","sources":["../../src/lib/nodeTrace.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAGhE,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,cAAc,GAAG,cAAc,GAAG,SAAS,CAAC;AAE/F,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,uFAAuF;IACvF,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAGD,iEAAiE;AACjE,wBAAgB,OAAO,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,GAAG,IAAI,CAwBvD;AAED,4EAA4E;AAC5E,wBAAgB,eAAe,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CA+CvG;AAED,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,cAAc,EAAE,CAMnF;AAMD,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,UAAU,EAAE;QACV,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAClC,GAAG,IAAI,CAAC;IACT,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,uFAAuF;IACvF,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,4FAA4F;AAC5F,wBAAgB,aAAa,CAAC,CAAC,EAAE,aAAa,GAAG,OAAO,CAEvD;AAQD,kEAAkE;AAClE,wBAAgB,WAAW,CAAC,KAAK,EAAE,cAAc,GAAG,eAAe,CA8BlE;AAED,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,4DAA4D;IAC5D,KAAK,EAAE,aAAa,GAAG,IAAI,CAAC;IAC5B,+DAA+D;IAC/D,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,SAAS,EAAE,CAuC5F"}

package/dist-lib/lib/nodeTrace.js

@@ -0,0 +1,182 @@
+// ============================================================================
+// src/lib/nodeTrace.ts — gebeurtenissen van een order per vakje van de flowkaart
+// ============================================================================
+// De Engine legt bij nieuwe gebeurtenissen het vakje (node_id) vast. Oudere
+// gebeurtenissen missen dat; die plaatsen we met een terugval op stap/fase.
+// Alleen lezen: hier wordt niets bepaald, alleen gegroepeerd.
+// ============================================================================
+import { FLOW_NODE } from "./flowNodes";
+/** Terugval voor oude gebeurtenissen zonder vastgelegd vakje. */
+export function gokNode(e) {
+    if (e.nodeId)
+        return e.nodeId;
+    // Automatische registraties: eerst op tabel en actie, dan pas op tekst.
+    const tabel = (e.dbTable ?? "").toLowerCase();
+    if (tabel) {
+        if (tabel === "logistics_plan_queue") {
+            return (e.dbAction ?? "").toUpperCase() === "INSERT" ? FLOW_NODE.ontvangst : FLOW_NODE.indeling;
+        }
+        if (/control|scan/.test(tabel))
+            return FLOW_NODE.controle;
+        if (/print|slip|shipping_note|document/.test(tabel))
+            return FLOW_NODE.stations;
+        if (/pick|cart/.test(tabel))
+            return FLOW_NODE.picken;
+        if (/order/.test(tabel))
+            return FLOW_NODE.ontvangst;
+    }
+    const t = `${e.phase ?? ""} ${e.step ?? ""}`.toLowerCase();
+    if (/binnengekomen|ontvangst|nieuwe order|combineren|buffer/.test(t))
+        return FLOW_NODE.ontvangst;
+    if (/indeling|plan|kar|belading/.test(t))
+        return FLOW_NODE.indeling;
+    if (/pick(?!station)/.test(t))
+        return FLOW_NODE.picken;
+    if (/vrijgave|aanmeld|drukte|vertraging|wacht/.test(t))
+        return FLOW_NODE.vrijgave;
+    if (/pakbon|print|verzendbrief|document|station|floriday/.test(t))
+        return FLOW_NODE.stations;
+    if (/controle|scan|afmeld/.test(t))
+        return FLOW_NODE.controle;
+    if (/afgehandeld|gereed|klaar/.test(t))
+        return FLOW_NODE.eind;
+    return null;
+}
+/** Groepeert de gebeurtenissen van één order per vakje van de flowkaart. */
+export function groepeerPerNode(events) {
+    const veilig = Array.isArray(events) ? events : [];
+    const map = new Map();
+    for (const e of veilig) {
+        const id = gokNode(e);
+        if (!id)
+            continue;
+        const bestaand = map.get(id);
+        if (bestaand) {
+            bestaand.events.push(e);
+        }
+        else {
+            map.set(id, {
+                nodeId: id,
+                events: [e],
+                aantal: 0,
+                eerste: null,
+                laatste: null,
+                duurMs: null,
+                status: "geslaagd",
+                pogingen: 0,
+                reden: null,
+                errorClass: null,
+                volgendeStap: null,
+            });
+        }
+    }
+    for (const groep of map.values()) {
+        groep.events.sort((a, b) => (a.createdAt < b.createdAt ? -1 : a.createdAt > b.createdAt ? 1 : 0));
+        const laatsteEvent = groep.events[groep.events.length - 1];
+        groep.aantal = groep.events.length;
+        groep.eerste = groep.events[0]?.createdAt ?? null;
+        groep.laatste = laatsteEvent?.createdAt ?? null;
+        const totaal = groep.events.reduce((som, e) => som + (e.durationMs ?? 0), 0);
+        groep.duurMs = totaal > 0 ? totaal : null;
+        groep.pogingen = groep.events.reduce((m, e) => Math.max(m, e.attempts ?? 0), 0);
+        groep.volgendeStap = laatsteEvent?.nextStep ?? null;
+        // De laatste registratie bepaalt de stand: een vakje dat eerst wachtte en
+        // daarna is afgerond, is afgerond. Een latere "wachtend" blijft wachtend.
+        const bepalend = laatsteEvent ?? groep.events[0];
+        groep.status = bepalend?.status ?? "geslaagd";
+        groep.reden = bepalend?.reason ?? bepalend?.error ?? bepalend?.decision ?? null;
+        groep.errorClass = bepalend?.errorClass ?? null;
+    }
+    return map;
+}
+/** De vakjes op volgorde van de eerste gebeurtenis: de reis van de order. */
+export function reisVolgorde(groepen) {
+    return [...groepen.values()].sort((a, b) => {
+        const ta = a.eerste ?? "";
+        const tb = b.eerste ?? "";
+        return ta < tb ? -1 : ta > tb ? 1 : 0;
+    });
+}
+/** Is dit een automatische database-regel (trigger) in plaats van een engine-beslissing? */
+export function isAutomatisch(e) {
+    return (e.phase ?? "").toLowerCase() === "database";
+}
+function calcVan(e) {
+    const c = e.calc;
+    if (!c || typeof c !== "object")
+        return null;
+    return c;
+}
+/** Korte samenvatting van wat de Engine in dit vakje besliste. */
+export function samenvatVak(groep) {
+    const events = Array.isArray(groep.events) ? groep.events : [];
+    const engine = events.filter((e) => !isAutomatisch(e));
+    const relevant = engine.length > 0 ? engine : events;
+    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 foutEvent = [...relevant].reverse().find((e) => e.status === "mislukt") ?? null;
+    return {
+        beslissing: laatsteMet((e) => e.decision),
+        reden: laatsteMet((e) => e.reason) ?? groep.reden,
+        regel: laatsteMet((e) => e.rule),
+        berekening: laatsteMet((e) => calcVan(e)),
+        volgendeStap: laatsteMet((e) => e.nextStep) ?? groep.volgendeStap,
+        fout: foutEvent?.error ?? null,
+        errorClass: foutEvent?.errorClass ?? groep.errorClass,
+        pogingen: groep.pogingen,
+        volgendePoging: laatsteMet((e) => e.nextAttemptAt),
+        aantalBeslissingen: engine.length,
+        aantalAutomatisch: events.length - engine.length,
+    };
+}
+/**
+ * Engine-gebeurtenissen blijven los; automatische database-regels worden
+ * per soort (stap + tabel + actie) samengevoegd tot één regel met telling.
+ * Nieuwste eerst.
+ */
+export function bundelGebeurtenissen(events) {
+    const veilig = Array.isArray(events) ? [...events] : [];
+    veilig.sort((a, b) => (a.createdAt < b.createdAt ? 1 : a.createdAt > b.createdAt ? -1 : 0));
+    const uit = [];
+    const index = new Map();
+    for (const e of veilig) {
+        if (!isAutomatisch(e)) {
+            uit.push({
+                key: e.id,
+                event: e,
+                events: [e],
+                aantal: 1,
+                laatste: e.createdAt,
+                label: e.step,
+            });
+            continue;
+        }
+        const key = `auto:${e.step}|${e.dbTable ?? ""}|${e.dbAction ?? ""}`;
+        const bestaand = index.get(key);
+        if (bestaand) {
+            bestaand.events.push(e);
+            bestaand.aantal += 1;
+            continue;
+        }
+        const bundel = {
+            key,
+            event: null,
+            events: [e],
+            aantal: 1,
+            laatste: e.createdAt,
+            label: e.step,
+        };
+        index.set(key, bundel);
+        uit.push(bundel);
+    }
+    return uit;
+}

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

@@ -0,0 +1,14 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+export interface PickQueueCleanupResult {
+    mode: string | null;
+    cartRows: number;
+    retiredOrderRows: number;
+    errors: string[];
+}
+/**
+ * Verbergt oude orderregels uit het actieve pickscherm zodra dezelfde
+ * pickeenheid concrete karregels heeft. De regel blijft als printhistorie
+ * bestaan; karrencontrole gebruikt de canonieke kargegevens en blijft intact.
+ */
+export declare function retireSupersededOrderRows(sb: SupabaseClient): Promise<PickQueueCleanupResult>;
+//# sourceMappingURL=pickQueueCleanup.server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pickQueueCleanup.server.d.ts","sourceRoot":"","sources":["../../src/lib/pickQueueCleanup.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAI5D,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,cAAc,GACjB,OAAO,CAAC,sBAAsB,CAAC,CAiFjC"}

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

@@ -0,0 +1,80 @@
+const REPLACED_REASON = "Vervangen door actuele karregels.";
+/**
+ * Verbergt oude orderregels uit het actieve pickscherm zodra dezelfde
+ * pickeenheid concrete karregels heeft. De regel blijft als printhistorie
+ * bestaan; karrencontrole gebruikt de canonieke kargegevens en blijft intact.
+ */
+export async function retireSupersededOrderRows(sb) {
+    const result = {
+        mode: null,
+        cartRows: 0,
+        retiredOrderRows: 0,
+        errors: [],
+    };
+    const { data: modeData, error: modeError } = await sb.rpc("logistics_pick_mode");
+    if (modeError) {
+        result.errors.push(modeError.message);
+        return result;
+    }
+    const modeValue = Array.isArray(modeData) ? modeData[0] : modeData;
+    const modeObject = modeValue && typeof modeValue === "object"
+        ? modeValue
+        : null;
+    result.mode = String(modeObject?.["pickMode"] ?? modeObject?.["mode"] ?? "");
+    if (result.mode !== "cart")
+        return result;
+    const { data: cartRows, error: cartRowsError } = await sb
+        .from("pick_queue")
+        .select("order_number")
+        .is("cancelled_at", null)
+        .not("payload->>cartRowFor", "is", null);
+    if (cartRowsError) {
+        result.errors.push(cartRowsError.message);
+        return result;
+    }
+    const safeCartRows = Array.isArray(cartRows) ? cartRows : [];
+    const orderNumbers = [...new Set(safeCartRows
+            .map((row) => row.order_number)
+            .filter((value) => typeof value === "string" && value.length > 0))];
+    result.cartRows = safeCartRows.length;
+    if (orderNumbers.length === 0)
+        return result;
+    const replacedAt = new Date().toISOString();
+    const { data: oldRows, error: oldRowsError } = await sb
+        .from("pick_queue")
+        .select("id, payload")
+        .in("order_number", orderNumbers)
+        .is("cancelled_at", null)
+        .is("payload->>cartRowFor", null);
+    if (oldRowsError) {
+        result.errors.push(oldRowsError.message);
+        return result;
+    }
+    const safeOldRows = Array.isArray(oldRows) ? oldRows : [];
+    for (const row of safeOldRows) {
+        const payload = row.payload && typeof row.payload === "object" && !Array.isArray(row.payload)
+            ? row.payload
+            : {};
+        const { error } = await sb
+            .from("pick_queue")
+            .update({
+            cancelled_at: replacedAt,
+            payload: {
+                ...payload,
+                cartPlanReady: true,
+                cartPlanReason: null,
+                supersededByCartRows: true,
+                supersededReason: REPLACED_REASON,
+                supersededAt: replacedAt,
+            },
+            updated_at: replacedAt,
+        })
+            .eq("id", row.id)
+            .is("cancelled_at", null);
+        if (error)
+            result.errors.push(error.message);
+        else
+            result.retiredOrderRows += 1;
+    }
+    return result;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"planQueue.server.d.ts","sourceRoot":"","sources":["../../src/lib/planQueue.server.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAI5D,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,2FAA2F;IAC3F,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAwBD,wFAAwF;AACxF,wBAAsB,YAAY,CAChC,EAAE,EAAE,cAAc,EAClB,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAO,GAC3D,OAAO,CAAC,eAAe,CAAC,CAsG1B;AA0CD,4EAA4E;AAE5E,wBAAsB,cAAc,CAAC,EAAE,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAEtE"}
+{"version":3,"file":"planQueue.server.d.ts","sourceRoot":"","sources":["../../src/lib/planQueue.server.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAQ5D,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,2FAA2F;IAC3F,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAwBD,wFAAwF;AACxF,wBAAsB,YAAY,CAChC,EAAE,EAAE,cAAc,EAClB,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAO,GAC3D,OAAO,CAAC,eAAe,CAAC,CAwQ1B;AAmDD,4EAA4E;AAE5E,wBAAsB,cAAc,CAAC,EAAE,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAEtE"}

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

@@ -9,6 +9,9 @@
 // ============================================================================
 import { replanBufferInternal, replanOrderInternal } from "./loadCarrierPlanning.server.js";
 import { attachIndelingToTasks } from "./loadCarrierTaskSync.server.js";
+import { trace, newTraceId, classifyError } from "./trace.server.js";
+import { FLOW_NODE } from "./flowNodes.js";
+import { completePlannerDiffRuns, skipPlannerDiffRuns } from "./plannerDiff.server.js";
 const EMPTY = {
     claimed: 0,
     planned: 0,
@@ -37,10 +40,55 @@ export async function runPlanQueue(sb, options = {}) {
     // Voorkomt dat dezelfde buffer binnen één ronde meerdere keren wordt gepland.
     const plannedBuffers = new Set();
     const touchedDates = new Set();
+    // Herkenbare ordernummers voor het logboek; nooit verzinnen bij ontbreken.
+    const orderNumbers = new Map();
+    {
+        const ids = Array.from(new Set(rows.map((r) => r.order_id).filter(Boolean)));
+        if (ids.length > 0) {
+            const { data: orderRows } = await sb
+                .from("orders")
+                .select("id, order_number, order_source")
+                .in("id", ids);
+            for (const o of Array.isArray(orderRows) ? orderRows : []) {
+                orderNumbers.set(String(o?.id), {
+                    number: o?.order_number ? String(o.order_number) : null,
+                    source: o?.order_source === "floriday" ? "floriday" : o?.order_source ? "eigen" : null,
+                });
+            }
+        }
+    }
     for (const row of rows) {
+        // Het trace-id is de wachtrijrij zelf: zo horen alle stappen van deze
+        // herberekening aantoonbaar bij één "versie" in het orderlogboek.
+        const traceId = row.id || newTraceId();
+        const gevonden = orderNumbers.get(row.order_id);
+        const basis = {
+            traceId,
+            orderRef: gevonden?.number ?? row.order_id,
+            orderSource: gevonden?.source ?? null,
+            phase: "karindeling",
+            actor: "logistiek-engine:planwachtrij",
+            attempts: Number(row.attempts ?? 0),
+            nodeId: FLOW_NODE.indeling,
+        };
         if (Date.now() > deadlineAt) {
             // Teruggeven aan de wachtrij; de volgende ronde pakt hem weer op.
-            await sb.rpc("logistics_plan_finish", { p_id: row.id, p_error: "deadline" });
+            // Doorschuiven is geen mislukking: geen extra poging, geen foutmelding.
+            await sb.rpc("logistics_plan_defer", { p_id: row.id });
+            await trace(sb, {
+                ...basis,
+                step: "Indelen uitgesteld",
+                status: "wachtend",
+                decision: "Order blijft wachten",
+                reason: "De ronde was te lang bezig; deze order gaat mee met de volgende ronde.",
+                errorClass: "regel",
+                nextStep: "Volgende planronde (elke minuut)",
+                calc: {
+                    setting: "Maximale duur van één planronde",
+                    values: { rondeEindigdeOm: new Date(deadlineAt).toISOString(), beoordeeldOm: new Date().toISOString() },
+                    conclusion: "De order is niet overgeslagen, maar doorgeschoven naar de eerstvolgende ronde.",
+                },
+            });
             continue;
         }
         try {
@@ -54,23 +102,74 @@ export async function runPlanQueue(sb, options = {}) {
             }
             const bufferId = group.find((g) => g.buffer_id)?.buffer_id ?? null;
             let blocked = false;
+            await trace(sb, {
+                ...basis,
+                nodeId: FLOW_NODE.ontvangst,
+                step: "Order opgepakt voor indeling",
+                status: "geslaagd",
+                decision: bufferId ? "Order hoort bij een buffer" : "Order wordt los ingedeeld",
+                reason: bufferId
+                    ? "De order zit in een buffer; alle orders van die buffer worden samen ingedeeld."
+                    : "Er is geen open buffer voor deze order, dus hij wordt zelfstandig ingedeeld.",
+                reads: { geraakteOrders: group.length, bufferId, planDatums: [...touchedDates] },
+                nextStep: "Karrenindeling berekenen",
+            });
+            const startMs = Date.now();
             if (bufferId) {
                 if (!plannedBuffers.has(bufferId)) {
                     plannedBuffers.add(bufferId);
                     const plan = await replanBufferInternal(sb, bufferId);
                     if (plan.skipped === "locked") {
                         result.skippedLocked++;
+                        await trace(sb, {
+                            ...basis,
+                            step: "Indeling overgeslagen",
+                            status: "overgeslagen",
+                            decision: "Indeling blijft zoals hij is",
+                            reason: "De karren van deze buffer zijn al geprint, gescand of gecontroleerd.",
+                            errorClass: "regel",
+                            durationMs: Date.now() - startMs,
+                            calc: {
+                                setting: "Wanneer mag een karrenindeling niet meer veranderen",
+                                conclusion: "Bevroren karren worden nooit opnieuw ingedeeld, ook niet bij een herberekening.",
+                            },
+                            nextStep: "Pickstations en documenten",
+                        });
                     }
                     else if (plan.skipped === "blocked") {
                         blocked = true;
                         result.blocked++;
                         if (result.errors.length < 5 && plan.blockedReason)
                             result.errors.push(plan.blockedReason);
+                        await trace(sb, {
+                            ...basis,
+                            step: "Indeling geblokkeerd",
+                            status: "mislukt",
+                            decision: "Order gaat niet verder",
+                            errorClass: classifyError(null, plan.blockedReason ?? null),
+                            durationMs: Date.now() - startMs,
+                            nextStep: "Gegevens aanvullen en opnieuw indelen",
+                            ...(plan.blockedReason ? { reason: plan.blockedReason, error: plan.blockedReason } : {}),
+                        });
                     }
                     else {
                         result.planned++;
                         result.cartsCreated += Number(plan.cartsCreated ?? 0);
                         await attachIndelingToTasks(sb, plan);
+                        await trace(sb, {
+                            ...basis,
+                            step: "Buffer ingedeeld op karren",
+                            status: "geslaagd",
+                            decision: "Karrenindeling gemaakt",
+                            durationMs: Date.now() - startMs,
+                            output: { bufferId, karrenAangemaakt: Number(plan.cartsCreated ?? 0) },
+                            calc: {
+                                setting: "Indelingsmethode van de actieve werkwijze",
+                                values: { buffer: bufferId, karren: Number(plan.cartsCreated ?? 0) },
+                                result: `${Number(plan.cartsCreated ?? 0)} kar(ren) voor deze buffer`,
+                            },
+                            nextStep: "Vrijgave en aanmeldmoment",
+                        });
                     }
                 }
             }
@@ -78,23 +177,63 @@ export async function runPlanQueue(sb, options = {}) {
                 const plan = await replanOrderInternal(sb, row.order_id);
                 if (plan?.skipped === "locked") {
                     result.skippedLocked++;
+                    await trace(sb, {
+                        ...basis,
+                        step: "Indeling overgeslagen",
+                        status: "overgeslagen",
+                        decision: "Indeling blijft zoals hij is",
+                        reason: "De karren van deze order zijn al geprint, gescand of gecontroleerd.",
+                        errorClass: "regel",
+                        durationMs: Date.now() - startMs,
+                        nextStep: "Pickstations en documenten",
+                    });
                 }
                 else if (plan?.skipped === "blocked") {
                     blocked = true;
                     result.blocked++;
                     if (result.errors.length < 5 && plan.blockedReason)
                         result.errors.push(plan.blockedReason);
+                    await trace(sb, {
+                        ...basis,
+                        step: "Indeling geblokkeerd",
+                        status: "mislukt",
+                        decision: "Order gaat niet verder",
+                        errorClass: classifyError(null, plan.blockedReason ?? null),
+                        durationMs: Date.now() - startMs,
+                        nextStep: "Gegevens aanvullen en opnieuw indelen",
+                        ...(plan.blockedReason ? { reason: plan.blockedReason, error: plan.blockedReason } : {}),
+                    });
                 }
                 else if (plan) {
                     result.planned++;
                     result.cartsCreated += Number(plan.cartsCreated ?? 0);
                     await attachIndelingToTasks(sb, plan);
+                    await trace(sb, {
+                        ...basis,
+                        step: "Order ingedeeld op karren",
+                        status: "geslaagd",
+                        decision: "Karrenindeling gemaakt",
+                        durationMs: Date.now() - startMs,
+                        output: { karrenAangemaakt: Number(plan.cartsCreated ?? 0) },
+                        calc: {
+                            setting: "Indelingsmethode van de actieve werkwijze",
+                            values: { karren: Number(plan.cartsCreated ?? 0) },
+                            result: `${Number(plan.cartsCreated ?? 0)} kar(ren) voor deze order`,
+                        },
+                        nextStep: "Vrijgave en aanmeldmoment",
+                    });
                 }
             }
             // De blokkade zet de wachtrijregel zelf al op 'geblokkeerd'; die mag niet
-            // alsnog als afgerond worden weggeschreven.
-            if (blocked)
+            // alsnog als afgerond worden weggeschreven. Een wachtende vergelijking
+            // krijgt geen "na"-stand en wordt daarom als overgeslagen afgesloten.
+            if (blocked) {
+                const skipWarnings = await skipPlannerDiffRuns(sb, [row.order_id, ...group.map((g) => g.order_id)].filter(Boolean), "Indeling geblokkeerd; geen nieuwe karindeling om mee te vergelijken.").catch((e) => [String(e)]);
+                for (const w of skipWarnings)
+                    if (result.errors.length < 10)
+                        result.errors.push(w);
                 continue;
+            }
             // Orders zonder taken krijgen een order.received-event, zodat de
             // taakdispatcher er taken van maakt.
             for (const g of group.length > 0 ? group : [{ order_id: row.order_id }]) {
@@ -102,6 +241,11 @@ export async function runPlanQueue(sb, options = {}) {
                     continue;
                 await sb.rpc("logistics_plan_ensure_event", { p_order_id: g.order_id });
             }
+            // Dry-run: vergelijking oud/nieuw wegschrijven (alleen als er een momentopname wacht).
+            const diffWarnings = await completePlannerDiffRuns(sb, [row.order_id, ...group.map((g) => g.order_id)].filter(Boolean)).catch((e) => [String(e)]);
+            for (const w of diffWarnings)
+                if (result.errors.length < 10)
+                    result.errors.push(w);
             await sb.rpc("logistics_plan_finish", { p_id: row.id, p_error: null });
         }
         catch (err) {
@@ -110,6 +254,15 @@ export async function runPlanQueue(sb, options = {}) {
             if (result.errors.length < 5)
                 result.errors.push(message);
             await sb.rpc("logistics_plan_finish", { p_id: row.id, p_error: message });
+            await trace(sb, {
+                ...basis,
+                step: "Indelen mislukt",
+                status: "mislukt",
+                decision: "Order gaat niet verder",
+                errorClass: classifyError(null, message),
+                error: message,
+                nextStep: "Automatisch opnieuw geprobeerd in de volgende planronde",
+            });
         }
     }
     if (result.planned > 0) {
@@ -135,6 +288,9 @@ async function runDayLevelSteps(sb, dates, result) {
         { fn: "logistics_prune_buffer_member_queue", args: {} },
         { fn: "logistics_apply_document_layouts", args: {} },
         { fn: "logistics_capacity_day_check", args: { p_from: from, p_to: to >= from ? to : from } },
+        // Legt per order vast waar hij in de flow staat (vrijgave, pickstation,
+        // picken, controle, afgehandeld). Alleen meekijkend.
+        { fn: "logistics_trace_progress", args: { p_limit: 200 } },
     ];
     for (const call of calls) {
         const { error } = await sb.rpc(call.fn, call.args);
@@ -153,6 +309,11 @@ async function syncPickQueue(sb, result) {
     if (pruneError && result.errors.length < 10) {
         result.errors.push(`logistics_prune_buffer_member_queue: ${pruneError.message}`);
     }
+    // Ook zonder nieuwe planning schuift de reis van bestaande orders door.
+    const { error: traceError } = await sb.rpc("logistics_trace_progress", { p_limit: 200 });
+    if (traceError && result.errors.length < 10) {
+        result.errors.push(`logistics_trace_progress: ${traceError.message}`);
+    }
 }
 /** Ruimt afgeronde wachtrijrijen op volgens de ingestelde bewaartermijn. */
 export async function prunePlanQueue(sb) {

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

@@ -0,0 +1,37 @@
+export interface SnapshotItem {
+    orderItemId: string | null;
+    crates: number | string | null;
+}
+export interface SnapshotCart {
+    cartId?: string;
+    cartNumber: number | null;
+    bufferId?: string | null;
+    orderId?: string | null;
+    items: SnapshotItem[];
+}
+export interface PlannerDiffResult {
+    identical: boolean;
+    cartsBefore: number;
+    cartsAfter: number;
+    differences: Array<{
+        cartNumber: number | null;
+        before: string | null;
+        after: string | null;
+    }>;
+}
+export declare function compareSnapshots(before: unknown, after: unknown): PlannerDiffResult;
+/** Overzicht: laatste vergelijking per buffer. 'wachtend' en 'overgeslagen' tellen niet als vergeleken of afwijkend. */
+export declare function summarizeDiffRuns<T extends {
+    buffer_id: string | null;
+    order_ref: string | null;
+    status: string;
+    identical: boolean | null;
+}>(rows: T[]): {
+    totaal: number;
+    identiek: number;
+    afwijkend: number;
+    mislukt: number;
+    overgeslagen: number;
+    afwijkingen: T[];
+};
+//# sourceMappingURL=plannerDiff.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plannerDiff.d.ts","sourceRoot":"","sources":["../../src/lib/plannerDiff.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;CAChC;AACD,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,KAAK,EAAE,YAAY,EAAE,CAAC;CACvB;AACD,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;CAChG;AAiBD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,iBAAiB,CAyBnF;AAED,wHAAwH;AACxH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS;IAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,GAAG,IAAI,CAAA;CAAE,EAC3I,IAAI,EAAE,CAAC,EAAE;;;;;;;EAsBV"}