@flowselections/logistiek-engine 1.0.53 → 1.0.90

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

@@ -12,124 +12,40 @@ import { buildDimensionItems, carrierDimensions } from "./dimensionData.server";
 // ---------------------------------------------------------------------------
 // Buffer
 // ---------------------------------------------------------------------------
-function normalizeBufferPart(value) {
-    if (value == null)
-        return "";
-    if (Array.isArray(value)) {
-        for (const entry of value) {
-            const normalized = normalizeBufferPart(entry);
-            if (normalized)
-                return normalized;
-        }
-        return "";
-    }
-    if (typeof value === "object") {
-        const o = value;
-        return normalizeBufferPart(o.gln ?? o.locationGln ?? o.warehouseId ?? o.id ?? o.name ?? o.location ?? o.address?.addressLine);
-    }
-    return String(value).trim().toLowerCase().replace(/\s+/g, " ");
-}
-function pickFirstString(...values) {
-    for (const value of values) {
-        const normalized = normalizeBufferPart(value);
-        if (normalized)
-            return normalized;
-    }
-    return "";
-}
-export function buildBufferKey(order, mode) {
-    const cf = (order.custom_fields ?? {});
-    const pickupDate = pickFirstString(cf.pickup_moment, cf.pickup_date, cf.pickup_datetime, order.delivery_date);
-    const location = pickFirstString(cf.delivery_location_gln, cf.destination_gln, cf.region_gln, cf.location_gln, cf.delivery_location_id, cf.delivery_location);
-    const customer = normalizeBufferPart(order.customer_id);
-    let key;
-    switch (mode) {
-        case "same_pickup":
-            key = `p|${pickupDate}`;
-            break;
-        case "same_location":
-            key = `l|${location}`;
-            break;
-        case "same_customer":
-            key = `c|${customer}|${pickupDate}`;
-            break;
-        case "never":
-            key = `order-${order.id}`;
-            break;
-        case "same_pickup_and_location":
-        default:
-            key = `pl|${pickupDate}|${location}`;
-    }
-    return { key, pickupDate, location };
-}
+// De bufferkeuze is uitsluitend van de database (logistics_apply_buffer_decision,
+// via trigger trg_orders_apply_buffer_decision). Deze code leest die keuze
+// alleen; ze berekent geen eigen sleutel en schrijft nooit orders.buffer_id.
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 export async function resolveBufferForOrderInternal(sb, orderId) {
-    const { data: order } = await sb
-        .from("orders")
-        .select("id, customer_id, delivery_date, custom_fields, buffer_id")
-        .eq("id", orderId)
-        .maybeSingle();
-    if (!order)
+    const readBuffer = async () => {
+        const { data } = await sb.from("orders").select("id, buffer_id").eq("id", orderId).maybeSingle();
+        if (!data)
+            return { found: false, bufferId: null };
+        return { found: true, bufferId: data.buffer_id ?? null };
+    };
+    const first = await readBuffer();
+    if (!first.found)
+        return null;
+    if (first.bufferId)
+        return first.bufferId;
+    // Nog geen buffer: laat de database één keer beslissen, en lees opnieuw.
+    const { error } = await sb.rpc("logistics_apply_buffer_decision", { p_order_id: orderId });
+    if (error) {
+        console.warn(`[buffer] bufferbesluit voor order ${orderId} mislukt: ${error.message}`);
         return null;
-    const { data: settings } = await sb
-        .from("cart_planning_settings")
-        .select("buffer_grouping_mode")
-        .eq("id", 1)
-        .maybeSingle();
-    const mode = settings?.buffer_grouping_mode ?? "same_pickup_and_location";
-    const cf = { ...(order.custom_fields ?? {}) };
-    const locId = cf.delivery_location_id;
-    if (typeof locId === "string" && UUID_RE.test(locId) && !cf.delivery_location_gln) {
-        const { data: loc } = await sb
-            .from("customer_delivery_locations")
-            .select("gln, name")
-            .eq("id", locId)
-            .maybeSingle();
-        if (loc?.gln)
-            cf.delivery_location_gln = loc.gln;
-        if (loc?.name)
-            cf.delivery_location_name = loc.name;
-    }
-    const { key, pickupDate, location } = buildBufferKey({ ...order, custom_fields: cf }, mode);
-    let bufferId = null;
-    const { data: existing } = await sb
-        .from("order_buffers")
-        .select("id")
-        .eq("buffer_key", key)
-        .maybeSingle();
-    if (existing?.id) {
-        bufferId = existing.id;
-    }
-    else {
-        const { data: inserted, error } = await sb
-            .from("order_buffers")
-            .insert({
-            buffer_key: key,
-            grouping_mode: mode,
-            pickup_date: pickupDate || null,
-            pickup_location: location || null,
-            customer_id: mode === "same_customer" ? order.customer_id : null,
-        })
-            .select("id")
-            .single();
-        if (error) {
-            // Race: iemand anders maakte dezelfde buffer aan.
-            const { data: retry } = await sb
-                .from("order_buffers")
-                .select("id")
-                .eq("buffer_key", key)
-                .maybeSingle();
-            bufferId = retry?.id ?? null;
-        }
-        else {
-            bufferId = inserted?.id ?? null;
-        }
     }
-    if (bufferId && order.buffer_id !== bufferId) {
-        await sb.from("orders").update({ buffer_id: bufferId }).eq("id", orderId);
+    const second = await readBuffer();
+    if (!second.bufferId) {
+        console.warn(`[buffer] order ${orderId} heeft geen buffer volgens de werkwijze (buffer uit of reservering uitgesloten); niet ingedeeld.`);
     }
-    return bufferId;
+    return second.bufferId;
 }
+/**
+ * Een belading die uit Floriday komt (per regel of, als noodgreep, order-breed) of
+ * die een mens bewust heeft vastgezet, is leidend: het aantal lagen per ladingdrager
+ * wordt dan exact gevolgd.
+ */
+const isAuthoritative = (s) => s === "handmatig" || s === "floriday_line" || s === "order_items" || s === "floriday_packing";
 const positive = (v) => {
     const n = Number(v);
     return Number.isFinite(n) && n > 0 ? Math.round(n) : null;
@@ -151,17 +67,58 @@ export function beladingFromFloridayPacking(packing) {
         return null;
     return { plants_per_crate: ppc, crates_per_layer: cpl, layers_per_cart: lpc };
 }
-/** Beladingbronnen in volgorde: Floriday-verpakking > orderregel > product > geen. */
-function resolveBelading(row, packing) {
-    if (packing)
-        return { belading: packing, source: "floriday_packing" };
-    const fromRow = positive(row.plants_per_crate) != null || positive(row.crates_per_layer) != null || positive(row.layers_per_cart) != null
-        ? {
-            plants_per_crate: positive(row.plants_per_crate) ?? 1,
-            crates_per_layer: positive(row.crates_per_layer) ?? 1,
-            layers_per_cart: positive(row.layers_per_cart) ?? 1,
-        }
-        : null;
+/**
+ * Leest per artikel de Floriday-verpakking van de orderregel zelf uit
+ * `orders.custom_fields.floriday_lines`. Dit is de enige bron die per regel klopt;
+ * `custom_fields.floriday_packing` geldt voor de hele order.
+ */
+export function beladingPerRegelUitOrder(customFields) {
+    const out = new Map();
+    const cf = (customFields ?? {});
+    const lines = Array.isArray(cf.floriday_lines) ? cf.floriday_lines : [];
+    for (const raw of lines) {
+        const line = (raw ?? {});
+        const tradeItemId = line.trade_item_id ? String(line.trade_item_id) : null;
+        if (!tradeItemId)
+            continue;
+        const belading = beladingFromFloridayPacking(line.packing);
+        if (belading)
+            out.set(tradeItemId, belading);
+    }
+    return out;
+}
+/** Waarden van de orderregel zelf, of null als de regel niets heeft. */
+function beladingVanRegel(row) {
+    if (positive(row.plants_per_crate) == null &&
+        positive(row.crates_per_layer) == null &&
+        positive(row.layers_per_cart) == null) {
+        return null;
+    }
+    return {
+        plants_per_crate: positive(row.plants_per_crate) ?? 1,
+        crates_per_layer: positive(row.crates_per_layer) ?? 1,
+        layers_per_cart: positive(row.layers_per_cart) ?? 1,
+    };
+}
+/**
+ * Beladingbronnen in vaste volgorde:
+ *   1. handmatig vastgezette regel (packing_locked_at);
+ *   2. de Floriday-verpakking van díe regel (op artikel gekoppeld);
+ *   3. de eigen waarden van de bestelregel;
+ *   4. het product;
+ *   5. de order-brede Floriday-verpakking — uitsluitend als allerlaatste noodgreep
+ *      voor een regel die van 1 t/m 4 niets heeft;
+ *   6. anders onbekend: er wordt niet gegokt, de indeling blokkeert.
+ */
+function resolveBelading(row, packing, linePacking = null) {
+    const fromRow = beladingVanRegel(row);
+    // 1. Handmatig vastgezet: niemand overschrijft dat, ook Floriday niet.
+    if (row.packing_locked_at && fromRow)
+        return { belading: fromRow, source: "handmatig" };
+    // 2. De Floriday-verpakking van deze regel.
+    if (linePacking)
+        return { belading: linePacking, source: "floriday_line" };
+    // 3. De eigen waarden van de bestelregel.
     if (fromRow)
         return { belading: fromRow, source: "order_items" };
     const p = row.products ?? null;
@@ -172,8 +129,13 @@ function resolveBelading(row, packing) {
             layers_per_cart: positive(p.layers_per_cart) ?? 1,
         }
         : null;
+    // 4. Het product.
     if (fromProduct)
         return { belading: fromProduct, source: "product" };
+    // 5. Allerlaatste noodgreep: de order-brede Floriday-verpakking.
+    if (packing)
+        return { belading: packing, source: "floriday_packing" };
+    // 6. Onbekend.
     return { belading: { plants_per_crate: 1, crates_per_layer: 1, layers_per_cart: 1 }, source: "geen" };
 }
 export async function expandOrderItemsForPlanner(sb, rows, options = {}) {
@@ -197,8 +159,15 @@ export async function expandOrderItemsForPlanner(sb, rows, options = {}) {
         groupSet = new Set((groups ?? []).map((g) => g.id));
     }
     for (const row of rows) {
-        const packing = row.order_id ? options.packingByOrder?.get(String(row.order_id)) ?? null : null;
-        const { belading: base, source } = resolveBelading(row, packing);
+        const orderKey = row.order_id ? String(row.order_id) : null;
+        const packing = orderKey ? options.packingByOrder?.get(orderKey) ?? null : null;
+        const lineMap = orderKey ? options.packingByOrderLine?.get(orderKey) ?? null : null;
+        const linePacking = lineMap
+            ? lineMap.get(String(row.product_id ?? "")) ??
+                lineMap.get(String(row.products?.floriday_trade_item_id ?? "")) ??
+                null
+            : null;
+        const { belading: base, source } = resolveBelading(row, packing, linePacking);
         const plants = Math.max(0, Number(row.quantity ?? 0));
         const groupNameKey = String(row.product_name ?? "")
             .replace(/^\[Groep\]\s*/i, "")
@@ -218,7 +187,7 @@ export async function expandOrderItemsForPlanner(sb, rows, options = {}) {
                 product_name: row.product_name ?? "Onbekend",
                 plants,
                 ...base,
-                packing_authoritative: source === "floriday_packing",
+                packing_authoritative: isAuthoritative(source),
                 weight_per_crate: row.products?.weight != null ? Number(row.products.weight) : null,
             });
             continue;
@@ -241,7 +210,7 @@ export async function expandOrderItemsForPlanner(sb, rows, options = {}) {
                 product_name: row.product_name ?? "Onbekend",
                 plants,
                 ...base,
-                packing_authoritative: source === "floriday_packing",
+                packing_authoritative: isAuthoritative(source),
                 weight_per_crate: null,
             });
             continue;
@@ -259,21 +228,36 @@ export async function expandOrderItemsForPlanner(sb, rows, options = {}) {
         }
         const resolved = memberList.map((m) => {
             const p = prodByTrade.get(String(m.trade_item_id));
-            // Een Floriday-verpakking geldt voor de hele orderregel, dus ook voor de leden.
-            if (packing)
-                return { m, p, belading: { ...base }, source: "floriday_packing" };
+            // Een handmatig vastgezette regel blijft leidend voor de hele groep.
+            if (source === "handmatig") {
+                return { m, p, belading: { ...base }, source };
+            }
+            // 1. De Floriday-verpakking van dít lid.
+            const eigenLijn = lineMap?.get(String(m.trade_item_id)) ?? (p ? lineMap?.get(String(p.id)) ?? null : null);
+            if (eigenLijn)
+                return { m, p, belading: { ...eigenLijn }, source: "floriday_line" };
+            // 2. Het artikel zelf. Nooit de belading van de groepsregel of van een ander lid.
             const known = p &&
                 (positive(p.plants_per_crate) != null ||
                     positive(p.crates_per_layer) != null ||
                     positive(p.layers_per_cart) != null);
-            const belading = known
-                ? {
-                    plants_per_crate: positive(p.plants_per_crate) ?? 1,
-                    crates_per_layer: positive(p.crates_per_layer) ?? 1,
-                    layers_per_cart: positive(p.layers_per_cart) ?? 1,
-                }
-                : { ...base };
-            return { m, p, belading, source: (known ? "product" : source) };
+            if (known) {
+                return {
+                    m,
+                    p,
+                    belading: {
+                        plants_per_crate: positive(p.plants_per_crate) ?? 1,
+                        crates_per_layer: positive(p.crates_per_layer) ?? 1,
+                        layers_per_cart: positive(p.layers_per_cart) ?? 1,
+                    },
+                    source: "product",
+                };
+            }
+            // 3. Allerlaatste noodgreep: de order-brede Floriday-verpakking van de order.
+            if (packing)
+                return { m, p, belading: { ...packing }, source: "floriday_packing" };
+            // 4. Onbekend: er wordt niet gegokt, de indeling blokkeert.
+            return { m, p, belading: { ...base }, source: "geen" };
         });
         const weightSum = resolved.reduce((s, r) => s + Number(r.m.quantity ?? 1), 0) || resolved.length;
         const shares = [];
@@ -302,7 +286,7 @@ export async function expandOrderItemsForPlanner(sb, rows, options = {}) {
                 product_name: `${row.product_name ?? "Groep"} — ${r.p?.product ?? r.m.trade_item_id}`,
                 plants: shares[idx],
                 ...r.belading,
-                packing_authoritative: r.source === "floriday_packing",
+                packing_authoritative: isAuthoritative(r.source),
                 weight_per_crate: r.p?.weight != null ? Number(r.p.weight) : null,
             });
         });
@@ -569,6 +553,53 @@ export function dimensionCartsToPlannedUnits(carts) {
 // ---------------------------------------------------------------------------
 /** Maximaal aantal ladingdragers dat één orderbuffer mag opleveren. */
 const MAX_CARTS_PER_BUFFER = 500;
+/** Statussen waarbij een order niet meer ingedeeld hoeft te worden. */
+const TERMINALE_STATUSSEN = new Set([
+    "verzonden",
+    "afgehandeld",
+    "geannuleerd",
+    "cancelled",
+    "geleverd",
+    "afgerond",
+]);
+/** Reservering of al afgehandelde order: niet plannen, ook niet blokkeren. */
+function isReservationOrTerminal(order) {
+    if (!order)
+        return true;
+    if (order.is_reservation === true)
+        return true;
+    const status = String(order.status ?? "").trim().toLowerCase();
+    return TERMINALE_STATUSSEN.has(status);
+}
+/**
+ * Duidelijk teveel identieke bestelregels wijst op een synchronisatie die
+ * regels toevoegt in plaats van bijwerkt. Dan niet rekenen: een indeling op
+ * opgeblazen aantallen is fout én loopt in een timeout.
+ */
+const DUPES_MIN_REGELS = 50;
+const DUPES_FACTOR = 3;
+function telDubbeleRegels(rows) {
+    const groepen = new Map();
+    const producten = new Set();
+    for (const r of rows) {
+        const product = String(r["product_id"] ?? r["product_name"] ?? "");
+        producten.add(product);
+        const sleutel = [
+            product,
+            r["quantity"] ?? 0,
+            r["plants_per_crate"] ?? 0,
+            r["crates_per_layer"] ?? 0,
+            r["layers_per_cart"] ?? 0,
+        ].join("|");
+        groepen.set(sleutel, (groepen.get(sleutel) ?? 0) + 1);
+    }
+    return {
+        regels: rows.length,
+        uniek: groepen.size,
+        kopieen: rows.length - groepen.size,
+        producten: producten.size,
+    };
+}
 /**
  * Bepaalt de definitieve, persistente identiteit van iedere fysieke kar.
  * Bij een bufferorder met meerdere orders zijn alle karren gedeelde
@@ -662,7 +693,62 @@ export async function bufferOrdersWithoutCarts(sb, bufferId, orderIds) {
     }
     return ids.filter((id) => !withCarts.has(id));
 }
+/**
+ * Auditpunt 2: één buffer wordt nooit door twee processen tegelijk herschreven.
+ *
+ * De lees-verwijder-herschrijf-cyclus hieronder loopt over veel losse aanroepen
+ * en past dus niet in één databasetransactie; een advisory xact lock zou meteen
+ * na de eerste aanroep weer vrijvallen. Daarom een kortlopende lease met
+ * vervaltijd (logistics_plan_lock_acquire), die wél geldt over de planwachtrij,
+ * de massa-herberekening en een openstaand scherm heen.
+ *
+ * Lukt de vergrendeling niet, dan volgt een nette "wordt al bijgewerkt"-uitkomst
+ * in plaats van een tweede, botsende herberekening.
+ */
 export async function replanBufferInternal(sb, bufferId, options = {}) {
+    // Een proefberekening schrijft niets weg en hoeft dus niets te vergrendelen.
+    if (options.dryRun)
+        return replanBufferUnlocked(sb, bufferId, options);
+    const lockKey = `buffer:${bufferId}`;
+    let held = false;
+    try {
+        const { data, error } = await sb.rpc("logistics_plan_lock_acquire", {
+            _key: lockKey,
+            _owner: "logistiek-engine",
+            _ttl_seconds: 600,
+        });
+        held = !error && data === true;
+    }
+    catch {
+        held = false;
+    }
+    if (!held) {
+        return {
+            ok: true,
+            bufferId,
+            orderIds: [],
+            cartsCreated: 0,
+            replacedManualCount: 0,
+            usedFloridayPacking: false,
+            warnings: [BUFFER_BUSY_MESSAGE],
+            skipped: "locked",
+        };
+    }
+    try {
+        return await replanBufferUnlocked(sb, bufferId, options);
+    }
+    finally {
+        try {
+            await sb.rpc("logistics_plan_lock_release", { _key: lockKey, _owner: "logistiek-engine" });
+        }
+        catch {
+            // Vrijgeven mag nooit de uitkomst omgooien; de lease verloopt vanzelf.
+        }
+    }
+}
+/** Herbruikbare melding als een buffer al door een ander proces wordt bijgewerkt. */
+export const BUFFER_BUSY_MESSAGE = "Deze orderbuffer wordt op dit moment al bijgewerkt; probeer het zo opnieuw.";
+async function replanBufferUnlocked(sb, bufferId, options = {}) {
     const warnings = [];
     // Bevroren karren blijven staan; al het overige van de héle buffer wordt
     // samen ingedeeld, zodat orders van de buffer op dezelfde karren komen.
@@ -670,11 +756,17 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
     const isSupplement = keepCartIds.length > 0;
     const { data: orders } = await sb
         .from("orders")
-        .select("id, order_number, customer_id, custom_fields, plan_locked_at")
+        .select("id, order_number, customer_id, custom_fields, plan_locked_at, status, is_reservation")
         .eq("buffer_id", bufferId)
         .is("deleted_at", null);
     const allOrderRows = Array.isArray(orders) ? orders : [];
-    const orderRows = allOrderRows;
+    // Reserveringen en al afgeronde orders horen niet in de indeling thuis. Ze
+    // leveren nooit karren op en zouden anders de hele buffer laten blokkeren.
+    const orderRows = allOrderRows.filter((o) => !isReservationOrTerminal(o));
+    const overgeslagen = allOrderRows.length - orderRows.length;
+    if (overgeslagen > 0) {
+        warnings.push(`${overgeslagen} order(s) in deze buffer zijn overgeslagen: reservering of al afgehandeld.`);
+    }
     const orderIds = orderRows.map((o) => o.id);
     // Binnen een bufferorder mogen orders en klanten altijd samen op een kar.
     const isBufferOrder = orderRows.length > 1;
@@ -777,22 +869,86 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
     const { data: items } = await sb
         .from("order_items")
         .select("id, order_id, product_id, product_name, quantity, plants_per_crate, crates_per_layer, layers_per_cart, " +
-        "products(plants_per_crate, crates_per_layer, layers_per_cart, weight)")
+        "packing_locked_at, packing_locked_by, " +
+        "products(plants_per_crate, crates_per_layer, layers_per_cart, weight, floriday_trade_item_id)")
         .in("order_id", idList);
+    // Duidelijk teveel identieke bestelregels: niet rekenen maar blokkeren.
+    // Een indeling op opgeblazen aantallen is fout en loopt in een timeout.
+    {
+        const perOrder = new Map();
+        for (const it of Array.isArray(items) ? items : []) {
+            const id = String(it.order_id ?? "");
+            const lijst = perOrder.get(id) ?? [];
+            lijst.push(it);
+            perOrder.set(id, lijst);
+        }
+        const verdacht = [];
+        for (const [id, rijen] of perOrder) {
+            const telling = telDubbeleRegels(rijen);
+            if (telling.regels >= DUPES_MIN_REGELS && telling.regels > telling.uniek * DUPES_FACTOR) {
+                const order = orderRows.find((o) => String(o.id) === id);
+                verdacht.push({ orderId: id, orderRef: String(order?.order_number ?? id), telling });
+            }
+        }
+        if (verdacht.length > 0) {
+            const reason = "Dubbele bestelregels gevonden: " +
+                verdacht
+                    .map((v) => `${v.orderRef} heeft ${v.telling.regels} bestelregels voor ${v.telling.producten} product(en) ` +
+                    `(${v.telling.kopieen} kopie(ën))`)
+                    .join("; ") +
+                ". Er is niets ingedeeld; de kopieën moeten eerst worden opgeruimd en de bron ervan hersteld.";
+            console.error(`[logistiek-engine] buffer ${bufferId} geblokkeerd: ${reason}`);
+            if (!options.dryRun) {
+                const { error: blockError } = await sb.rpc("logistics_plan_block", {
+                    p_order_ids: orderIds,
+                    p_reason: reason,
+                    p_details: {
+                        reason_code: "dubbele_regels",
+                        bufferId,
+                        path: "typescript",
+                        orders: verdacht.map((v) => ({ orderRef: v.orderRef, ...v.telling })),
+                    },
+                });
+                if (blockError)
+                    warnings.push(`Blokkade kon niet worden vastgelegd: ${blockError.message}`);
+            }
+            return {
+                ok: false,
+                bufferId,
+                orderIds,
+                cartsCreated: 0,
+                replacedManualCount: 0,
+                usedFloridayPacking: false,
+                warnings: [...warnings, reason],
+                skipped: "blocked",
+                blockedReason: reason,
+            };
+        }
+    }
     const customerByOrder = new Map(orderRows.map((o) => [o.id, o.customer_id ?? null]));
     const rawRows = (Array.isArray(items) ? items : []).map((it) => ({
         ...it,
         customer_id: customerByOrder.get(it.order_id) ?? null,
     }));
-    // Floriday-verpakking per order is de eerste beladingbron.
+    // Order-brede Floriday-verpakking: alleen nog als allerlaatste noodgreep.
     const packingByOrder = new Map();
+    // Floriday-verpakking per orderregel, gekoppeld op artikel. Dit is de bron die
+    // per regel klopt en gaat voor op de order-brede waarde.
+    const packingByOrderLine = new Map();
     for (const o of orderRows) {
         const belading = beladingFromFloridayPacking(o.custom_fields?.floriday_packing);
         if (belading)
             packingByOrder.set(String(o.id), belading);
+        const perRegel = beladingPerRegelUitOrder(o.custom_fields);
+        if (perRegel.size > 0)
+            packingByOrderLine.set(String(o.id), perRegel);
     }
     const sources = new Map();
-    let inputs = await expandOrderItemsForPlanner(sb, rawRows, { packingByOrder, sources });
+    let inputs = await expandOrderItemsForPlanner(sb, rawRows, {
+        packingByOrder,
+        packingByOrderLine,
+        sources,
+    });
     // Wat al op een bevroren kar ligt, wordt niet opnieuw ingedeeld.
     let frozenCartCount = 0;
     let cartNumberStart = 1;
@@ -922,8 +1078,17 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
     // daarom verwijderd.)
     const solo = orderRows.length === 1 ? orderRows[0] : null;
     const soloPacking = solo ? beladingFromFloridayPacking(solo.custom_fields?.floriday_packing) : null;
+    // Het overname-pad legt één verpakking over de hele order. Dat mag alleen als
+    // elke regel toch al exact die verpakking heeft; anders rekent de gewone
+    // planner, die per regel met de eigen belading werkt.
+    const uniformeBelading = inputs.length > 0 &&
+        soloPacking != null &&
+        inputs.every((i) => i.plants_per_crate === soloPacking.plants_per_crate &&
+            i.crates_per_layer === soloPacking.crates_per_layer &&
+            i.layers_per_cart === soloPacking.layers_per_cart);
     const takeoverProfile = profileFor(profiles, options.carrierType ?? defaultProfile.code);
-    const takeoverAllowed = takeoverProfile.capacity_model === "layered" || takeoverProfile.capacity_model === "stacked";
+    const takeoverAllowed = (takeoverProfile.capacity_model === "layered" || takeoverProfile.capacity_model === "stacked") &&
+        uniformeBelading;
     if (useDimensions) {
         // Globale methode: indelen op basis van fysieke afmetingen.
         const carrierRow = profiles.find((p) => p.code === (options.carrierType ?? defaultProfile.code)) ?? null;
@@ -1047,8 +1212,13 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
     }
     // Veiligheidsgrens: een onrealistisch grote uitkomst wordt niet afgekapt maar
     // geblokkeerd. Een half plan laat planten stilzwijgend uit de pickstroom vallen.
-    if (plannedCarts.length > MAX_CARTS_PER_BUFFER) {
-        const reason = `Deze orderbuffer levert ${plannedCarts.length} ladingdragers op, meer dan de grens van ` +
+    // Auditpunt 2: de grens telt cumulatief. Bij aanvullen na bevroren karren
+    // tellen die bevroren karren mee, zodat de grens niet in kleine stapjes
+    // omzeild kan worden.
+    const totalCartsAfterPlan = plannedCarts.length + frozenCartCount;
+    if (totalCartsAfterPlan > MAX_CARTS_PER_BUFFER) {
+        const reason = `Deze orderbuffer komt uit op ${totalCartsAfterPlan} ladingdragers ` +
+            `(${frozenCartCount} al vastgelegd + ${plannedCarts.length} nieuw), meer dan de grens van ` +
             `${MAX_CARTS_PER_BUFFER}. Er is niets ingedeeld; controleer de aantallen of de belading van de producten.`;
         console.error(`[logistiek-engine] buffer ${bufferId} geblokkeerd: ${reason}`);
         if (!options.dryRun) {
@@ -1059,7 +1229,9 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
                     reason_code: "kargrens_overschreden",
                     bufferId,
                     path: "typescript",
-                    carts: plannedCarts.length,
+                    carts: totalCartsAfterPlan,
+                    newCarts: plannedCarts.length,
+                    frozenCarts: frozenCartCount,
                     limit: MAX_CARTS_PER_BUFFER,
                     beladingSources,
                 },
@@ -1166,37 +1338,167 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
             await del().in("order_id", ids);
         }
     };
-    await clearExistingCarts();
-    // In blokken wegschrijven: per ladingdrager een aparte insert is bij grote
-    // orders veel te traag.
-    let created = 0;
-    const CHUNK = 100;
-    for (let start = 0; start < plannedCarts.length; start += CHUNK) {
-        const chunk = plannedCarts.slice(start, start + CHUNK);
-        const cartRows = chunk.map((cart, chunkIndex) => {
-            const cartIndex = start + chunkIndex;
-            const identity = persistentIdentities[cartIndex];
-            if (!identity) {
-                throw new Error(`Karrenindeling ongeldig: identiteit ontbreekt voor kar ${cartIndex + 1}.`);
+    // ---------------------------------------------------------------------------
+    // Vergelijken in plaats van wissen. Een kar die exact hetzelfde blijft, blijft
+    // staan: zelfde rij, zelfde id, zelfde barcode. Alleen echte verschillen worden
+    // geschreven. Dit voorkomt dat elke herberekening honderdduizenden karren en
+    // logboekregels produceert.
+    // ---------------------------------------------------------------------------
+    const getal = (v) => v === null || v === undefined || v === "" ? "" : Number.isFinite(Number(v)) ? Number(v).toFixed(3) : String(v);
+    const itemSig = (r) => [
+        String(r["order_item_id"] ?? ""),
+        String(r["product_id"] ?? ""),
+        getal(r["crates"]),
+        getal(r["boxes"]),
+        getal(r["weight_kg"]),
+        getal(r["plants_per_crate"]),
+        getal(r["crates_per_layer"]),
+        getal(r["layers_per_cart"]),
+        getal(r["layer_fraction"]),
+        getal(r["layer_share_pct"]),
+        getal(r["layer_index"]),
+        getal(r["crates_in_layer"]),
+    ].join("|");
+    const karSig = (row, items) => [
+        String(row["order_id"] ?? "gedeeld"),
+        getal(row["cart_number"]),
+        getal(row["total_carts"]),
+        String(row["carrier_type"] ?? ""),
+        String(row["carrier_type_id"] ?? ""),
+        getal(row["max_layers"]),
+        getal(row["total_layers_used"]),
+        getal(row["occupancy_pct"]),
+        getal(row["weight_kg"]),
+        String(row["layout_method"] ?? ""),
+        getal(row["algorithm_version"]),
+        String(row["is_complete"] ?? ""),
+        String(row["source"] ?? ""),
+    ].join("|") +
+        "#" +
+        items.map(itemSig).sort().join(";");
+    const gewenst = plannedCarts.map((cart, cartIndex) => {
+        const identity = persistentIdentities[cartIndex];
+        if (!identity) {
+            throw new Error(`Karrenindeling ongeldig: identiteit ontbreekt voor kar ${cartIndex + 1}.`);
+        }
+        const row = {
+            order_id: identity.ownerOrderId,
+            buffer_id: bufferId,
+            cart_number: identity.cartNumber,
+            total_carts: identity.totalCarts,
+            is_auto: true,
+            is_complete: cart.is_complete,
+            source: usedFloridayPacking ? "floriday" : "auto",
+            occupancy_pct: cart.occupancy_pct,
+            total_layers_used: cart.total_layers_used,
+            carrier_type: cart.carrier_type,
+            carrier_type_id: cart.carrier_type_id,
+            max_layers: cart.max_layers,
+            weight_kg: cart.weight_kg,
+            algorithm_version: useDimensions ? DIMENSION_PLANNER_VERSION : LOAD_CARRIER_PLANNER_VERSION,
+            layout_method: useDimensions ? "afmetingen" : "belading",
+        };
+        const items = cart.items.map((i) => ({
+            order_item_id: i.order_item_id.includes("::") ? i.order_item_id.split("::")[0] : i.order_item_id,
+            product_id: i.product_id,
+            product_name: i.product_name,
+            crates: Math.round(i.crates),
+            boxes: i.boxes ?? null,
+            weight_kg: i.weight_kg ?? null,
+            plants_per_crate: i.plants_per_crate,
+            crates_per_layer: i.crates_per_layer,
+            layers_per_cart: i.layers_per_cart,
+            layer_fraction: i.layer_fraction,
+            layer_share_pct: i.layer_share_pct,
+            layer_index: i.layer_index ?? null,
+            crates_in_layer: i.crates_in_layer ?? null,
+        }));
+        return { planIndex: cartIndex, row, items, sig: karSig(row, items) };
+    });
+    // Bestaande (niet-bevroren) karren binnen dezelfde scope inlezen.
+    const scopeOr = orderIds.length > 0
+        ? `buffer_id.eq.${bufferId},order_id.in.(${orderIds.join(",")})`
+        : `buffer_id.eq.${bufferId}`;
+    const { data: huidigeKarren, error: huidigeError } = await sb
+        .from("order_carts")
+        .select("id, order_id, buffer_id, cart_number, total_carts, is_complete, source, occupancy_pct, " +
+        "total_layers_used, carrier_type, carrier_type_id, max_layers, weight_kg, algorithm_version, layout_method")
+        .or(scopeOr);
+    if (huidigeError) {
+        throw new Error(`Bestaande karren konden niet worden vergeleken: ${huidigeError.message}`);
+    }
+    const bevroren = new Set(keepCartIds.map(String));
+    const vergelijkbaar = (Array.isArray(huidigeKarren) ? huidigeKarren : []).filter((c) => !bevroren.has(String(c.id)));
+    const huidigeIds = vergelijkbaar.map((c) => String(c.id));
+    const huidigeItems = new Map();
+    for (let s = 0; s < huidigeIds.length; s += 200) {
+        const slice = huidigeIds.slice(s, s + 200);
+        if (slice.length === 0)
+            continue;
+        const { data: rijen, error: itemsError } = await sb
+            .from("order_cart_items")
+            .select("cart_id, order_item_id, product_id, crates, boxes, weight_kg, plants_per_crate, " +
+            "crates_per_layer, layers_per_cart, layer_fraction, layer_share_pct, layer_index, crates_in_layer")
+            .in("cart_id", slice);
+        if (itemsError) {
+            throw new Error(`Inhoud van bestaande karren kon niet worden gelezen: ${itemsError.message}`);
+        }
+        for (const r of Array.isArray(rijen) ? rijen : []) {
+            const id = String(r.cart_id);
+            const lijst = huidigeItems.get(id) ?? [];
+            lijst.push(r);
+            huidigeItems.set(id, lijst);
+        }
+    }
+    const beschikbaarPerSig = new Map();
+    for (const c of vergelijkbaar) {
+        const id = String(c.id);
+        const sig = karSig(c, huidigeItems.get(id) ?? []);
+        const lijst = beschikbaarPerSig.get(sig) ?? [];
+        lijst.push(id);
+        beschikbaarPerSig.set(sig, lijst);
+    }
+    const behouden = new Map(); // planIndex -> bestaande cart id
+    const nieuw = [];
+    for (const g of gewenst) {
+        const kandidaten = beschikbaarPerSig.get(g.sig);
+        const hergebruik = kandidaten && kandidaten.length > 0 ? kandidaten.shift() : undefined;
+        if (hergebruik)
+            behouden.set(g.planIndex, hergebruik);
+        else
+            nieuw.push(g);
+    }
+    const teVerwijderen = [];
+    for (const lijst of beschikbaarPerSig.values())
+        teVerwijderen.push(...lijst);
+    if (teVerwijderen.length > 0) {
+        for (let s = 0; s < teVerwijderen.length; s += 200) {
+            const slice = teVerwijderen.slice(s, s + 200);
+            // Alleen voor karren die echt verdwijnen: openstaande printopdrachten en barcodes vervallen.
+            await sb
+                .from("print_jobs")
+                .update({ status: "geannuleerd", foutmelding: "Vervallen: kar verwijderd bij herindeling", updated_at: new Date().toISOString() })
+                .in("status", ["wachtend", "bezig"])
+                .in("payload->>cart_id", slice);
+            await sb.from("pakbon_barcode_inhoud").delete().in("cart_id", slice);
+            await sb.from("order_cart_layer_positions").delete().in("cart_id", slice);
+            const { error: delError } = await sb.from("order_carts").delete().in("id", slice);
+            if (delError) {
+                throw new Error(`Verouderde karren konden niet worden opgeruimd: ${delError.message}`);
             }
-            return {
-                order_id: identity.ownerOrderId,
-                buffer_id: bufferId,
-                cart_number: identity.cartNumber,
-                total_carts: identity.totalCarts,
-                is_auto: true,
-                is_complete: cart.is_complete,
-                source: usedFloridayPacking ? "floriday" : "auto",
-                occupancy_pct: cart.occupancy_pct,
-                total_layers_used: cart.total_layers_used,
-                carrier_type: cart.carrier_type,
-                carrier_type_id: cart.carrier_type_id,
-                max_layers: cart.max_layers,
-                weight_kg: cart.weight_kg,
-                algorithm_version: useDimensions ? DIMENSION_PLANNER_VERSION : LOAD_CARRIER_PLANNER_VERSION,
-                layout_method: useDimensions ? "afmetingen" : "belading",
-            };
-        });
+        }
+    }
+    let created = behouden.size;
+    const idByPlanIndex = new Map(behouden);
+    if (nieuw.length === 0) {
+        console.log(`[logistiek-engine] buffer ${bufferId}: indeling ongewijzigd, ${behouden.size} kar(ren) behouden, ` +
+            `${teVerwijderen.length} verouderde kar(ren) verwijderd.`);
+    }
+    // Alleen de echt nieuwe karren wegschrijven, in blokken.
+    const CHUNK = 40;
+    for (let start = 0; start < nieuw.length; start += CHUNK) {
+        const chunk = nieuw.slice(start, start + CHUNK);
+        const cartRows = chunk.map((g) => g.row);
         const { data: insertedCarts, error } = await sb
             .from("order_carts")
             .insert(cartRows)
@@ -1211,33 +1513,13 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
         const identityKey = (orderId, cartNumber) => `${orderId == null ? "shared" : String(orderId)}:${Number(cartNumber)}`;
         const idByIdentity = new Map(insertedCarts.map((c) => [identityKey(c.order_id, c.cart_number), String(c.id)]));
         const itemRows = [];
-        for (let chunkIndex = 0; chunkIndex < chunk.length; chunkIndex++) {
-            const cart = chunk[chunkIndex];
-            const identity = persistentIdentities[start + chunkIndex];
-            const cartId = identity
-                ? idByIdentity.get(identityKey(identity.ownerOrderId, identity.cartNumber))
-                : undefined;
+        for (const g of chunk) {
+            const cartId = idByIdentity.get(identityKey(g.row["order_id"], g.row["cart_number"]));
             if (!cartId)
                 continue;
-            for (const i of cart.items) {
-                itemRows.push({
-                    cart_id: cartId,
-                    // Samengestelde sleutels van groepsleden bestaan niet als orderregel.
-                    order_item_id: i.order_item_id.includes("::") ? i.order_item_id.split("::")[0] : i.order_item_id,
-                    product_id: i.product_id,
-                    product_name: i.product_name,
-                    crates: Math.round(i.crates),
-                    boxes: i.boxes ?? null,
-                    weight_kg: i.weight_kg ?? null,
-                    plants_per_crate: i.plants_per_crate,
-                    crates_per_layer: i.crates_per_layer,
-                    layers_per_cart: i.layers_per_cart,
-                    layer_fraction: i.layer_fraction,
-                    layer_share_pct: i.layer_share_pct,
-                    layer_index: i.layer_index ?? null,
-                    crates_in_layer: i.crates_in_layer ?? null,
-                });
-            }
+            idByPlanIndex.set(g.planIndex, cartId);
+            for (const i of g.items)
+                itemRows.push({ ...i, cart_id: cartId });
         }
         for (let s = 0; s < itemRows.length; s += 500) {
             const slice = itemRows.slice(s, s + 500);
@@ -1258,14 +1540,11 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
         // Fysieke laagindeling per kar. Alleen de afmetingenmethode levert posities;
         // bij belading blijft de indeling leeg ("nog geen laagindeling aangeleverd").
         if (dimensionPlan) {
-            for (let chunkIndex = 0; chunkIndex < chunk.length; chunkIndex++) {
-                const cart = chunk[chunkIndex];
-                const identity = persistentIdentities[start + chunkIndex];
-                const cartId = identity
-                    ? idByIdentity.get(identityKey(identity.ownerOrderId, identity.cartNumber))
-                    : undefined;
-                const dimCart = dimensionPlan.get(start + chunkIndex);
-                if (!cartId || !dimCart)
+            for (const g of chunk) {
+                const cartId = idByPlanIndex.get(g.planIndex);
+                const dimCart = dimensionPlan.get(g.planIndex);
+                const cart = plannedCarts[g.planIndex];
+                if (!cartId || !dimCart || !cart)
                     continue;
                 const rows = layerPositionRows(cartId, dimCart);
                 // Atomair vervangen: eerst de vorige indeling van deze kar weg.