@flowselections/logistiek-engine 1.0.1

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

@@ -0,0 +1,106 @@
+// ============================================================================
+// src/lib/loadCarrierPlanning.functions.ts — server functions (thin wrappers)
+// ============================================================================
+import { createServerFn } from "@tanstack/react-start";
+import { requireSupabaseAuth } from "../integrations/supabase/auth-middleware";
+export const replanOrderLoadCarriers = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((data) => {
+    if (!data || typeof data.orderId !== "string" || data.orderId.length === 0) {
+        throw new Error("orderId is verplicht");
+    }
+    return data;
+})
+    .handler(async ({ data }) => {
+    const { replanOrderInternal } = await import("./loadCarrierPlanning.server");
+    const { attachIndelingToTasks } = await import("./loadCarrierTaskSync.server");
+    const result = await replanOrderInternal(data.orderId, {
+        dryRun: data.dryRun,
+        carrierType: data.carrierType ?? null,
+    });
+    if (result && !data.dryRun)
+        await attachIndelingToTasks(result);
+    return result;
+});
+export const replanBufferLoadCarriers = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((data) => {
+    if (!data || typeof data.bufferId !== "string" || data.bufferId.length === 0) {
+        throw new Error("bufferId is verplicht");
+    }
+    return data;
+})
+    .handler(async ({ data }) => {
+    const { replanBufferInternal } = await import("./loadCarrierPlanning.server");
+    const { attachIndelingToTasks } = await import("./loadCarrierTaskSync.server");
+    const result = await replanBufferInternal(data.bufferId, {
+        dryRun: data.dryRun,
+        carrierType: data.carrierType ?? null,
+    });
+    if (!data.dryRun)
+        await attachIndelingToTasks(result);
+    return result;
+});
+/**
+ * Deelt alle orders in, in batches. De client roept dit net zo lang aan tot
+ * `done` waar is en schakelt dan door naar de volgende fase.
+ */
+export const planAllLoadCarriers = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((data) => data ?? {})
+    .handler(async ({ data }) => {
+    const { planBuffersBatch, planLooseOrdersBatch } = await import("./bulkLoadCarrierPlanning.server");
+    const limit = Math.min(Math.max(Number(data.limit ?? 20), 1), 50);
+    const cursor = data.cursor ?? null;
+    if (data.phase === "orders")
+        return planLooseOrdersBatch(cursor, limit);
+    return planBuffersBatch(cursor, limit);
+});
+/**
+ * Zet voor orders zonder takenketen alsnog een melding klaar, zodat de Engine
+ * de volledige keten (inclusief load.compose) aanmaakt.
+ */
+export const ensureLogisticsTasks = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((data) => data ?? {})
+    .handler(async ({ data, context }) => {
+    const { findOrdersWithoutTasks } = await import("./bulkLoadCarrierPlanning.server");
+    const limit = Math.min(Math.max(Number(data.limit ?? 50), 1), 200);
+    const orders = await findOrdersWithoutTasks(limit);
+    let created = 0;
+    const errors = [];
+    for (const order of orders) {
+        const { error } = await context.supabase.rpc("logistics_emit_event", {
+            p_source_module: "logistiek-engine",
+            p_event_type: "order.received",
+            p_order_ref: order.orderRef,
+            p_payload: {
+                source: "bulk-indeling",
+                orderId: order.id,
+                ...(order.pickupAt ? { pickupAt: order.pickupAt } : {}),
+            },
+            p_strategy_id: data.strategyId ?? null,
+            p_shadow: false,
+            p_idempotency_key: `bulk:${order.orderRef}`,
+        });
+        if (error) {
+            if (errors.length < 5)
+                errors.push(error.message);
+        }
+        else {
+            created++;
+        }
+    }
+    return { checked: orders.length, created, errors };
+});
+export const previewLoadCarrierPlan = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((data) => {
+    if (!data || typeof data.orderId !== "string")
+        throw new Error("orderId is verplicht");
+    return data;
+})
+    .handler(async ({ data }) => {
+    const { replanOrderInternal } = await import("./loadCarrierPlanning.server");
+    return replanOrderInternal(data.orderId, { dryRun: true, carrierType: data.carrierType ?? null });
+});

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

@@ -0,0 +1,46 @@
+import { type CarrierProfile, type PlannedLoadUnit, type PlannerInputItem } from "./loadCarrierPlanner";
+import { type LoadCarrierTypeRow } from "./loadCarrierTypes";
+export declare function buildBufferKey(order: {
+    id: string;
+    customer_id?: string | null;
+    delivery_date?: string | null;
+    custom_fields?: any;
+}, mode: string): {
+    key: string;
+    pickupDate: string;
+    location: string;
+};
+export declare function resolveBufferForOrderInternal(orderId: string): Promise<string | null>;
+export declare function expandOrderItemsForPlanner(rows: Array<Record<string, any>>): Promise<PlannerInputItem[]>;
+export declare function loadCarrierProfiles(): Promise<LoadCarrierTypeRow[]>;
+export interface BeladingRules {
+    maxOrders: number | null;
+    maxCustomers: number | null;
+    maxLayers: number | null;
+    maxBoxes: number | null;
+    optimalFill: boolean;
+}
+/** Leest de actieve werkwijze en vertaalt "2. Beladingindeling" naar plannergrenzen. */
+export declare function loadBeladingRules(): Promise<BeladingRules | null>;
+/** Past de grenzen uit de werkwijze toe op het capaciteitsprofiel van een ladingdrager. */
+export declare function applyRulesToProfile(profile: CarrierProfile, rules: BeladingRules | null): CarrierProfile;
+export interface ReplanResult {
+    ok: boolean;
+    bufferId: string;
+    orderIds: string[];
+    cartsCreated: number;
+    replacedManualCount: number;
+    usedFloridayPacking: boolean;
+    warnings: string[];
+    skipped?: "locked";
+    carts?: PlannedLoadUnit[];
+}
+export interface ReplanOptions {
+    /** Alleen berekenen, niets wegschrijven. */
+    dryRun?: boolean;
+    /** Overschrijf het ladingdragertype dat de Rule Engine zou kiezen. */
+    carrierType?: string | null;
+}
+export declare function replanBufferInternal(bufferId: string, options?: ReplanOptions): Promise<ReplanResult>;
+export declare function replanOrderInternal(orderId: string, options?: ReplanOptions): Promise<ReplanResult | null>;
+//# sourceMappingURL=loadCarrierPlanning.server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loadCarrierPlanning.server.d.ts","sourceRoot":"","sources":["../../src/lib/loadCarrierPlanning.server.ts"],"names":[],"mappings":"AASA,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACtB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAA0B,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAkCrF,wBAAgB,cAAc,CAC5B,KAAK,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,aAAa,CAAC,EAAE,GAAG,CAAA;CAAE,EACtG,IAAI,EAAE,MAAM,GACX;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAqCvD;AAID,wBAAsB,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAmE3F;AAgBD,wBAAsB,0BAA0B,CAC9C,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,GAC/B,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA0H7B;AAMD,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAOzE;AAUD,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,WAAW,EAAE,OAAO,CAAC;CACtB;AAOD,wFAAwF;AACxF,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAsBvE;AAED,2FAA2F;AAC3F,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,aAAa,GAAG,IAAI,GAAG,cAAc,CAaxG;AAWD,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,OAAO,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,mBAAmB,EAAE,OAAO,CAAC;IAC7B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,KAAK,CAAC,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,aAAa;IAC5B,4CAA4C;IAC5C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,sEAAsE;IACtE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC,CA0OvB;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAI9B"}

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

@@ -0,0 +1,515 @@
+// ============================================================================
+// src/lib/loadCarrierPlanning.server.ts — orkestratie van de beladingindeling
+// ============================================================================
+// Leest orders, orderregels, ladingdragertypen en instellingen uit de database,
+// draait de pure planner per ladingdragertype en schrijft het resultaat weg
+// naar order_carts / order_cart_items.
+// ============================================================================
+import { supabaseAdmin } from "../integrations/supabase/client.server";
+import { planLoadUnits, LOAD_CARRIER_PLANNER_VERSION, } from "./loadCarrierPlanner";
+import { fallbackCarrierProfile } from "./loadCarrierTypes";
+const db = () => supabaseAdmin;
+// ---------------------------------------------------------------------------
+// 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 };
+}
+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(orderId) {
+    const { data: order } = await db()
+        .from("orders")
+        .select("id, customer_id, delivery_date, custom_fields, buffer_id")
+        .eq("id", orderId)
+        .maybeSingle();
+    if (!order)
+        return null;
+    const { data: settings } = await db()
+        .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 db()
+            .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 db()
+        .from("order_buffers")
+        .select("id")
+        .eq("buffer_key", key)
+        .maybeSingle();
+    if (existing?.id) {
+        bufferId = existing.id;
+    }
+    else {
+        const { data: inserted, error } = await db()
+            .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 db()
+                .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 db().from("orders").update({ buffer_id: bufferId }).eq("id", orderId);
+    }
+    return bufferId;
+}
+function isDefaultBelading(b) {
+    return b.plants_per_crate === 1 && b.crates_per_layer === 1 && b.layers_per_cart === 1;
+}
+export async function expandOrderItemsForPlanner(rows) {
+    const out = [];
+    const groupIds = rows
+        .map((r) => r.product_id)
+        .filter((id) => typeof id === "string" && UUID_RE.test(id));
+    let groupSet = new Set();
+    if (groupIds.length > 0) {
+        const { data: groups } = await db().from("product_groups").select("id").in("id", groupIds);
+        groupSet = new Set((groups ?? []).map((g) => g.id));
+    }
+    for (const row of rows) {
+        const base = {
+            plants_per_crate: Math.max(1, Number(row.plants_per_crate ?? row.products?.plants_per_crate ?? 1)),
+            crates_per_layer: Math.max(1, Number(row.crates_per_layer ?? row.products?.crates_per_layer ?? 1)),
+            layers_per_cart: Math.max(1, Number(row.layers_per_cart ?? row.products?.layers_per_cart ?? 1)),
+        };
+        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]");
+        if (!isGroup) {
+            out.push({
+                order_item_id: row.id,
+                order_id: row.order_id ?? null,
+                customer_id: row.customer_id ?? null,
+                product_id: row.product_id ?? null,
+                product_name: row.product_name ?? "Onbekend",
+                plants,
+                ...base,
+                weight_per_crate: row.products?.weight != null ? Number(row.products.weight) : null,
+            });
+            continue;
+        }
+        const { data: members } = await db()
+            .from("product_group_items")
+            .select("trade_item_id, quantity, sort_order")
+            .eq("product_group_id", row.product_id)
+            .order("sort_order", { ascending: true });
+        const memberList = Array.isArray(members) ? members : [];
+        if (memberList.length === 0) {
+            out.push({
+                order_item_id: row.id,
+                order_id: row.order_id ?? null,
+                customer_id: row.customer_id ?? null,
+                product_id: row.product_id ?? null,
+                product_name: row.product_name ?? "Onbekend",
+                plants,
+                ...base,
+                weight_per_crate: null,
+            });
+            continue;
+        }
+        const tradeIds = memberList.map((m) => String(m.trade_item_id));
+        const { data: prods } = await db()
+            .from("products")
+            .select("id, product, plants_per_crate, crates_per_layer, layers_per_cart, weight, floriday_trade_item_id")
+            .or(tradeIds.map((t) => `floriday_trade_item_id.eq.${t}`).join(","));
+        const prodByTrade = new Map();
+        for (const p of prods ?? []) {
+            if (p.floriday_trade_item_id)
+                prodByTrade.set(String(p.floriday_trade_item_id), p);
+            prodByTrade.set(String(p.id), p);
+        }
+        const resolved = memberList.map((m) => {
+            const p = prodByTrade.get(String(m.trade_item_id));
+            const belading = p
+                ? {
+                    plants_per_crate: Math.max(1, Number(p.plants_per_crate ?? 1)),
+                    crates_per_layer: Math.max(1, Number(p.crates_per_layer ?? 1)),
+                    layers_per_cart: Math.max(1, Number(p.layers_per_cart ?? 1)),
+                }
+                : { plants_per_crate: 1, crates_per_layer: 1, layers_per_cart: 1 };
+            return { m, p, belading };
+        });
+        // Fallback: sibling met bekende belading, anders de groepsregel zelf.
+        const known = resolved.find((r) => !isDefaultBelading(r.belading))?.belading;
+        for (const r of resolved) {
+            if (isDefaultBelading(r.belading)) {
+                r.belading = known ?? (isDefaultBelading(base) ? r.belading : base);
+            }
+        }
+        const weightSum = resolved.reduce((s, r) => s + Number(r.m.quantity ?? 1), 0) || resolved.length;
+        const shares = [];
+        let assigned = 0;
+        for (const r of resolved) {
+            const raw = (plants * Number(r.m.quantity ?? 1)) / weightSum;
+            const ppc = r.belading.plants_per_crate;
+            const crates = Math.max(0, Math.round(raw / ppc));
+            shares.push(crates * ppc);
+            assigned += crates * ppc;
+        }
+        if (assigned !== plants && resolved.length > 0) {
+            const firstPpc = resolved[0].belading.plants_per_crate;
+            const deltaCrates = Math.round((plants - assigned) / firstPpc);
+            shares[0] = Math.max(0, shares[0] + deltaCrates * firstPpc);
+        }
+        resolved.forEach((r, idx) => {
+            if (shares[idx] <= 0)
+                return;
+            out.push({
+                order_item_id: `${row.id}::${r.m.trade_item_id}`,
+                order_id: row.order_id ?? null,
+                customer_id: row.customer_id ?? null,
+                product_id: r.p?.id ?? null,
+                product_name: `${row.product_name ?? "Groep"} — ${r.p?.product ?? r.m.trade_item_id}`,
+                plants: shares[idx],
+                ...r.belading,
+                weight_per_crate: r.p?.weight != null ? Number(r.p.weight) : null,
+            });
+        });
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Ladingdragertypen
+// ---------------------------------------------------------------------------
+export async function loadCarrierProfiles() {
+    const { data } = await db()
+        .from("load_carrier_types")
+        .select("*")
+        .eq("is_active", true)
+        .order("sort_order", { ascending: true });
+    return Array.isArray(data) ? data : [];
+}
+function profileFor(profiles, code) {
+    return profiles.find((p) => p.code === code) ?? fallbackCarrierProfile(code);
+}
+const numOrNull = (v) => {
+    const n = typeof v === "string" ? Number(v) : v;
+    return Number.isFinite(n) && n > 0 ? Math.round(n) : null;
+};
+/** Leest de actieve werkwijze en vertaalt "2. Beladingindeling" naar plannergrenzen. */
+export async function loadBeladingRules() {
+    const { data } = await db()
+        .from("logistics_rule_configs")
+        .select("settings")
+        .eq("is_active", true)
+        .order("updated_at", { ascending: false })
+        .limit(1);
+    const settings = Array.isArray(data) && data.length > 0 ? data[0]?.settings : null;
+    // De wizard bewaart de waarden onder `fields`; oudere configuraties platter.
+    const k = settings?.karrenindeling?.fields ?? settings?.karrenindeling;
+    if (!k || typeof k !== "object")
+        return null;
+    if (k.mode && k.mode !== "auto")
+        return null;
+    return {
+        maxOrders: k.multi_order === false ? 1 : k.fill_orders_as_much_as_fits ? null : numOrNull(k.max_orders),
+        maxCustomers: k.fill_customers_as_much_as_fits ? null : numOrNull(k.max_customers),
+        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,
+    };
+}
+/** Past de grenzen uit de werkwijze toe op het capaciteitsprofiel van een ladingdrager. */
+export function applyRulesToProfile(profile, rules) {
+    if (!rules)
+        return profile;
+    return {
+        ...profile,
+        layers_per_carrier: rules.maxLayers != null
+            ? Math.max(1, Math.min(profile.layers_per_carrier || 1, rules.maxLayers))
+            : profile.layers_per_carrier,
+        max_boxes: rules.maxBoxes != null
+            ? Math.min(profile.max_boxes ?? Number.MAX_SAFE_INTEGER, rules.maxBoxes)
+            : profile.max_boxes ?? null,
+    };
+}
+// ---------------------------------------------------------------------------
+// Herplannen van een buffer
+// ---------------------------------------------------------------------------
+/** Maximaal aantal ladingdragers dat één orderbuffer mag opleveren. */
+const MAX_CARTS_PER_BUFFER = 500;
+export async function replanBufferInternal(bufferId, options = {}) {
+    const warnings = [];
+    const { data: orders } = await db()
+        .from("orders")
+        .select("id, customer_id, custom_fields, plan_locked_at")
+        .eq("buffer_id", bufferId)
+        .is("deleted_at", null);
+    const orderRows = Array.isArray(orders) ? orders : [];
+    const orderIds = orderRows.map((o) => o.id);
+    if (orderRows.some((o) => o.plan_locked_at)) {
+        return {
+            ok: true,
+            bufferId,
+            orderIds,
+            cartsCreated: 0,
+            replacedManualCount: 0,
+            usedFloridayPacking: false,
+            warnings: ["plan_locked"],
+            skipped: "locked",
+        };
+    }
+    const idList = orderIds.length > 0 ? orderIds : ["00000000-0000-0000-0000-000000000000"];
+    const { data: items } = await db()
+        .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)")
+        .in("order_id", idList);
+    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,
+    }));
+    const inputs = await expandOrderItemsForPlanner(rawRows);
+    const itemToOrder = new Map();
+    for (const i of inputs)
+        if (i.order_id)
+            itemToOrder.set(i.order_item_id, i.order_id);
+    // Bestaande beladingen tellen en wissen.
+    const { data: existingCarts } = await db()
+        .from("order_carts")
+        .select("id, source")
+        .eq("buffer_id", bufferId);
+    const replacedManualCount = (existingCarts ?? []).filter((c) => c.source === "manual").length;
+    // Instellingen + never-mix.
+    const { data: settings } = await db().from("cart_planning_settings").select("*").eq("id", 1).maybeSingle();
+    const { data: overrides } = await db()
+        .from("cart_planning_product_overrides")
+        .select("product_id, never_mix");
+    const neverMix = new Set((overrides ?? []).filter((o) => o.never_mix && o.product_id).map((o) => String(o.product_id)));
+    const profiles = await loadCarrierProfiles();
+    const rules = await loadBeladingRules();
+    const defaultProfile = profiles.find((p) => p.is_default) ?? profileFor(profiles, "trolley");
+    let plannedCarts = [];
+    let usedFloridayPacking = false;
+    const solo = orderRows.length === 1 ? orderRows[0] : null;
+    const floridayPacking = solo?.custom_fields?.floriday_packing ?? null;
+    const isFo = solo && (solo.custom_fields?.source === "floriday" || floridayPacking?.pieces_per_package);
+    if (isFo && floridayPacking && Array.isArray(floridayPacking.carts)) {
+        usedFloridayPacking = true;
+        const code = options.carrierType ?? floridayPacking.carrier_type ?? defaultProfile.code;
+        const profile = profileFor(profiles, code);
+        plannedCarts = floridayPacking.carts.map((c, idx) => ({
+            cart_number: idx + 1,
+            carrier_type: profile.code,
+            carrier_type_id: profile.id ?? null,
+            source: "auto",
+            is_complete: Boolean(c.is_complete),
+            occupancy_pct: Number(c.occupancy_pct ?? 100),
+            total_layers_used: Number(c.total_layers_used ?? profile.layers_per_carrier),
+            max_layers: profile.layers_per_carrier,
+            weight_kg: null,
+            items: Array.isArray(c.items) ? c.items : [],
+        }));
+    }
+    else {
+        // Ladingdrager per orderregel bepalen en per type een ronde draaien.
+        const groups = new Map();
+        for (const input of inputs) {
+            const code = options.carrierType ?? defaultProfile.code;
+            const list = groups.get(code) ?? [];
+            list.push(input);
+            groups.set(code, list);
+        }
+        for (const [code, list] of groups) {
+            const profile = applyRulesToProfile(profileFor(profiles, code), rules);
+            const result = planLoadUnits(list, {
+                carrier: profile,
+                maxPartySharePerLayerPct: settings?.max_party_share_per_layer_pct ?? 50,
+                // 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,
+                oneCustomerPerLayer: Boolean(settings?.max_one_customer_per_layer),
+                ownCarrierFromLayers: settings?.own_cart_from_layers ?? null,
+                sortOrder: "none",
+            });
+            plannedCarts = plannedCarts.concat(result.carts);
+            warnings.push(...result.warnings);
+        }
+        plannedCarts.forEach((c, idx) => {
+            c.cart_number = idx + 1;
+        });
+    }
+    // Veiligheidsgrens: een onrealistisch grote order (bijv. een verkeerd
+    // ingevoerd aantal planten) mag de indeling niet laten vastlopen.
+    if (plannedCarts.length > MAX_CARTS_PER_BUFFER) {
+        warnings.push(`Deze orderbuffer levert ${plannedCarts.length} ladingdragers op. Er zijn er ${MAX_CARTS_PER_BUFFER} ingedeeld; controleer de aantallen of de belading van de producten.`);
+        plannedCarts = plannedCarts.slice(0, MAX_CARTS_PER_BUFFER);
+    }
+    if (options.dryRun) {
+        return {
+            ok: true,
+            bufferId,
+            orderIds,
+            cartsCreated: plannedCarts.length,
+            replacedManualCount,
+            usedFloridayPacking,
+            warnings,
+            carts: plannedCarts,
+        };
+    }
+    await db().from("order_carts").delete().eq("buffer_id", bufferId);
+    // 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);
+            }
+            return {
+                order_id: orderIdsOnCart.size === 1 ? [...orderIdsOnCart][0] : null,
+                buffer_id: bufferId,
+                cart_number: cart.cart_number,
+                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: LOAD_CARRIER_PLANNER_VERSION,
+            };
+        });
+        const { data: insertedCarts, error } = await db()
+            .from("order_carts")
+            .insert(cartRows)
+            .select("id, cart_number");
+        if (error || !Array.isArray(insertedCarts)) {
+            warnings.push(`Een deel van de ladingdragers kon niet worden opgeslagen: ${error?.message ?? ""}`);
+            continue;
+        }
+        created += insertedCarts.length;
+        const idByNumber = new Map(insertedCarts.map((c) => [Number(c.cart_number), String(c.id)]));
+        const itemRows = [];
+        for (const cart of chunk) {
+            const cartId = idByNumber.get(cart.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.max(1, 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,
+                });
+            }
+        }
+        for (let s = 0; s < itemRows.length; s += 500) {
+            const slice = itemRows.slice(s, s + 500);
+            if (slice.length > 0)
+                await db().from("order_cart_items").insert(slice);
+        }
+    }
+    return {
+        ok: true,
+        bufferId,
+        orderIds,
+        cartsCreated: created,
+        replacedManualCount,
+        usedFloridayPacking,
+        warnings,
+        carts: plannedCarts,
+    };
+}
+export async function replanOrderInternal(orderId, options = {}) {
+    const bufferId = await resolveBufferForOrderInternal(orderId);
+    if (!bufferId)
+        return null;
+    return replanBufferInternal(bufferId, options);
+}

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

@@ -0,0 +1,3 @@
+import type { ReplanResult } from "./loadCarrierPlanning.server";
+export declare function attachIndelingToTasks(result: ReplanResult | null): Promise<number>;
+//# sourceMappingURL=loadCarrierTaskSync.server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loadCarrierTaskSync.server.d.ts","sourceRoot":"","sources":["../../src/lib/loadCarrierTaskSync.server.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAKjE,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CA6CxF"}