@flowselections/logistiek-engine 1.0.26 → 1.0.28

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

@@ -7,6 +7,8 @@
 // ============================================================================
 import { planLoadUnits, LOAD_CARRIER_PLANNER_VERSION, } from "./loadCarrierPlanner";
 import { fallbackCarrierProfile } from "./loadCarrierTypes";
+import { planByDimensions, DIMENSION_PLANNER_VERSION } from "./dimensionPlanner";
+import { buildDimensionItems, carrierDimensions } from "./dimensionData.server";
 // ---------------------------------------------------------------------------
 // Buffer
 // ---------------------------------------------------------------------------
@@ -180,6 +182,16 @@ export async function expandOrderItemsForPlanner(sb, rows, options = {}) {
         .map((r) => r.product_id)
         .filter((id) => typeof id === "string" && UUID_RE.test(id));
     let groupSet = new Set();
+    // Groepsregels dragen niet altijd een product_id. Zonder koppeling wordt de
+    // groep op naam opgezocht, zodat de leden en hun afmetingen alsnog meetellen.
+    const groupByName = new Map();
+    {
+        const { data: allGroups } = await sb.from("product_groups").select("id, name");
+        for (const g of Array.isArray(allGroups) ? allGroups : []) {
+            if (g?.name)
+                groupByName.set(String(g.name).trim().toLowerCase(), String(g.id));
+        }
+    }
     if (groupIds.length > 0) {
         const { data: groups } = await sb.from("product_groups").select("id").in("id", groupIds);
         groupSet = new Set((groups ?? []).map((g) => g.id));
@@ -188,8 +200,14 @@ export async function expandOrderItemsForPlanner(sb, rows, options = {}) {
         const packing = row.order_id ? options.packingByOrder?.get(String(row.order_id)) ?? null : null;
         const { belading: base, source } = resolveBelading(row, packing);
         const plants = Math.max(0, Number(row.quantity ?? 0));
-        const isGroup = (row.product_id && groupSet.has(row.product_id)) ||
-            String(row.product_name ?? "").startsWith("[Groep]");
+        const groupNameKey = String(row.product_name ?? "")
+            .replace(/^\[Groep\]\s*/i, "")
+            .trim()
+            .toLowerCase();
+        const groupId = row.product_id && groupSet.has(row.product_id)
+            ? String(row.product_id)
+            : groupByName.get(groupNameKey) ?? null;
+        const isGroup = groupId != null || String(row.product_name ?? "").startsWith("[Groep]");
         if (!isGroup) {
             options.sources?.set(String(row.id), source);
             out.push({
@@ -205,11 +223,13 @@ export async function expandOrderItemsForPlanner(sb, rows, options = {}) {
             });
             continue;
         }
-        const { data: members } = await sb
-            .from("product_group_items")
-            .select("trade_item_id, quantity, sort_order")
-            .eq("product_group_id", row.product_id)
-            .order("sort_order", { ascending: true });
+        const { data: members } = groupId
+            ? await sb
+                .from("product_group_items")
+                .select("trade_item_id, quantity, sort_order")
+                .eq("product_group_id", groupId)
+                .order("sort_order", { ascending: true })
+            : { data: [] };
         const memberList = Array.isArray(members) ? members : [];
         if (memberList.length === 0) {
             options.sources?.set(String(row.id), source);
@@ -328,6 +348,7 @@ export async function loadBeladingRules(sb) {
         maxLayers: k.fill_layers_as_much_as_fits ? null : numOrNull(k.max_layers),
         maxBoxes: k.fill_boxes_as_much_as_fits ? null : numOrNull(k.max_boxes_per_pallet),
         optimalFill: k.optimal_fill !== false,
+        layoutMethod: k.cart_layout_method === "afmetingen" ? "afmetingen" : "belading",
     };
 }
 /** Past de grenzen uit de werkwijze toe op het capaciteitsprofiel van een ladingdrager. */
@@ -414,19 +435,246 @@ export function planByFloridayPacking(inputs, profile, packing) {
     return carts;
 }
 // ---------------------------------------------------------------------------
+// Indeling op afmetingen omzetten naar het bestaande opslagmodel
+// ---------------------------------------------------------------------------
+/** Herkomst van de laagindeling, zoals vastgelegd in order_cart_layer_positions. */
+export const LAYER_POSITION_SOURCE = "afmetingen-planken";
+/** cm -> mm; de weergavemodules rekenen in millimeters. */
+const mm = (cm) => Number((cm * 10).toFixed(1));
+/**
+ * Zet de laagindeling van één kar om naar rijen voor
+ * public.order_cart_layer_positions. (0,0) is linksboven van de laag,
+ * x loopt naar rechts, y naar beneden, alles in millimeters.
+ */
+export function layerPositionRows(cartId, cart) {
+    const rows = [];
+    for (const layer of cart.layers) {
+        for (const pos of layer.positions) {
+            const rawItemId = pos.order_item_id;
+            // Samengestelde sleutels van groepsleden bestaan niet als orderregel.
+            const orderItemId = rawItemId.includes("::") ? rawItemId.split("::")[0] : rawItemId;
+            const isUuid = /^[0-9a-f-]{36}$/i.test(orderItemId);
+            rows.push({
+                cart_id: cartId,
+                layer: layer.layer_index,
+                keg_id: pos.keg_id,
+                x: mm(pos.x),
+                y: mm(pos.y),
+                width: mm(pos.width),
+                height: mm(pos.height),
+                rotation: pos.rotation,
+                layer_width: mm(layer.layer_length_cm),
+                layer_height: mm(layer.layer_width_cm),
+                product_id: pos.product_id,
+                order_item_id: isUuid ? orderItemId : null,
+                label: pos.label,
+                source: LAYER_POSITION_SOURCE,
+                algorithm_version: DIMENSION_PLANNER_VERSION,
+            });
+        }
+    }
+    return rows;
+}
+function validateDimensionCart(cart) {
+    const itemCrates = cart.layers.reduce((sum, layer) => sum + layer.placements.reduce((layerSum, placement) => layerSum + placement.crates, 0), 0);
+    const positions = cart.layers.reduce((sum, layer) => sum + layer.positions.length, 0);
+    if (itemCrates !== positions) {
+        return `Kar ${cart.cart_number} bevat ${itemCrates} fusten, maar heeft ${positions} fysieke posities.`;
+    }
+    for (const layer of cart.layers) {
+        for (let index = 0; index < layer.positions.length; index++) {
+            const position = layer.positions[index];
+            if (position.x < 0 ||
+                position.y < 0 ||
+                position.x + position.width > layer.layer_length_cm + 1e-9 ||
+                position.y + position.height > layer.layer_width_cm + 1e-9) {
+                return `Fust ${position.keg_id} van kar ${cart.cart_number} valt buiten de bruikbare afmetingen.`;
+            }
+            for (let otherIndex = index + 1; otherIndex < layer.positions.length; otherIndex++) {
+                const other = layer.positions[otherIndex];
+                const overlaps = position.x < other.x + other.width - 1e-9 &&
+                    position.x + position.width > other.x + 1e-9 &&
+                    position.y < other.y + other.height - 1e-9 &&
+                    position.y + position.height > other.y + 1e-9;
+                if (overlaps) {
+                    return `Fusten ${position.keg_id} en ${other.keg_id} overlappen op kar ${cart.cart_number}, laag ${layer.layer_index}.`;
+                }
+            }
+        }
+    }
+    return null;
+}
+export function dimensionCartsToPlannedUnits(carts) {
+    return carts.map((cart) => {
+        const layerCount = cart.layers.length || 1;
+        const items = [];
+        for (const layer of cart.layers) {
+            const cratesInLayer = layer.placements.reduce((s, p) => s + p.crates, 0) || 1;
+            for (const p of layer.placements) {
+                const fraction = p.crates / cratesInLayer;
+                items.push({
+                    order_item_id: p.order_item_id,
+                    order_id: p.order_id,
+                    product_id: p.product_id,
+                    product_name: p.product_name,
+                    crates: p.crates,
+                    plants: p.plants,
+                    boxes: p.crates,
+                    weight_kg: p.weight_kg,
+                    plants_per_crate: p.plants_per_crate,
+                    crates_per_layer: cratesInLayer,
+                    layers_per_cart: layerCount,
+                    layer_fraction: Number(fraction.toFixed(3)),
+                    layer_share_pct: Number(((100 * fraction) / layerCount).toFixed(2)),
+                    layer_index: layer.layer_index,
+                    crates_in_layer: p.crates,
+                });
+            }
+        }
+        return {
+            cart_number: cart.cart_number,
+            carrier_type: cart.carrier_code,
+            carrier_type_id: cart.carrier_id,
+            source: "auto",
+            is_complete: cart.is_complete,
+            occupancy_pct: cart.occupancy_pct,
+            total_layers_used: layerCount,
+            max_layers: layerCount,
+            weight_kg: cart.weight_kg,
+            items,
+        };
+    });
+}
+// ---------------------------------------------------------------------------
 // Herplannen van een buffer
 // ---------------------------------------------------------------------------
 /** Maximaal aantal ladingdragers dat één orderbuffer mag opleveren. */
 const MAX_CARTS_PER_BUFFER = 500;
+/**
+ * Bepaalt de definitieve, persistente identiteit van iedere fysieke kar.
+ * Bij een bufferorder met meerdere orders zijn alle karren gedeelde
+ * bufferkarren: geen eigen order, doorlopend genummerd binnen de buffer.
+ * Bij één order per buffer krijgt die order exact 1..N.
+ */
+export function assignPersistentCartIdentities(carts, itemToOrder, identityOptions = {}) {
+    if (identityOptions.shared) {
+        const start = Math.max(1, identityOptions.startNumber ?? 1);
+        const total = (identityOptions.existingCount ?? 0) + carts.length;
+        return carts.map((_, index) => ({
+            ownerOrderId: null,
+            cartNumber: start + index,
+            totalCarts: total,
+        }));
+    }
+    const owners = carts.map((cart) => {
+        const orderIds = new Set();
+        for (const item of cart.items) {
+            const orderId = item.order_id ?? itemToOrder.get(item.order_item_id);
+            if (orderId)
+                orderIds.add(orderId);
+        }
+        return orderIds.size === 1 ? [...orderIds][0] : null;
+    });
+    const totals = new Map();
+    for (const owner of owners) {
+        if (owner)
+            totals.set(owner, (totals.get(owner) ?? 0) + 1);
+    }
+    const sequences = new Map();
+    let sharedSequence = 0;
+    return owners.map((ownerOrderId) => {
+        if (!ownerOrderId) {
+            sharedSequence += 1;
+            return { ownerOrderId: null, cartNumber: -sharedSequence, totalCarts: null };
+        }
+        const cartNumber = (sequences.get(ownerOrderId) ?? 0) + 1;
+        sequences.set(ownerOrderId, cartNumber);
+        return { ownerOrderId, cartNumber, totalCarts: totals.get(ownerOrderId) ?? null };
+    });
+}
+function assertPersistentCartIdentities(identities, orderIds) {
+    for (const orderId of orderIds) {
+        const own = identities.filter((identity) => identity.ownerOrderId === orderId);
+        if (own.length === 0)
+            continue;
+        const numbers = own.map((identity) => identity.cartNumber).sort((a, b) => a - b);
+        const valid = numbers.every((number, index) => number === index + 1) &&
+            own.every((identity) => identity.totalCarts === own.length);
+        if (!valid) {
+            throw new Error(`Karrenindeling ongeldig voor order ${orderId}: verwacht vaste karnummers 1 t/m ${own.length}.`);
+        }
+    }
+}
+/**
+ * Leden van een buffer die nog helemaal geen fysieke kar hebben: geen eigen kar
+ * (order_carts.order_id) én geen gedeelde bufferkar waar een van hun orderregels
+ * op ligt. Zonder kar krijgt zo'n order ook geen pickdocument, dus dit mag nooit
+ * blijven staan.
+ */
+export async function bufferOrdersWithoutCarts(sb, bufferId, orderIds) {
+    const ids = orderIds.map(String).filter(Boolean);
+    if (ids.length === 0)
+        return [];
+    const { data: carts, error: cartsError } = await sb
+        .from("order_carts")
+        .select("id, order_id")
+        .or(`buffer_id.eq.${bufferId},order_id.in.(${ids.join(",")})`);
+    if (cartsError) {
+        throw new Error(`Karren van de buffer konden niet worden gelezen: ${cartsError.message}`);
+    }
+    const cartRows = Array.isArray(carts) ? carts : [];
+    const withCarts = new Set(cartRows.map((c) => (c.order_id ? String(c.order_id) : "")).filter(Boolean));
+    // Gedeelde karren (zonder eigen order) tellen mee voor elk lid waarvan er een
+    // orderregel op ligt.
+    const sharedIds = cartRows.filter((c) => !c.order_id).map((c) => String(c.id));
+    if (sharedIds.length > 0) {
+        const { data: items, error: itemsError } = await sb
+            .from("order_cart_items")
+            .select("order_item_id, order_items(order_id)")
+            .in("cart_id", sharedIds);
+        if (itemsError) {
+            throw new Error(`Inhoud van gedeelde karren kon niet worden gelezen: ${itemsError.message}`);
+        }
+        for (const row of Array.isArray(items) ? items : []) {
+            const orderId = row?.order_items?.order_id;
+            if (orderId)
+                withCarts.add(String(orderId));
+        }
+    }
+    return ids.filter((id) => !withCarts.has(id));
+}
 export async function replanBufferInternal(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.
+    const keepCartIds = (options.keepCartIds ?? []).map(String).filter(Boolean);
+    const isSupplement = keepCartIds.length > 0;
     const { data: orders } = await sb
         .from("orders")
-        .select("id, customer_id, custom_fields, plan_locked_at")
+        .select("id, order_number, customer_id, custom_fields, plan_locked_at")
         .eq("buffer_id", bufferId)
         .is("deleted_at", null);
-    const orderRows = Array.isArray(orders) ? orders : [];
+    const allOrderRows = Array.isArray(orders) ? orders : [];
+    const orderRows = allOrderRows;
     const orderIds = orderRows.map((o) => o.id);
+    // Binnen een bufferorder mogen orders en klanten altijd samen op een kar.
+    const isBufferOrder = orderRows.length > 1;
+    const orderRefs = orderRows.map((o) => String(o.order_number ?? "")).filter(Boolean);
+    const { data: releasedTasks } = orderRefs.length > 0
+        ? await sb
+            .from("logistics_tasks")
+            .select("order_ref")
+            .eq("task_type", "pick.execute")
+            .eq("shadow", false)
+            .not("status", "in", "(done,cancelled,superseded,skipped)")
+            .lte("planned_start", new Date().toISOString())
+            .in("order_ref", orderRefs)
+        : { data: [] };
+    // Alleen een expliciet slot op de order blokkeert een herplanning hard.
+    // Vrijgave alleen is niet genoeg: zolang er nog niets is geprint, gescand of
+    // gecontroleerd mag een gewijzigde belading nog doorwerken. De bevriezing van
+    // karidentiteiten hieronder bewaakt de fysieke werkelijkheid.
+    void releasedTasks;
     if (orderRows.some((o) => o.plan_locked_at)) {
         return {
             ok: true,
@@ -439,6 +687,66 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
             skipped: "locked",
         };
     }
+    // Een eenmaal geprinte, gescande of gecontroleerde fysieke kar heeft een
+    // blijvende identiteit. Ook vóór de formele vrijgavetijd mag een replan die
+    // id, het nummer of total_carts daarom niet meer vervangen.
+    if (!isSupplement) {
+        const { data: existingCartRows, error: existingCartError } = await sb
+            .from("order_carts")
+            .select("id, order_id, cart_number, total_carts")
+            .or(`buffer_id.eq.${bufferId},order_id.in.(${orderIds.join(",")})`);
+        if (existingCartError) {
+            throw new Error(`Bestaande karidentiteiten konden niet worden gecontroleerd: ${existingCartError.message}`);
+        }
+        const existingCartIds = (Array.isArray(existingCartRows) ? existingCartRows : [])
+            .map((cart) => String(cart.id ?? ""))
+            .filter(Boolean);
+        if (existingCartIds.length > 0) {
+            const [controlResult, barcodeResult, printResult] = await Promise.all([
+                sb.from("cart_control_items").select("cart_number_id").in("cart_number_id", existingCartIds),
+                sb.from("pakbon_barcode_inhoud").select("cart_id").in("cart_id", existingCartIds),
+                sb.from("print_jobs").select("id, payload").in("payload->>cart_id", existingCartIds),
+            ]);
+            const lockCheckError = controlResult.error ?? barcodeResult.error ?? printResult.error;
+            if (lockCheckError) {
+                throw new Error(`Karvergrendeling kon niet veilig worden gecontroleerd: ${lockCheckError.message}`);
+            }
+            const frozen = new Set();
+            for (const r of controlResult.data ?? []) {
+                const id = r?.cart_number_id;
+                if (id)
+                    frozen.add(String(id));
+            }
+            for (const r of barcodeResult.data ?? []) {
+                const id = r?.cart_id;
+                if (id)
+                    frozen.add(String(id));
+            }
+            for (const r of printResult.data ?? []) {
+                const id = r?.payload?.cart_id;
+                if (id)
+                    frozen.add(String(id));
+            }
+            const frozenIds = existingCartIds.filter((id) => frozen.has(id));
+            if (frozenIds.length > 0) {
+                // Geprinte, gescande of gecontroleerde karren blijven exact zoals ze zijn.
+                // Al het overige van de buffer wordt in één ronde samen ingedeeld, zodat
+                // de resterende fusten van alle orders op dezelfde karren komen.
+                const supplement = await replanBufferInternal(sb, bufferId, {
+                    ...options,
+                    keepCartIds: frozenIds,
+                });
+                return {
+                    ...supplement,
+                    warnings: [
+                        ...(supplement.warnings ?? []),
+                        `${frozenIds.length} reeds geprinte of gecontroleerde kar(ren) zijn ongewijzigd gebleven; ` +
+                            "de overige fusten van de buffer zijn samen opnieuw ingedeeld.",
+                    ],
+                };
+            }
+        }
+    }
     const idList = orderIds.length > 0 ? orderIds : ["00000000-0000-0000-0000-000000000000"];
     const { data: items } = await sb
         .from("order_items")
@@ -458,7 +766,63 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
             packingByOrder.set(String(o.id), belading);
     }
     const sources = new Map();
-    const inputs = await expandOrderItemsForPlanner(sb, rawRows, { packingByOrder, sources });
+    let inputs = await expandOrderItemsForPlanner(sb, rawRows, { packingByOrder, sources });
+    // Wat al op een bevroren kar ligt, wordt niet opnieuw ingedeeld.
+    let frozenCartCount = 0;
+    let cartNumberStart = 1;
+    if (isSupplement) {
+        const { data: keptCarts, error: keptError } = await sb
+            .from("order_carts")
+            .select("id, cart_number")
+            .in("id", keepCartIds);
+        if (keptError) {
+            throw new Error(`Bevroren karren konden niet worden gelezen: ${keptError.message}`);
+        }
+        const keptRows = Array.isArray(keptCarts) ? keptCarts : [];
+        frozenCartCount = keptRows.length;
+        cartNumberStart =
+            keptRows.reduce((max, c) => Math.max(max, Number(c.cart_number) || 0), 0) + 1;
+        const { data: frozenItems, error: frozenItemsError } = await sb
+            .from("order_cart_items")
+            .select("order_item_id, product_id, crates, plants_per_crate")
+            .in("cart_id", keepCartIds);
+        if (frozenItemsError) {
+            throw new Error(`Inhoud van bevroren karren kon niet worden gelezen: ${frozenItemsError.message}`);
+        }
+        const doneKey = (itemId, productId) => `${String(itemId ?? "")}|${String(productId ?? "")}`;
+        const done = new Map();
+        for (const r of Array.isArray(frozenItems) ? frozenItems : []) {
+            const plants = Math.max(0, Math.round(Number(r.crates ?? 0))) *
+                Math.max(1, Math.round(Number(r.plants_per_crate ?? 1)));
+            const key = doneKey(r.order_item_id, r.product_id);
+            done.set(key, (done.get(key) ?? 0) + plants);
+        }
+        for (const i of inputs) {
+            const baseId = i.order_item_id.includes("::") ? i.order_item_id.split("::")[0] : i.order_item_id;
+            const key = doneKey(baseId, i.product_id);
+            const already = done.get(key) ?? 0;
+            if (already <= 0)
+                continue;
+            const used = Math.min(already, i.plants);
+            i.plants -= used;
+            done.set(key, already - used);
+        }
+        inputs = inputs.filter((i) => i.plants > 0);
+        if (inputs.length === 0) {
+            return {
+                ok: true,
+                bufferId,
+                orderIds,
+                cartsCreated: 0,
+                replacedManualCount: 0,
+                usedFloridayPacking: false,
+                warnings: [
+                    "Alle fusten van deze buffer liggen al op geprinte of gecontroleerde karren; niets opnieuw ingedeeld.",
+                ],
+                skipped: "locked",
+            };
+        }
+    }
     const itemToOrder = new Map();
     for (const i of inputs)
         if (i.order_id)
@@ -487,7 +851,8 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
     const guardProfile = profileFor(profiles, options.carrierType ?? defaultProfile.code);
     const needsBelading = guardProfile.capacity_model !== "single" && guardProfile.capacity_model !== "none";
     const unknownItems = inputs.filter((i) => sources.get(i.order_item_id) === "geen" && i.plants > 0);
-    if (needsBelading && unknownItems.length > 0 && !options.dryRun) {
+    const useDimensions = rules?.layoutMethod === "afmetingen";
+    if (!useDimensions && needsBelading && unknownItems.length > 0 && !options.dryRun) {
         const reason = `Belading onbekend voor ${unknownItems.length} orderregel(s): geen Floriday-verpakking, ` +
             `geen waarden op de orderregel en geen productinstelling. Er is niets ingedeeld.`;
         console.error(`[logistiek-engine] buffer ${bufferId} geblokkeerd: ${reason}`);
@@ -518,6 +883,9 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
         };
     }
     let plannedCarts = [];
+    // Laagindeling van de afmetingenmethode, per cart_number. Alleen gevuld als
+    // er daadwerkelijk op afmetingen is ingedeeld.
+    let dimensionPlan = null;
     let usedFloridayPacking = false;
     // Overname-pad: één order in de buffer én een volledige Floriday-verpakking.
     // Dan neemt de engine de verhouding van Floriday over en optimaliseert niet.
@@ -528,7 +896,86 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
     const soloPacking = solo ? beladingFromFloridayPacking(solo.custom_fields?.floriday_packing) : null;
     const takeoverProfile = profileFor(profiles, options.carrierType ?? defaultProfile.code);
     const takeoverAllowed = takeoverProfile.capacity_model === "layered" || takeoverProfile.capacity_model === "stacked";
-    if (solo && soloPacking && takeoverAllowed) {
+    if (useDimensions) {
+        // Globale methode: indelen op basis van fysieke afmetingen.
+        const carrierRow = profiles.find((p) => p.code === (options.carrierType ?? defaultProfile.code)) ?? null;
+        const { carrier, missing: carrierMissing } = carrierDimensions(carrierRow);
+        const { items: dimItems, missing: itemMissing, derived: derivedHeights, } = await buildDimensionItems(sb, inputs, carrier, carrierRow?.layers_per_carrier ?? null);
+        warnings.push(...derivedHeights);
+        const missing = [...carrierMissing, ...itemMissing];
+        let planError = null;
+        if (missing.length === 0 && carrier) {
+            const result = planByDimensions(dimItems, carrier);
+            if (result.error)
+                planError = result.error;
+            else {
+                const invalidCart = result.carts.map(validateDimensionCart).find((message) => message != null) ?? null;
+                if (invalidCart)
+                    planError = invalidCart;
+                else {
+                    plannedCarts = dimensionCartsToPlannedUnits(result.carts);
+                    dimensionPlan = new Map(result.carts.map((c) => [c.cart_number, c]));
+                    warnings.push(...result.warnings);
+                }
+            }
+        }
+        if (missing.length > 0 || planError) {
+            const reason = planError ?? `Afmetingen onbekend: ${missing.map((m) => m.message).join(" ")}`;
+            if (options.dryRun) {
+                return {
+                    ok: false,
+                    bufferId,
+                    orderIds,
+                    cartsCreated: 0,
+                    replacedManualCount: 0,
+                    usedFloridayPacking: false,
+                    warnings: [...warnings, reason],
+                    skipped: "blocked",
+                    blockedReason: reason,
+                    beladingSources,
+                };
+            }
+            console.error(`[logistiek-engine] buffer ${bufferId} geblokkeerd (afmetingen): ${reason}`);
+            const { error: blockError } = await sb.rpc("logistics_plan_block", {
+                p_order_ids: orderIds,
+                p_reason: reason,
+                p_details: {
+                    bufferId,
+                    path: "afmetingen",
+                    carrier: carrierRow?.code ?? null,
+                    missing: missing.slice(0, 20),
+                },
+            });
+            if (blockError)
+                warnings.push(`Blokkade kon niet worden vastgelegd: ${blockError.message}`);
+            // Karren die met een andere (oudere) werkwijze zijn gemaakt mogen niet
+            // blijven staan: dan lijkt er een geldige indeling te zijn terwijl de
+            // afmetingen ontbreken. Karren van de afmetingenmethode blijven staan.
+            // Bij aanvullen blijven bestaande (bevroren) karren altijd staan.
+            if (!isSupplement) {
+                const { error: staleError } = await sb
+                    .from("order_carts")
+                    .delete()
+                    .eq("buffer_id", bufferId)
+                    .or("layout_method.is.null,layout_method.neq.afmetingen");
+                if (staleError)
+                    warnings.push(`Oude karrenindeling kon niet worden opgeruimd: ${staleError.message}`);
+            }
+            return {
+                ok: false,
+                bufferId,
+                orderIds,
+                cartsCreated: 0,
+                replacedManualCount: 0,
+                usedFloridayPacking: false,
+                warnings: [...warnings, reason],
+                skipped: "blocked",
+                blockedReason: reason,
+                beladingSources,
+            };
+        }
+    }
+    else if (solo && soloPacking && takeoverAllowed) {
         usedFloridayPacking = true;
         plannedCarts = planByFloridayPacking(inputs, takeoverProfile, soloPacking);
         console.log(`[logistiek-engine] buffer ${bufferId}: overname Floriday-verpakking ` +
@@ -553,8 +1000,10 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
                 // Zonder optimale vulling wordt er niet bijgemengd in een laag.
                 maxBeladingenPerLayer: rules && !rules.optimalFill ? 1 : (settings?.max_beladingen_per_layer ?? 2),
                 neverMixProductIds: neverMix,
-                maxOrders: rules?.maxOrders ?? null,
-                maxCustomers: rules?.maxCustomers ?? settings?.max_customers_per_cart ?? null,
+                // Binnen een bufferorder mag alles samen op een kar: de grenzen voor
+                // aantal orders en klanten gelden dan niet.
+                maxOrders: isBufferOrder ? null : rules?.maxOrders ?? null,
+                maxCustomers: isBufferOrder ? null : rules?.maxCustomers ?? settings?.max_customers_per_cart ?? null,
                 oneCustomerPerLayer: Boolean(settings?.max_one_customer_per_layer),
                 ownCarrierFromLayers: settings?.own_cart_from_layers ?? null,
                 sortOrder: "none",
@@ -612,24 +1061,93 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
             carts: plannedCarts,
         };
     }
-    await sb.from("order_carts").delete().eq("buffer_id", bufferId);
+    const persistentIdentities = assignPersistentCartIdentities(plannedCarts, itemToOrder, {
+        shared: isBufferOrder || isSupplement,
+        startNumber: cartNumberStart,
+        existingCount: frozenCartCount,
+    });
+    assertPersistentCartIdentities(persistentIdentities, orderIds);
+    // Houd de fysieke afmetingenindeling aan dezelfde definitieve karidentiteit.
+    const dimensionCartsByPlanIndex = dimensionPlan
+        ? plannedCarts.map((cart) => dimensionPlan?.get(cart.cart_number) ?? null)
+        : null;
+    if (dimensionPlan) {
+        const normalizedDimensionPlan = new Map();
+        plannedCarts.forEach((cart, index) => {
+            const dimensionCart = dimensionCartsByPlanIndex?.[index] ?? null;
+            const identity = persistentIdentities[index];
+            if (!dimensionCart || !identity)
+                return;
+            cart.cart_number = identity.cartNumber;
+            dimensionCart.cart_number = identity.cartNumber;
+            normalizedDimensionPlan.set(index, dimensionCart);
+        });
+        dimensionPlan = normalizedDimensionPlan;
+    }
+    else {
+        plannedCarts.forEach((cart, index) => {
+            const identity = persistentIdentities[index];
+            if (identity)
+                cart.cart_number = identity.cartNumber;
+        });
+    }
+    if (plannedCarts.length === 0 && orderIds.length > 0) {
+        const reason = `Karrenindeling ongeldig voor order(s) ${orderRefs.join(", ")}: ` +
+            "een vrij te geven order moet minimaal één fysieke kar hebben.";
+        const { error: blockError } = await sb.rpc("logistics_plan_block", {
+            p_order_ids: orderIds,
+            p_reason: reason,
+            p_details: { bufferId, path: useDimensions ? "afmetingen" : "belading", carts: 0 },
+        });
+        if (blockError)
+            warnings.push(`Blokkade kon niet worden vastgelegd: ${blockError.message}`);
+        return {
+            ok: false,
+            bufferId,
+            orderIds,
+            cartsCreated: 0,
+            replacedManualCount,
+            usedFloridayPacking,
+            warnings: [...warnings, reason],
+            skipped: "blocked",
+            blockedReason: reason,
+            beladingSources,
+        };
+    }
+    // Opruimen op buffer EN op order. Verhuist een order naar een andere buffer,
+    // dan blijven de karren van de oude buffer anders als weeskar staan en telt
+    // Controle karren ze dubbel. Bevroren karren (geprint, gescand, gecontroleerd)
+    // blijven altijd staan.
+    const keepFilter = keepCartIds.length > 0 ? `(${keepCartIds.join(",")})` : null;
+    const clearExistingCarts = async () => {
+        const ids = orderIds.filter(Boolean);
+        const del = () => {
+            const q = sb.from("order_carts").delete();
+            return keepFilter ? q.not("id", "in", keepFilter) : q;
+        };
+        await del().eq("buffer_id", bufferId);
+        if (ids.length > 0) {
+            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) => {
-            const orderIdsOnCart = new Set();
-            for (const i of cart.items) {
-                const oid = i.order_id ?? itemToOrder.get(i.order_item_id);
-                if (oid)
-                    orderIdsOnCart.add(oid);
+        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}.`);
             }
             return {
-                order_id: orderIdsOnCart.size === 1 ? [...orderIdsOnCart][0] : null,
+                order_id: identity.ownerOrderId,
                 buffer_id: bufferId,
-                cart_number: cart.cart_number,
+                cart_number: identity.cartNumber,
+                total_carts: identity.totalCarts,
                 is_auto: true,
                 is_complete: cart.is_complete,
                 source: usedFloridayPacking ? "floriday" : "auto",
@@ -639,24 +1157,30 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
                 carrier_type_id: cart.carrier_type_id,
                 max_layers: cart.max_layers,
                 weight_kg: cart.weight_kg,
-                algorithm_version: LOAD_CARRIER_PLANNER_VERSION,
+                algorithm_version: useDimensions ? DIMENSION_PLANNER_VERSION : LOAD_CARRIER_PLANNER_VERSION,
+                layout_method: useDimensions ? "afmetingen" : "belading",
             };
         });
         const { data: insertedCarts, error } = await sb
             .from("order_carts")
             .insert(cartRows)
-            .select("id, cart_number");
+            .select("id, order_id, cart_number");
         if (error || !Array.isArray(insertedCarts)) {
             const message = `Ladingdragers konden niet worden opgeslagen: ${error?.message ?? "onbekende fout"}`;
             console.error(`[logistiek-engine] buffer ${bufferId}: ${message}`);
-            await sb.from("order_carts").delete().eq("buffer_id", bufferId);
+            await clearExistingCarts();
             throw new Error(message);
         }
         created += insertedCarts.length;
-        const idByNumber = new Map(insertedCarts.map((c) => [Number(c.cart_number), String(c.id)]));
+        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 (const cart of chunk) {
-            const cartId = idByNumber.get(cart.cart_number);
+        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;
             if (!cartId)
                 continue;
             for (const i of cart.items) {
@@ -666,7 +1190,7 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
                     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.max(1, Math.round(i.crates)),
+                    crates: Math.round(i.crates),
                     boxes: i.boxes ?? null,
                     weight_kg: i.weight_kg ?? null,
                     plants_per_crate: i.plants_per_crate,
@@ -674,6 +1198,8 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
                     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,
                 });
             }
         }
@@ -689,10 +1215,126 @@ export async function replanBufferInternal(sb, bufferId, options = {}) {
                     (itemError.details ? ` — ${itemError.details}` : "") +
                     (itemError.hint ? ` (${itemError.hint})` : "");
                 console.error(`[logistiek-engine] buffer ${bufferId}: ${message}`);
-                await sb.from("order_carts").delete().eq("buffer_id", bufferId);
+                await clearExistingCarts();
                 throw new Error(message);
             }
         }
+        // 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)
+                    continue;
+                const rows = layerPositionRows(cartId, dimCart);
+                // Atomair vervangen: eerst de vorige indeling van deze kar weg.
+                await sb.from("order_cart_layer_positions").delete().eq("cart_id", cartId);
+                for (let s = 0; s < rows.length; s += 500) {
+                    const slice = rows.slice(s, s + 500);
+                    if (slice.length === 0)
+                        continue;
+                    const { error: posError } = await sb
+                        .from("order_cart_layer_positions")
+                        .upsert(slice, { onConflict: "cart_id,layer,keg_id" });
+                    if (posError) {
+                        // Een halve indeling is misleidend: de volledige buffer verwijderen
+                        // en de wachtrij laten falen, zodat niets als geldig wordt getoond.
+                        await clearExistingCarts();
+                        throw new Error(`De fysieke laagindeling van kar ${cart.cart_number} kon niet worden opgeslagen: ${posError.message}`);
+                    }
+                }
+                const expectedPositions = rows.length;
+                const { count: storedPositions, error: countError } = await sb
+                    .from("order_cart_layer_positions")
+                    .select("id", { count: "exact", head: true })
+                    .eq("cart_id", cartId);
+                if (countError || storedPositions !== expectedPositions) {
+                    await clearExistingCarts();
+                    throw new Error(`De fysieke indeling van kar ${cart.cart_number} is niet volledig opgeslagen: ` +
+                        `${expectedPositions} fusten verwacht, ${storedPositions ?? 0} opgeslagen.`);
+                }
+            }
+        }
+    }
+    // Sluitcontrole: elke geschreven kar moet de actieve methode én het bijbehorende
+    // versienummer dragen. Zo kan een oudere rekenwijze (bijvoorbeeld een nog niet
+    // bijgewerkte publicatie) nooit stilzwijgend een indeling achterlaten.
+    {
+        const expectedMethod = useDimensions ? "afmetingen" : "belading";
+        const expectedVersion = useDimensions ? DIMENSION_PLANNER_VERSION : LOAD_CARRIER_PLANNER_VERSION;
+        const verifyQuery = sb
+            .from("order_carts")
+            .select("cart_number, layout_method, algorithm_version")
+            .eq("buffer_id", bufferId);
+        // Bevroren karren zijn met een eerdere ronde geschreven en blijven buiten
+        // deze controle: hun identiteit mag nooit meer wijzigen.
+        const { data: writtenCarts, error: verifyError } = keepFilter
+            ? await verifyQuery.not("id", "in", keepFilter)
+            : await verifyQuery;
+        const rows = Array.isArray(writtenCarts) ? writtenCarts : [];
+        const wrong = rows.filter((c) => String(c.layout_method ?? "") !== expectedMethod ||
+            Number(c.algorithm_version) !== expectedVersion);
+        if (verifyError || wrong.length > 0) {
+            const reason = verifyError
+                ? `Karrenindeling kon niet worden gecontroleerd: ${verifyError.message}`
+                : `Karrenindeling is niet volgens de ingestelde werkwijze "${expectedMethod}" vastgelegd ` +
+                    `(${wrong.length} van ${rows.length} karren). Er is niets ingedeeld.`;
+            console.error(`[logistiek-engine] buffer ${bufferId}: ${reason}`);
+            await clearExistingCarts();
+            await sb.rpc("logistics_plan_block", {
+                p_order_ids: orderIds,
+                p_reason: reason,
+                p_details: { bufferId, path: "verificatie", expectedMethod, expectedVersion },
+            });
+            return {
+                ok: false,
+                bufferId,
+                orderIds,
+                cartsCreated: 0,
+                replacedManualCount,
+                usedFloridayPacking,
+                warnings: [...warnings, reason],
+                skipped: "blocked",
+                blockedReason: reason,
+                beladingSources,
+            };
+        }
+    }
+    // Sluitcontrole op de buffer: elk lid moet na afloop een fysieke kar hebben,
+    // eigen kar of een gedeelde bufferkar met een van zijn orderregels. Zonder kar
+    // krijgt dat lid geen pickdocument, en dat is nooit een geldige uitkomst.
+    {
+        const membersToCheck = allOrderRows.map((o) => String(o.id));
+        const stillMissing = await bufferOrdersWithoutCarts(sb, bufferId, membersToCheck);
+        if (stillMissing.length > 0) {
+            const numberById = new Map(allOrderRows.map((o) => [String(o.id), String(o.order_number ?? o.id)]));
+            const refs = stillMissing.map((id) => numberById.get(id) ?? id);
+            const reason = `Bufferindeling onvolledig: order(s) ${refs.join(", ")} hebben geen enkele kar ` +
+                `en zouden dus geen pickdocument krijgen.`;
+            console.error(`[logistiek-engine] buffer ${bufferId}: ${reason}`);
+            await sb.rpc("logistics_plan_block", {
+                p_order_ids: stillMissing,
+                p_reason: reason,
+                p_details: { bufferId, path: "bufferdekking", missing: refs },
+            });
+            return {
+                ok: false,
+                bufferId,
+                orderIds,
+                cartsCreated: created,
+                replacedManualCount,
+                usedFloridayPacking,
+                warnings: [...warnings, reason],
+                skipped: "blocked",
+                blockedReason: reason,
+                beladingSources,
+            };
+        }
     }
     return {
         ok: true,