@flowselections/logistiek-engine 1.0.203 → 1.0.209

package/dist-lib/lib/loadCarrierPlanner.js

@@ -9,22 +9,126 @@
 //   - verticaal  : totalHeightPct <= 100
 //   - horizontaal: crateShare per laag <= 1
 // ============================================================================
-export const LOAD_CARRIER_PLANNER_VERSION = 3;
+export const LOAD_CARRIER_PLANNER_VERSION = 5;
+/** Grens vanaf waar "beladingen per laag" als onbeperkt geldt (instelling 999 = onbeperkt). */
+export const BELADINGEN_ONBEPERKT = 999;
+/**
+ * Leidt de menging per laag af uit de werkwijze.
+ * Niet vrij als: geen optimale vulling, maximaal N beladingen per laag (N < 999),
+ * maximaal N klanten per laag, of één klant per laag.
+ */
+export function bepaalLaagMenging(w) {
+    if (w.optimalFill === false)
+        return { menging: "per_regel", groepen: { klantenPerLaag: null, beladingenPerLaag: null }, reden: "optimale vulling staat uit" };
+    const b = Number(w.maxBeladingenPerLayer);
+    const bel = w.maxBeladingenPerLayer != null && Number.isFinite(b) && b > 0 && b < BELADINGEN_ONBEPERKT ? Math.round(b) : null;
+    const k = Number(w.maxCustomersPerLayer);
+    const kl = w.oneCustomerPerLayer ? 1 : w.maxCustomersPerLayer != null && Number.isFinite(k) && k > 0 ? Math.round(k) : null;
+    const delen = [];
+    if (kl != null)
+        delen.push(`maximaal ${kl} klant(en) per laag`);
+    if (bel != null)
+        delen.push(`maximaal ${bel} beladingen per laag binnen een klant`);
+    return {
+        menging: "vrij",
+        groepen: { klantenPerLaag: kl, beladingenPerLaag: bel },
+        reden: delen.length ? delen.join("; ") : "mengen per laag toegestaan",
+    };
+}
+/**
+ * 1.0.205: lagen op een kar volgens de mengregels.
+ * - "per_regel" (optimale vulling uit): Σ ceil(fust ÷ fusten per laag) per regel.
+ * - anders: regels vormen groepen die een laag mogen delen (zelfde klant; klanten in
+ *   groepen van N; binnen een klant hoogstens M regels). Eén groep op de kar → fractie.
+ *   Meer groepen → elke groep telt in hele lagen: Σ ceil(groep).
+ */
+export function karLagen(regels, menging = "vrij", groepen) {
+    const f = (r) => r.crates / Math.max(1, r.cpl);
+    if (menging === "per_regel")
+        return regels.reduce((s, r) => s + Math.ceil(f(r) - 1e-9), 0);
+    const N = groepen?.klantenPerLaag ?? null;
+    const M = groepen?.beladingenPerLaag ?? null;
+    if (N == null && M == null)
+        return regels.reduce((s, r) => s + f(r), 0);
+    // Per klant, vaste volgorde.
+    const perKlant = new Map();
+    for (const r of regels) {
+        const k = r.klantId ?? `regel:${r.regelId}`;
+        const l = perKlant.get(k) ?? [];
+        l.push(r);
+        perKlant.set(k, l);
+    }
+    const klanten = [...perKlant.keys()].sort();
+    const units = [];
+    if (M != null) {
+        // Binnen een klant groepen van M regels; klanten delen niet als N gezet is.
+        for (const k of klanten) {
+            const l = perKlant.get(k).sort((a, b) => a.regelId.localeCompare(b.regelId));
+            for (let i = 0; i < l.length; i += M)
+                units.push(l.slice(i, i + M).reduce((s, r) => s + f(r), 0));
+        }
+    }
+    else {
+        for (let i = 0; i < klanten.length; i += N) {
+            units.push(klanten.slice(i, i + N).reduce((s, k) => s + perKlant.get(k).reduce((t, r) => t + f(r), 0), 0));
+        }
+    }
+    if (units.length <= 1)
+        return units.reduce((s, u) => s + u, 0);
+    return units.reduce((s, u) => s + Math.ceil(u - 1e-9), 0);
+}
+/**
+ * 1.0.208: vulgraad van een kar zoals Floriday (fractie, 1 = vol):
+ * Σ per regel (lagen van de regel ÷ lagen per kar van die regel).
+ * Mengregels blijven: een afgeronde laag (tussen groepen die geen laag mogen delen)
+ * telt met de kleinste lagen-per-kar binnen die groep.
+ */
+export function karVulgraadFractie(regels, menging = "vrij", groepen) {
+    const f = (r) => r.crates / Math.max(1, r.cpl);
+    const l = (r) => Math.max(1, Number(r.lpc) || 1);
+    if (menging === "per_regel")
+        return regels.reduce((s, r) => s + Math.ceil(f(r) - 1e-9) / l(r), 0);
+    const N = groepen?.klantenPerLaag ?? null;
+    const M = groepen?.beladingenPerLaag ?? null;
+    if (N == null && M == null)
+        return regels.reduce((s, r) => s + f(r) / l(r), 0);
+    const perKlant = new Map();
+    for (const r of regels) {
+        const k = r.klantId ?? `regel:${r.regelId}`;
+        const lijst = perKlant.get(k) ?? [];
+        lijst.push(r);
+        perKlant.set(k, lijst);
+    }
+    const klanten = [...perKlant.keys()].sort();
+    const units = [];
+    if (M != null) {
+        for (const k of klanten) {
+            const lijst = perKlant.get(k).sort((a, b) => a.regelId.localeCompare(b.regelId));
+            for (let i = 0; i < lijst.length; i += M)
+                units.push(lijst.slice(i, i + M));
+        }
+    }
+    else {
+        for (let i = 0; i < klanten.length; i += N)
+            units.push(klanten.slice(i, i + N).flatMap((k) => perKlant.get(k)));
+    }
+    if (units.length <= 1)
+        return regels.reduce((s, r) => s + f(r) / l(r), 0);
+    return units.reduce((s, u) => {
+        const lagen = u.reduce((t, r) => t + f(r), 0);
+        return s + Math.ceil(lagen - 1e-9) / Math.min(...u.map(l));
+    }, 0);
+}
+/** Lagen van één regel op een kar volgens de menging per laag. */
+export function regelLagen(crates, cpl, menging = "vrij") {
+    const f = crates / Math.max(1, cpl);
+    return menging === "per_regel" ? Math.ceil(f - 1e-9) : f;
+}
 const EPS = 1e-9;
 function clampInt(value, min) {
     const n = typeof value === "string" ? Number(value) : value;
     return Math.max(min, Math.round(Number.isFinite(n) ? n : min));
 }
-/** Effectieve lagen: het minimum van de productbelading en de ladingdrager. */
-function effectiveLayers(item, carrier) {
-    const carrierLayers = Math.max(1, Math.round(carrier.layers_per_carrier || 1));
-    if (carrier.capacity_model === "single" || carrier.capacity_model === "none")
-        return 1;
-    // Floriday-verpakking is leidend en wordt niet afgeknepen op het profiel.
-    if (item.packing_authoritative)
-        return Math.max(1, Math.round(item.layers_per_cart));
-    return Math.max(1, Math.min(item.layers_per_cart, carrierLayers));
-}
 /** Effectieve fusten per laag: begrensd door de ladingdrager. */
 function effectiveCratesPerLayer(item, carrier) {
     const cap = carrier.max_crates_per_layer;
@@ -33,197 +137,6 @@ function effectiveCratesPerLayer(item, carrier) {
         return Math.max(1, Math.min(base, Math.round(cap)));
     return base;
 }
-// ---------------------------------------------------------------------------
-// Plaatsingsregels
-// ---------------------------------------------------------------------------
-function placeAsFreshLayer(cart, batch, batchIdx, crates) {
-    if (cart.totalHeightPct + batch.layerHeightPct > 100 + EPS)
-        return false;
-    cart.layers.push({
-        heightPct: batch.layerHeightPct,
-        crateShare: crates / batch.cratesPerLayer,
-        entries: [{ batchIdx, crates }],
-        customerIds: new Set(batch.input.customer_id ? [batch.input.customer_id] : []),
-    });
-    cart.totalHeightPct += batch.layerHeightPct;
-    return true;
-}
-function placeInLayer(cart, batch, batchIdx, crates, r) {
-    const partyShare = crates / batch.cratesPerLayer;
-    const maxShare = r.opts.maxPartySharePerLayerPct / 100;
-    // REGEL 1 — één partij mag nooit meer dan X% van een laag beslaan
-    if (partyShare > maxShare + EPS)
-        return false;
-    // REGEL 2 — never-mix producten en niet-mengbare ladingdragers
-    const neverMix = r.opts.carrier.allow_mixing === false ||
-        (batch.input.product_id ? r.opts.neverMixProductIds.has(batch.input.product_id) : false);
-    if (neverMix)
-        return false;
-    for (const layer of cart.layers) {
-        // REGEL 3 — max aantal verschillende beladingen per laag
-        if (layer.entries.length >= r.opts.maxBeladingenPerLayer)
-            continue;
-        // REGEL 4 — dezelfde partij niet twee keer in dezelfde laag
-        if (layer.entries.some((e) => e.batchIdx === batchIdx))
-            continue;
-        // REGEL 4b — maximaal aantal verschillende klanten op één laag
-        const layerCustomerLimit = r.opts.oneCustomerPerLayer
-            ? 1
-            : r.opts.maxCustomersPerLayer && r.opts.maxCustomersPerLayer > 0
-                ? r.opts.maxCustomersPerLayer
-                : null;
-        const customerId = batch.input.customer_id ?? null;
-        if (layerCustomerLimit != null &&
-            customerId &&
-            !layer.customerIds.has(customerId) &&
-            layer.customerIds.size >= layerCustomerLimit) {
-            continue;
-        }
-        // REGEL 5 — vloeroppervlak van de laag mag niet over 100%
-        if (layer.crateShare + partyShare > 1 + EPS)
-            continue;
-        // REGEL 6 — hoogte: bij mengen telt de HOOGSTE partij
-        const newHeight = Math.max(layer.heightPct, batch.layerHeightPct);
-        const heightDelta = newHeight - layer.heightPct;
-        if (cart.totalHeightPct + heightDelta > 100 + EPS)
-            continue;
-        layer.entries.push({ batchIdx, crates });
-        if (customerId)
-            layer.customerIds.add(customerId);
-        layer.crateShare += partyShare;
-        layer.heightPct = newHeight;
-        cart.totalHeightPct += heightDelta;
-        return true;
-    }
-    return false;
-}
-/** Extra grenzen die niet over hoogte of oppervlak gaan. */
-function acceptsBatch(cart, batch, crates, r) {
-    const carrier = r.opts.carrier;
-    const orderId = batch.input.order_id ?? null;
-    if (orderId && !cart.orderIds.has(orderId) && r.opts.maxOrders && cart.orderIds.size >= r.opts.maxOrders) {
-        return false;
-    }
-    const customerId = batch.input.customer_id ?? null;
-    if (customerId &&
-        !cart.customerIds.has(customerId) &&
-        r.opts.maxCustomers &&
-        cart.customerIds.size >= r.opts.maxCustomers) {
-        return false;
-    }
-    if (typeof carrier.max_boxes === "number" && carrier.max_boxes > 0) {
-        if (cart.boxes + crates > carrier.max_boxes)
-            return false;
-    }
-    if (typeof carrier.max_weight_kg === "number" && carrier.max_weight_kg > 0) {
-        const perCrate = Number(batch.input.weight_per_crate ?? 0) || 0;
-        if (perCrate > 0 && cart.weightKg + perCrate * crates > carrier.max_weight_kg + EPS)
-            return false;
-    }
-    return true;
-}
-function registerPlacement(cart, batch, crates) {
-    if (batch.input.order_id)
-        cart.orderIds.add(batch.input.order_id);
-    if (batch.input.customer_id)
-        cart.customerIds.add(batch.input.customer_id);
-    cart.boxes += crates;
-    cart.weightKg += (Number(batch.input.weight_per_crate ?? 0) || 0) * crates;
-}
-function tryPlaceBatch(cart, batch, batchIdx, r) {
-    const cpl = batch.cratesPerLayer;
-    let placed = 0;
-    let remaining = batch.cratesRemaining;
-    // 1) zo veel mogelijk VOLLE eigen lagen
-    while (remaining >= cpl && cart.totalHeightPct + batch.layerHeightPct <= 100 + EPS) {
-        if (!acceptsBatch(cart, batch, cpl, r))
-            break;
-        if (!placeAsFreshLayer(cart, batch, batchIdx, cpl))
-            break;
-        registerPlacement(cart, batch, cpl);
-        remaining -= cpl;
-        placed += cpl;
-    }
-    // 2) het restant: eerst bijmengen, anders eigen (deels lege) laag
-    if (remaining > 0) {
-        const partial = Math.min(remaining, Math.ceil(cpl * 0.5));
-        if (acceptsBatch(cart, batch, partial, r) && placeInLayer(cart, batch, batchIdx, partial, r)) {
-            registerPlacement(cart, batch, partial);
-            remaining -= partial;
-            placed += partial;
-        }
-        else if (acceptsBatch(cart, batch, remaining, r) && placeAsFreshLayer(cart, batch, batchIdx, remaining)) {
-            registerPlacement(cart, batch, remaining);
-            placed += remaining;
-            remaining = 0;
-        }
-    }
-    return placed;
-}
-// ---------------------------------------------------------------------------
-// Samenvatten
-// ---------------------------------------------------------------------------
-function summarizeCart(cart, rests, cartNumber, r) {
-    const byBatch = new Map();
-    for (const layer of cart.layers) {
-        const shareSum = layer.entries.reduce((s, e) => s + e.crates, 0);
-        for (const e of layer.entries) {
-            const cur = byBatch.get(e.batchIdx) ?? { crates: 0, layerFraction: 0, heightPct: 0 };
-            const ratio = shareSum > 0 ? e.crates / shareSum : 0;
-            cur.crates += e.crates;
-            cur.layerFraction += ratio;
-            cur.heightPct += layer.heightPct * ratio;
-            byBatch.set(e.batchIdx, cur);
-        }
-    }
-    const totalHeight = cart.totalHeightPct;
-    const items = [];
-    let weight = 0;
-    for (const [batchIdx, agg] of byBatch) {
-        const input = rests[batchIdx].input;
-        const perCrate = Number(input.weight_per_crate ?? 0) || 0;
-        weight += perCrate * agg.crates;
-        items.push({
-            order_item_id: input.order_item_id,
-            order_id: input.order_id ?? null,
-            product_id: input.product_id,
-            product_name: input.product_name,
-            crates: agg.crates,
-            plants: agg.crates * input.plants_per_crate,
-            boxes: agg.crates,
-            weight_kg: perCrate > 0 ? Math.round(perCrate * agg.crates * 100) / 100 : null,
-            plants_per_crate: input.plants_per_crate,
-            crates_per_layer: rests[batchIdx].cratesPerLayer,
-            layers_per_cart: Math.max(1, Math.round(100 / rests[batchIdx].layerHeightPct)),
-            // 1.0.190: layer_fraction = vulling per laag (0–1); lagen = fusten ÷ fusten per laag.
-            layer_fraction: Math.min(1, Math.round((agg.crates / Math.max(1, rests[batchIdx].cratesPerLayer)) * 1000) / 1000),
-            lagen: Math.round((agg.crates / Math.max(1, rests[batchIdx].cratesPerLayer)) * 1000) / 1000,
-            layer_share_pct: agg.heightPct,
-        });
-    }
-    return {
-        cart_number: cartNumber,
-        carrier_type: r.opts.carrier.code,
-        carrier_type_id: r.opts.carrier.id ?? null,
-        source: "auto",
-        is_complete: Math.abs(cart.totalHeightPct - 100) < 1e-6,
-        occupancy_pct: Math.round(cart.totalHeightPct * 100) / 100,
-        total_layers_used: cart.layers.length,
-        max_layers: Math.max(1, Math.round(r.opts.carrier.layers_per_carrier || 1)),
-        weight_kg: weight > 0 ? Math.round(weight * 100) / 100 : null,
-        items,
-    };
-}
-function newCart() {
-    return {
-        layers: [],
-        totalHeightPct: 0,
-        boxes: 0,
-        weightKg: 0,
-        orderIds: new Set(),
-        customerIds: new Set(),
-    };
-}
 function fullCart(input, crates, cratesPerLayer, layers, cartNumber, r) {
     const perCrate = Number(input.weight_per_crate ?? 0) || 0;
     return {
@@ -232,9 +145,9 @@ function fullCart(input, crates, cratesPerLayer, layers, cartNumber, r) {
         carrier_type_id: r.opts.carrier.id ?? null,
         source: "auto",
         is_complete: true,
-        occupancy_pct: 100,
-        total_layers_used: layers,
-        max_layers: Math.max(1, Math.round(r.opts.carrier.layers_per_carrier || 1)),
+        occupancy_pct: Math.round((10000 * crates) / Math.max(1, cratesPerLayer * layers)) / 100,
+        total_layers_used: Math.round((crates / Math.max(1, cratesPerLayer)) * 100) / 100,
+        max_layers: layers,
         weight_kg: perCrate > 0 ? Math.round(perCrate * crates * 100) / 100 : null,
         items: [
             {
@@ -272,8 +185,188 @@ function sortInputs(items, sortOrder) {
     }
 }
 // ---------------------------------------------------------------------------
-// Hoofdfunctie
+// 1.0.204: capaciteit per kar (zelfde regel als Floriday)
 // ---------------------------------------------------------------------------
+// lagen op de kar   = Σ (fust ÷ fusten per laag) per regel
+// capaciteit        = hoogste "lagen per kar" van de producten op de kar
+// vol               = lagen ≥ capaciteit (− 0,001)
+// verdelen          = vul een kar tot de capaciteit, rest naar de volgende kar
+// Voegt een product met meer lagen per kar toe, dan stijgt de capaciteit.
+// ---------------------------------------------------------------------------
+export const LAGEN_MARGE = 0.001;
+/** Capaciteit van een kar: hoogste lagen-per-kar van de producten; anders de ladingdrager. */
+export function karCapaciteit(productLagen, ladingdragerLagen) {
+    const geldig = productLagen.map(Number).filter((n) => Number.isFinite(n) && n > 0);
+    if (geldig.length > 0)
+        return { capaciteit: Math.max(...geldig), bron: "product" };
+    const l = Number(ladingdragerLagen);
+    if (ladingdragerLagen != null && Number.isFinite(l) && l > 0)
+        return { capaciteit: l, bron: "ladingdrager" };
+    return { capaciteit: null, bron: null };
+}
+/** Vulgraad in procenten (heel getal), of null als de capaciteit onbekend is. */
+export function karVulgraad(lagen, capaciteit) {
+    if (capaciteit == null || !(capaciteit > 0) || !Number.isFinite(lagen))
+        return null;
+    return Math.round((100 * lagen) / capaciteit);
+}
+function productLagen(item, carrier) {
+    if (carrier.capacity_model === "single")
+        return 1;
+    let l = Math.max(1, Math.round(item.layers_per_cart));
+    const grens = carrier.werkwijze_max_lagen;
+    if (typeof grens === "number" && grens > 0 && !item.packing_authoritative)
+        l = Math.min(l, Math.round(grens));
+    return l;
+}
+function accepteert(kar, rest, crates, r) {
+    const c = r.opts.carrier;
+    const orderId = rest.input.order_id ?? null;
+    if (orderId && !kar.orderIds.has(orderId) && r.opts.maxOrders && kar.orderIds.size >= r.opts.maxOrders)
+        return false;
+    const klant = rest.input.customer_id ?? null;
+    if (klant && !kar.customerIds.has(klant) && r.opts.maxCustomers && kar.customerIds.size >= r.opts.maxCustomers)
+        return false;
+    if (typeof c.max_boxes === "number" && c.max_boxes > 0 && kar.boxes + crates > c.max_boxes)
+        return false;
+    if (typeof c.max_weight_kg === "number" && c.max_weight_kg > 0) {
+        const pc = Number(rest.input.weight_per_crate ?? 0) || 0;
+        if (pc > 0 && kar.weightKg + pc * crates > c.max_weight_kg + EPS)
+            return false;
+    }
+    return true;
+}
+/** Hoeveel fusten van deze rest passen nog op de kar (0 = niets). */
+/** Lagen van een kar volgens de mengregels, optioneel met extra fusten van een rest. */
+function regelsVan(kar, rests, extra) {
+    const per = new Map();
+    for (const e of kar.entries)
+        per.set(e.restIdx, (per.get(e.restIdx) ?? 0) + e.crates);
+    if (extra)
+        per.set(extra.restIdx, (per.get(extra.restIdx) ?? 0) + extra.crates);
+    return [...per.entries()].map(([i, crates]) => ({
+        regelId: rests[i].input.order_item_id,
+        klantId: rests[i].input.customer_id ?? rests[i].input.order_id ?? null,
+        crates,
+        cpl: rests[i].cpl,
+        lpc: rests[i].lpc,
+    }));
+}
+function vulVan(kar, rests, r, extra) {
+    return karVulgraadFractie(regelsVan(kar, rests, extra), r.opts.laagMenging, r.opts.laagGroepen);
+}
+function lagenVan(kar, rests, r, extra) {
+    const per = new Map();
+    for (const e of kar.entries)
+        per.set(e.restIdx, (per.get(e.restIdx) ?? 0) + e.crates);
+    if (extra)
+        per.set(extra.restIdx, (per.get(extra.restIdx) ?? 0) + extra.crates);
+    const regels = [...per.entries()].map(([i, crates]) => ({
+        regelId: rests[i].input.order_item_id,
+        klantId: rests[i].input.customer_id ?? rests[i].input.order_id ?? null,
+        crates,
+        cpl: rests[i].cpl,
+    }));
+    return karLagen(regels, r.opts.laagMenging, r.opts.laagGroepen);
+}
+function pastErop(kar, rest, r, rests, restIdx) {
+    const neverMix = r.opts.carrier.allow_mixing === false ||
+        (rest.input.product_id ? r.opts.neverMixProductIds.has(rest.input.product_id) : false);
+    if (kar.entries.length > 0 && (neverMix || kar.neverMix))
+        return 0;
+    // 1.0.208: vol = vulgraad 100 % (Σ lagen van regel ÷ lagen per kar van die regel).
+    const vrij = 1 - kar.vul;
+    if (vrij <= LAGEN_MARGE)
+        return 0;
+    let n = Math.min(rest.crates, Math.floor((vrij + LAGEN_MARGE) * rest.lpc * rest.cpl + 1e-9));
+    const c = r.opts.carrier;
+    if (typeof c.max_boxes === "number" && c.max_boxes > 0)
+        n = Math.min(n, c.max_boxes - kar.boxes);
+    if (typeof c.max_weight_kg === "number" && c.max_weight_kg > 0) {
+        const pc = Number(rest.input.weight_per_crate ?? 0) || 0;
+        if (pc > 0)
+            n = Math.min(n, Math.floor((c.max_weight_kg - kar.weightKg + EPS) / pc));
+    }
+    // Mengregels: grootste n waarbij de kar binnen de capaciteit blijft (monotoon → binair zoeken).
+    const past = (m) => vulVan(kar, rests, r, { restIdx, crates: m }) <= 1 + LAGEN_MARGE;
+    if (n > 0 && !past(n)) {
+        let lo = 0, hi = n;
+        while (lo < hi) {
+            const mid = Math.ceil((lo + hi) / 2);
+            if (past(mid))
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        n = lo;
+    }
+    if (n <= 0 || !accepteert(kar, rest, n, r))
+        return 0;
+    return n;
+}
+function zetErop(kar, rest, restIdx, crates, r, rests) {
+    kar.entries.push({ restIdx, crates });
+    kar.capaciteit = Math.max(kar.capaciteit, rest.lpc);
+    kar.boxes += crates;
+    kar.weightKg += (Number(rest.input.weight_per_crate ?? 0) || 0) * crates;
+    if (rest.input.order_id)
+        kar.orderIds.add(rest.input.order_id);
+    if (rest.input.customer_id)
+        kar.customerIds.add(rest.input.customer_id);
+    if (r.opts.carrier.allow_mixing === false ||
+        (rest.input.product_id ? r.opts.neverMixProductIds.has(rest.input.product_id) : false))
+        kar.neverMix = true;
+    rest.crates -= crates;
+    kar.lagen = lagenVan(kar, rests, r);
+    kar.vul = vulVan(kar, rests, r);
+}
+function nieuweKar() {
+    return { entries: [], lagen: 0, vul: 0, capaciteit: 0, boxes: 0, weightKg: 0, orderIds: new Set(), customerIds: new Set(), neverMix: false, eigen: false };
+}
+function samenvatten(kar, rests, nr, r) {
+    const per = new Map();
+    for (const e of kar.entries)
+        per.set(e.restIdx, (per.get(e.restIdx) ?? 0) + e.crates);
+    const items = [];
+    let weight = 0;
+    const sleutel = (i) => `${rests[i].input.product_name}\u0000${rests[i].input.order_item_id}`;
+    for (const [idx, crates] of [...per.entries()].sort((a, b) => sleutel(a[0]).localeCompare(sleutel(b[0])))) {
+        const rest = rests[idx];
+        const input = rest.input;
+        const pc = Number(input.weight_per_crate ?? 0) || 0;
+        weight += pc * crates;
+        const lagen = regelLagen(crates, rest.cpl, r.opts.laagMenging);
+        items.push({
+            order_item_id: input.order_item_id,
+            order_id: input.order_id ?? null,
+            product_id: input.product_id,
+            product_name: input.product_name,
+            crates,
+            plants: crates * input.plants_per_crate,
+            boxes: crates,
+            weight_kg: pc > 0 ? Math.round(pc * crates * 100) / 100 : null,
+            plants_per_crate: input.plants_per_crate,
+            crates_per_layer: rest.cpl,
+            layers_per_cart: rest.lpc,
+            layer_fraction: Math.min(1, Math.round(lagen * 1000) / 1000),
+            lagen: Math.round(lagen * 1000) / 1000,
+            layer_share_pct: Math.round((10000 * lagen) / kar.capaciteit) / 100,
+        });
+    }
+    const lagen = Math.round(kar.lagen * 100) / 100;
+    return {
+        cart_number: nr,
+        carrier_type: r.opts.carrier.code,
+        carrier_type_id: r.opts.carrier.id ?? null,
+        source: "auto",
+        is_complete: kar.vul >= 1 - LAGEN_MARGE,
+        occupancy_pct: Math.round(10000 * kar.vul) / 100,
+        total_layers_used: lagen,
+        max_layers: kar.capaciteit,
+        weight_kg: weight > 0 ? Math.round(weight * 100) / 100 : null,
+        items,
+    };
+}
 export function planLoadUnits(inputs, options) {
     const carrier = options.carrier;
     const r = {
@@ -288,6 +381,8 @@ export function planLoadUnits(inputs, options) {
             oneCustomerPerLayer: options.oneCustomerPerLayer ?? false,
             ownCarrierFromLayers: options.ownCarrierFromLayers ?? null,
             sortOrder: options.sortOrder ?? "none",
+            laagMenging: options.laagMenging ?? "vrij",
+            laagGroepen: options.laagGroepen ?? null,
         },
     };
     const warnings = [];
@@ -301,7 +396,6 @@ export function planLoadUnits(inputs, options) {
         layers_per_cart: clampInt(i.layers_per_cart, 1),
     }))
         .filter((i) => i.plants > 0), r.opts.sortOrder);
-    // --- Model "none": elke partij is één losse eenheid, geen menging ---------
     if (carrier.capacity_model === "none") {
         let n = 0;
         for (const it of items) {
@@ -310,91 +404,70 @@ export function planLoadUnits(inputs, options) {
         }
         return { carts, warnings };
     }
+    // STAP A: volle karren per product (capaciteit = lagen per kar van dat product).
     const rests = [];
-    let cartNumber = 0;
-    // --- STAP A: volledige ladingdragers per artikel --------------------------
     for (const it of items) {
-        const layers = effectiveLayers(it, carrier);
+        const lpc = productLagen(it, carrier);
         const cpl = effectiveCratesPerLayer(it, carrier);
-        let cratesPerCart = cpl * layers;
-        if (typeof carrier.max_boxes === "number" && carrier.max_boxes > 0) {
-            cratesPerCart = Math.min(cratesPerCart, carrier.max_boxes);
-        }
-        const totalCrates = Math.ceil(it.plants / it.plants_per_crate);
-        const fullCarts = Math.floor(totalCrates / cratesPerCart);
-        let remainderCrates = totalCrates - fullCarts * cratesPerCart;
-        for (let c = 0; c < fullCarts; c++) {
-            carts.push(fullCart(it, cratesPerCart, cpl, layers, ++cartNumber, r));
-        }
-        // Partij die zelfstandig genoeg volle lagen vult krijgt een eigen drager.
-        // 1.0.190: die drager blijft open voor restfusten (hele fusten, eigen laag
-        // of bijmengen volgens de laagregels), zodat er geen extra kar ontstaat.
-        const own = r.opts.ownCarrierFromLayers;
-        const ownCarrier = Boolean(own && own > 0 && remainderCrates >= cpl * (own ?? 0));
-        if (remainderCrates > 0) {
-            rests.push({
-                input: it,
-                cratesRemaining: remainderCrates,
-                layerHeightPct: 100 / layers,
-                cratesPerLayer: cpl,
-                beladingKey: `${it.plants_per_crate}x${cpl}x${layers}`,
-                ownCarrier,
-            });
+        let perKar = cpl * lpc;
+        if (typeof carrier.max_boxes === "number" && carrier.max_boxes > 0)
+            perKar = Math.min(perKar, carrier.max_boxes);
+        const totaal = Math.ceil(it.plants / it.plants_per_crate);
+        const vol = Math.floor(totaal / perKar);
+        for (let c = 0; c < vol; c++)
+            carts.push(fullCart(it, perKar, cpl, lpc, carts.length + 1, r));
+        const rest = totaal - vol * perKar;
+        if (rest > 0) {
+            const own = r.opts.ownCarrierFromLayers;
+            rests.push({ input: it, crates: rest, cpl, lpc, ownCarrier: Boolean(own && own > 0 && rest >= cpl * own) });
         }
     }
-    // --- Sorteren van de restpartijen: eigen dragers eerst, dan first-fit decreasing
-    rests.sort((a, b) => {
-        if (Boolean(a.ownCarrier) !== Boolean(b.ownCarrier))
-            return a.ownCarrier ? -1 : 1;
-        if (a.beladingKey !== b.beladingKey)
-            return a.beladingKey.localeCompare(b.beladingKey);
-        return b.cratesRemaining - a.cratesRemaining;
+    // STAP B: restpartijen. Vaste volgorde (deterministisch): eigen drager eerst,
+    // dan hoogste capaciteit, dan meeste lagen, dan productnaam en regel-id.
+    const volgorde = rests
+        .map((rest, idx) => ({ rest, idx }))
+        .sort((a, b) => {
+        if (a.rest.ownCarrier !== b.rest.ownCarrier)
+            return a.rest.ownCarrier ? -1 : 1;
+        if (a.rest.lpc !== b.rest.lpc)
+            return b.rest.lpc - a.rest.lpc;
+        const la = a.rest.crates / a.rest.cpl, lb = b.rest.crates / b.rest.cpl;
+        if (Math.abs(la - lb) > 1e-9)
+            return lb - la;
+        return (a.rest.input.product_name.localeCompare(b.rest.input.product_name) ||
+            a.rest.input.order_item_id.localeCompare(b.rest.input.order_item_id));
     });
-    // --- STAP B: de hoofdlus --------------------------------------------------
-    const openCarts = [];
-    for (let bi = 0; bi < rests.length; bi++) {
-        const batch = rests[bi];
+    const open = [];
+    for (const { rest, idx } of volgorde) {
         let guard = 0;
-        let eigenDrager = null;
-        while (batch.cratesRemaining > 0 && guard++ < 1000) {
-            let placed = 0;
-            // Eigen drager: op een nieuwe drager beginnen en daar blijven (niet bij een ander inschuiven).
-            const kandidaten = batch.ownCarrier ? (eigenDrager ? [eigenDrager] : []) : openCarts;
-            for (const cart of kandidaten) {
-                placed = tryPlaceBatch(cart, batch, bi, r);
-                if (placed > 0) {
-                    batch.cratesRemaining -= placed;
+        while (rest.crates > 0 && guard++ < 10000) {
+            let geplaatst = false;
+            const kandidaten = rest.ownCarrier ? [] : open;
+            for (const kar of kandidaten) {
+                const n = pastErop(kar, rest, r, rests, idx);
+                if (n > 0) {
+                    zetErop(kar, rest, idx, n, r, rests);
+                    geplaatst = true;
                     break;
                 }
             }
-            if (placed === 0) {
-                const cart = newCart();
-                placed = tryPlaceBatch(cart, batch, bi, r);
-                if (placed === 0) {
-                    warnings.push(`Partij "${batch.input.product_name}" past niet volgens de veiligheidsregels van ${carrier.name} — geplaatst als losse ladingdrager.`);
-                    cart.layers.push({
-                        heightPct: 100,
-                        crateShare: 1,
-                        entries: [{ batchIdx: bi, crates: batch.cratesRemaining }],
-                        customerIds: new Set(batch.input.customer_id ? [batch.input.customer_id] : []),
-                    });
-                    cart.totalHeightPct = 100;
-                    registerPlacement(cart, batch, batch.cratesRemaining);
-                    placed = batch.cratesRemaining;
-                }
-                openCarts.push(cart);
-                if (batch.ownCarrier && !eigenDrager)
-                    eigenDrager = cart;
-                batch.cratesRemaining -= placed;
+            if (geplaatst)
+                continue;
+            const kar = nieuweKar();
+            kar.eigen = rest.ownCarrier;
+            const n = pastErop(kar, rest, r, rests, idx);
+            if (n > 0) {
+                zetErop(kar, rest, idx, n, r, rests);
             }
+            else {
+                warnings.push(`Partij "${rest.input.product_name}" past niet volgens de grenzen van ${carrier.name} — geplaatst als losse ladingdrager.`);
+                zetErop(kar, rest, idx, rest.crates, r, rests);
+            }
+            open.push(kar);
         }
     }
-    for (const cart of openCarts) {
-        carts.push(summarizeCart(cart, rests, ++cartNumber, r));
-    }
-    // Doornummeren zodat de volgorde altijd 1..n is.
-    carts.forEach((c, idx) => {
-        c.cart_number = idx + 1;
-    });
+    for (const kar of open)
+        carts.push(samenvatten(kar, rests, carts.length + 1, r));
+    carts.forEach((c, i) => { c.cart_number = i + 1; });
     return { carts, warnings };
 }