@flowselections/logistiek-engine 1.0.175 → 1.0.180

package/db/schema/logistiek-engine.sql

@@ -28261,3 +28261,2115 @@ ON CONFLICT (key) DO NOTHING;
 
 RESET check_function_bodies;
 
+
+-- ===== 1.0.176 automatische documentkeuze (idempotent: CREATE OR REPLACE / IF NOT EXISTS) =====
+-- Logistiek Engine 1.0.176: automatische documentkeuze.
+-- De gebruiker kiest nergens meer een layout. Eén centrale beslisregel:
+-- logistics_document_for_order(order, documenttype). Bestaat Layouts'
+-- layout_voor_document, dan alleen die; anders de automatische standaardlayout.
+-- Oude werkwijze-keuzes (packing_slip_layout e.d.) blijven staan maar worden genegeerd.
+-- Geen omgevingswaarden, geen datacorrectie.
+
+-- 1. Eigen stickers in dezelfde wachtrij als de Floriday-stickers.
+ALTER TABLE public.logistics_sticker_prints ADD COLUMN IF NOT EXISTS eigen_sticker_id uuid;
+ALTER TABLE public.logistics_sticker_prints DROP CONSTRAINT IF EXISTS logistics_sticker_prints_soort_check;
+ALTER TABLE public.logistics_sticker_prints ADD CONSTRAINT logistics_sticker_prints_soort_check
+  CHECK (soort = ANY (ARRAY['sticker'::text, 'traysticker'::text, 'eigen_sticker'::text]));
+
+-- 2. Automatische keuze zonder werkwijze-overrides.
+CREATE OR REPLACE FUNCTION public.logistics_document_layout_v2(_document_code text, _is_partial boolean DEFAULT false)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_types public.doc_layout_type[];
+  v_layout public.document_layouts%ROWTYPE;
+BEGIN
+  v_types := public.logistics_document_type_map(lower(btrim(coalesce(_document_code, ''))));
+  IF array_length(v_types, 1) IS NULL THEN RETURN NULL; END IF;
+  SELECT * INTO v_layout
+    FROM public.document_layouts
+   WHERE actief IS TRUE AND documenttype = ANY (v_types)
+   ORDER BY array_position(v_types, documenttype),
+            (coalesce(bron, 'eigen') = 'eigen') DESC,
+            is_standaard DESC NULLS LAST, updated_at DESC
+   LIMIT 1;
+  IF v_layout.id IS NULL THEN RETURN NULL; END IF;
+  RETURN jsonb_build_object(
+    'layoutId', v_layout.id, 'layoutName', v_layout.naam, 'layoutVersion', v_layout.huidige_versie,
+    'layoutDocumentType', v_layout.documenttype::text, 'layoutSettingKey', NULL,
+    'layoutVariant', CASE WHEN COALESCE(_is_partial, false) THEN 'partial_order' ELSE 'full_cart' END,
+    'layoutFallbackUsed', false,
+    'layout_id', v_layout.id, 'layout_name', v_layout.naam, 'layout_version', v_layout.huidige_versie,
+    'layout_document_type', v_layout.documenttype::text, 'layout_setting_key', NULL,
+    'layout_variant', CASE WHEN COALESCE(_is_partial, false) THEN 'partial_order' ELSE 'full_cart' END,
+    'layout_fallback_used', false);
+END;
+$function$;
+
+-- 3. Is Layouts al bijgewerkt?
+CREATE OR REPLACE FUNCTION public.logistics_document_selection_status()
+ RETURNS jsonb
+ LANGUAGE sql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+  SELECT CASE WHEN to_regprocedure('public.layout_voor_document(uuid,text)') IS NOT NULL
+    THEN jsonb_build_object('layouts_bijgewerkt', true, 'melding', 'Het document wordt automatisch bepaald uit de order (Layouts).')
+    ELSE jsonb_build_object('layouts_bijgewerkt', false, 'melding', 'Layouts is nog niet bijgewerkt – automatische keuze gebruikt')
+  END;
+$function$;
+
+-- 4. Centrale beslisregel.
+CREATE OR REPLACE FUNCTION public.logistics_document_for_order(p_order_id uuid, p_documenttype text)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_soort text := lower(btrim(coalesce(p_documenttype, '')));
+  v_floriday boolean;
+  v_bron text;
+  v_type text;
+  v_res jsonb;
+  v_n int; v_std int; v_id uuid;
+  v_l public.document_layouts%ROWTYPE;
+BEGIN
+  IF v_soort = '' THEN
+    RETURN jsonb_build_object('ok', false, 'layout_id', NULL, 'reden', 'Geen documentsoort opgegeven.');
+  END IF;
+
+  IF to_regprocedure('public.layout_voor_document(uuid,text)') IS NOT NULL THEN
+    EXECUTE 'SELECT to_jsonb(public.layout_voor_document($1, $2))' INTO v_res USING p_order_id, v_soort;
+    IF jsonb_typeof(v_res) <> 'object' THEN
+      RETURN jsonb_build_object('ok', false, 'layout_id', NULL, 'keuze', 'layouts',
+        'reden', 'Layouts gaf geen bruikbaar antwoord voor ' || v_soort || '.');
+    END IF;
+    RETURN v_res || jsonb_build_object('keuze', 'layouts',
+      'ok', coalesce((v_res->>'ok')::boolean, nullif(v_res->>'layout_id', '') IS NOT NULL));
+  END IF;
+
+  -- Automatische keuze (Layouts nog niet bijgewerkt).
+  SELECT o.order_source = 'floriday' INTO v_floriday FROM public.orders o WHERE o.id = p_order_id;
+  IF v_floriday IS NULL THEN
+    RETURN jsonb_build_object('ok', false, 'layout_id', NULL, 'keuze', 'automatisch', 'reden', 'Order niet gevonden.');
+  END IF;
+
+  v_type := CASE
+    WHEN v_soort IN ('eigen_sticker', 'sticker', 'etiket') THEN 'sticker'
+    WHEN v_soort IN ('verzenddocument', 'verzendbrief', 'afleverbrief', 'afleverbon') THEN 'afleverbrief'
+    WHEN v_soort IN ('veilingbrief', 'veilingbon') THEN 'veilingbrief'
+    WHEN v_soort LIKE '%pakbon%' THEN 'pakbon'
+    WHEN v_soort LIKE '%productie%' THEN 'productiebon'
+    ELSE v_soort END;
+  v_bron := CASE
+    WHEN v_floriday AND v_soort <> 'eigen_sticker' AND v_type IN ('sticker', 'traysticker', 'afleverbrief', 'veilingbrief') THEN 'floriday'
+    ELSE 'eigen' END;
+  IF v_bron = 'eigen' AND v_type = 'veilingbrief' THEN
+    RETURN jsonb_build_object('ok', false, 'layout_id', NULL, 'keuze', 'automatisch',
+      'reden', 'Een veilingbrief hoort alleen bij een Floriday-order; voor een eigen order wordt de afleverbrief gebruikt.');
+  END IF;
+
+  SELECT count(*), count(*) FILTER (WHERE is_standaard IS TRUE) INTO v_n, v_std
+    FROM public.document_layouts
+   WHERE actief IS TRUE AND coalesce(bron, 'eigen') = v_bron AND documenttype::text = v_type;
+  IF v_n = 1 THEN
+    SELECT * INTO v_l FROM public.document_layouts
+     WHERE actief IS TRUE AND coalesce(bron, 'eigen') = v_bron AND documenttype::text = v_type;
+  ELSIF v_n > 1 THEN
+    SELECT * INTO v_l FROM public.document_layouts
+     WHERE actief IS TRUE AND coalesce(bron, 'eigen') = v_bron AND documenttype::text = v_type
+     ORDER BY is_standaard DESC NULLS LAST, updated_at DESC LIMIT 1;
+  END IF;
+  IF v_l.id IS NULL THEN
+    RETURN jsonb_build_object('ok', false, 'layout_id', NULL, 'keuze', 'automatisch', 'bron', v_bron, 'documenttype', v_type,
+      'reden', CASE WHEN v_bron = 'floriday'
+        THEN 'Geen actieve ' || v_type || '-layout met bron Floriday. Activeer de Floriday-systeemlayout in Layouts en printers.'
+        ELSE 'Maak of activeer een ' || v_type || 'layout in Layouts en printers.' END);
+  END IF;
+  RETURN jsonb_build_object('ok', true, 'layout_id', v_l.id, 'keuze', 'automatisch', 'bron', v_bron,
+    'documenttype', v_type, 'breedte_mm', v_l.breedte_mm, 'hoogte_mm', v_l.hoogte_mm, 'reden', NULL);
+END;
+$function$;
+
+-- 5. Eigen stickers (HO/MO/AO): één per klant+product, aantal = planten van regels met needs_sticker.
+CREATE OR REPLACE FUNCTION public.logistics_own_sticker_count(p_unit text, p_quantity numeric, p_ppc_regel numeric, p_ppc_product numeric)
+RETURNS integer LANGUAGE sql IMMUTABLE SET search_path = public AS $cnt$
+  -- stuks/planten = aantal planten; fust = aantal x planten per fust (regel, anders product); onbekend = NULL (tegenhouden).
+  SELECT CASE
+    WHEN p_quantity IS NULL THEN NULL
+    WHEN lower(coalesce(p_unit, '')) = 'fust' THEN
+      CASE WHEN coalesce(nullif(p_ppc_regel, 0), nullif(p_ppc_product, 0)) IS NULL THEN NULL
+           ELSE (p_quantity * coalesce(nullif(p_ppc_regel, 0), nullif(p_ppc_product, 0)))::int END
+    ELSE p_quantity::int
+  END
+$cnt$;
+
+CREATE OR REPLACE FUNCTION public.logistics_own_sticker_sync(p_limit integer DEFAULT 200)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  r record;
+  v_bron text;
+  v_n int;
+  v_sticker uuid;
+  v_status text;
+  v_reden text;
+  v_bijgewerkt int := 0;
+  v_vrij int := 0;
+  v_uit int := 0;
+BEGIN
+  FOR r IN
+    SELECT o.id AS order_id, o.order_number, o.customer_id, oi.product_id,
+           sum(public.logistics_own_sticker_count(oi.unit, oi.quantity, oi.plants_per_crate, prd.plants_per_crate))::int AS planten,
+           bool_or(public.logistics_own_sticker_count(oi.unit, oi.quantity, oi.plants_per_crate, prd.plants_per_crate) IS NULL) AS onbekend
+      FROM public.orders o
+      JOIN public.order_items oi ON oi.order_id = o.id
+      LEFT JOIN public.products prd ON prd.id = oi.product_id
+     WHERE oi.needs_sticker IS TRUE
+       AND oi.quarantined_at IS NULL
+       AND oi.product_id IS NOT NULL
+       AND coalesce(o.order_source, '') <> 'floriday'
+       AND o.deleted_at IS NULL AND o.cancelled_at IS NULL
+       AND coalesce(o.status, '') <> 'geannuleerd'
+       AND o.delivery_date >= current_date - 1
+     GROUP BY o.id, o.order_number, o.customer_id, oi.product_id
+     LIMIT greatest(1, p_limit)
+  LOOP
+    v_bron := r.order_id::text || ':' || r.product_id::text;
+    SELECT count(*), (array_agg(s.id))[1] INTO v_n, v_sticker
+      FROM public.customer_product_stickers s
+      JOIN public.customers c ON c.id = r.customer_id
+     WHERE s.trade_item_key = r.product_id::text
+       AND s.customer_key IN (c.id::text, 'tf:' || coalesce(c.twinfield_code, '-'), 'cn:' || coalesce(c.customer_number, '-'));
+    v_status := 'wacht_op_moment'; v_reden := NULL;
+    IF r.onbekend THEN
+      v_status := 'geblokkeerd'; v_reden := 'Aantal stickers onbekend: regel in fust zonder planten per fust (niet op de regel en niet bij het product). Vul planten per fust in.';
+    ELSIF coalesce(r.planten, 0) < 1 THEN
+      v_status := 'geblokkeerd'; v_reden := 'Aantal planten is 0; geen sticker te printen.';
+    ELSIF v_n = 0 THEN
+      v_status := 'geblokkeerd'; v_reden := 'Geen eigen sticker gevonden voor deze klant en dit product. Voeg hem toe bij de klant.';
+    ELSIF v_n > 1 THEN
+      v_status := 'geblokkeerd'; v_reden := 'Meer dan één eigen sticker voor deze klant en dit product; er mag er maar één zijn.';
+    END IF;
+
+    UPDATE public.logistics_sticker_prints
+       SET kopieen = greatest(coalesce(r.planten, 0), 1),
+           eigen_sticker_id = CASE WHEN v_n = 1 THEN v_sticker ELSE NULL END,
+           status = CASE WHEN status = 'geblokkeerd' AND v_status = 'wacht_op_moment' THEN 'wacht_op_moment'
+                         WHEN status = 'niet_printen' THEN v_status
+                         WHEN status = 'wacht_op_moment' THEN v_status ELSE status END,
+           reden = CASE WHEN status IN ('wacht_op_moment', 'geblokkeerd', 'niet_printen') THEN v_reden ELSE reden END,
+           updated_at = now()
+     WHERE soort = 'eigen_sticker' AND bron_id = v_bron
+       AND status IN ('wacht_op_moment', 'geblokkeerd', 'niet_printen');
+    IF NOT FOUND AND NOT EXISTS (SELECT 1 FROM public.logistics_sticker_prints WHERE soort = 'eigen_sticker' AND bron_id = v_bron) THEN
+      INSERT INTO public.logistics_sticker_prints (soort, bron_id, order_id, order_number, kopieen, status, reden, eigen_sticker_id)
+      VALUES ('eigen_sticker', v_bron, r.order_id, r.order_number, greatest(coalesce(r.planten, 0), 1), v_status, v_reden,
+              CASE WHEN v_n = 1 THEN v_sticker ELSE NULL END);
+    END IF;
+    v_bijgewerkt := v_bijgewerkt + 1;
+  END LOOP;
+
+  -- Vinkje uitgezet (of order vervallen) vóór het printen: niet printen.
+  UPDATE public.logistics_sticker_prints p
+     SET status = 'niet_printen', reden = 'Sticker uitgezet op de orderregel of order vervallen.', updated_at = now()
+   WHERE p.soort = 'eigen_sticker' AND p.status IN ('wacht_op_moment', 'geblokkeerd', 'klaar')
+     AND NOT EXISTS (
+       SELECT 1 FROM public.order_items oi JOIN public.orders o ON o.id = oi.order_id
+        WHERE oi.order_id = p.order_id AND p.bron_id = oi.order_id::text || ':' || oi.product_id::text
+          AND oi.needs_sticker IS TRUE AND oi.quarantined_at IS NULL
+          AND o.deleted_at IS NULL AND o.cancelled_at IS NULL AND coalesce(o.status, '') <> 'geannuleerd');
+  GET DIAGNOSTICS v_uit = ROW_COUNT;
+
+  -- Vrijgeven met de pakbon: kar en printplek van de geprinte pakbonrij, formaat uit sticker of layout.
+  WITH vrij AS (
+    SELECT p.id,
+           (SELECT public.logistics_try_uuid(q.payload->>'cartId')
+              FROM public.pick_queue q
+             WHERE q.cancelled_at IS NULL AND q.print_job_id IS NOT NULL
+               AND (q.payload->>'orderId' = p.order_id::text OR q.payload->'orderIds' ? p.order_id::text)
+             ORDER BY q.created_at LIMIT 1) AS kar,
+           (SELECT k.print_plek_id::text
+              FROM public.pick_queue q
+              JOIN public.print_plek_koppelingen k ON k.bron IN ('pickstation', 'pick_station') AND k.bron_id = q.station_id::text
+             WHERE q.cancelled_at IS NULL AND q.print_job_id IS NOT NULL
+               AND (q.payload->>'orderId' = p.order_id::text OR q.payload->'orderIds' ? p.order_id::text)
+             ORDER BY q.created_at, k.created_at LIMIT 1) AS plek,
+           s.width_mm, s.height_mm,
+           public.logistics_document_for_order(p.order_id, 'eigen_sticker') AS lay
+      FROM public.logistics_sticker_prints p
+      LEFT JOIN public.customer_product_stickers s ON s.id = p.eigen_sticker_id
+     WHERE p.soort = 'eigen_sticker' AND p.status = 'wacht_op_moment'
+       AND EXISTS (SELECT 1 FROM public.pick_queue q
+                    WHERE q.cancelled_at IS NULL AND q.print_job_id IS NOT NULL
+                      AND (q.payload->>'orderId' = p.order_id::text OR q.payload->'orderIds' ? p.order_id::text))
+  )
+  UPDATE public.logistics_sticker_prints p
+     SET status = 'klaar', cart_id = vrij.kar, print_plek_id = vrij.plek,
+         breedte_mm = coalesce(vrij.width_mm, (vrij.lay->>'breedte_mm')::numeric),
+         hoogte_mm = coalesce(vrij.height_mm, (vrij.lay->>'hoogte_mm')::numeric),
+         updated_at = now()
+    FROM vrij
+   WHERE p.id = vrij.id;
+  GET DIAGNOSTICS v_vrij = ROW_COUNT;
+
+  RETURN jsonb_build_object('regels', v_bijgewerkt, 'vrijgegeven', v_vrij, 'niet_printen', v_uit);
+END;
+$function$;
+
+-- 6. Pakbon van het pickstation: alleen de centrale beslisregel (geen layout uit payload of werkwijze).
+CREATE OR REPLACE FUNCTION public.pick_enqueue_print_job(_queue_item_id uuid, _printer_id uuid, _session_id text, _is_herprint boolean, _cart_id text)
+ RETURNS uuid
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  item public.pick_queue;
+  dt public.pick_document_types;
+  doc_code text;
+  target_printer uuid;
+  target_layout uuid;
+  target_plek uuid;
+  layout_meta jsonb;
+  layout_reden text;
+  v_types public.doc_layout_type[];
+  doc_type public.doc_layout_type := 'vrij';
+  layout_type public.doc_layout_type;
+  pdf_url text;
+  pdf_b64 text;
+  herkomst text;
+  job_id uuid;
+  cart_plan jsonb := NULL;
+  selected_cart jsonb := NULL;
+  v_cart_uuid uuid;
+  v_barcode text;
+  v_barcode_on boolean := public.logistics_pick_barcode_enabled();
+  v_is_partial boolean := false;
+  v_sleutel text;
+  v_order uuid;
+BEGIN
+  SELECT * INTO item FROM public.pick_queue WHERE id = _queue_item_id;
+  IF NOT FOUND THEN RAISE EXCEPTION 'Dit document bestaat niet meer.'; END IF;
+
+  SELECT * INTO dt FROM public.pick_document_types WHERE id = item.document_type_id;
+
+  doc_code := lower(btrim(coalesce(
+    nullif(item.payload->>'documentType', ''),
+    nullif(dt.code, ''),
+    ''
+  )));
+
+  v_types := public.logistics_document_type_map(doc_code);
+
+  IF _cart_id IS NOT NULL THEN
+    cart_plan := public.pick_queue_cart_plan(_queue_item_id);
+    SELECT c INTO selected_cart
+      FROM jsonb_array_elements(COALESCE(cart_plan->'carts', '[]'::jsonb)) AS c
+     WHERE c->>'cartId' = _cart_id
+     LIMIT 1;
+
+    IF selected_cart IS NULL THEN
+      RAISE EXCEPTION 'De gekozen kar bestaat niet meer in het actuele karplan.';
+    END IF;
+
+    v_is_partial := NOT COALESCE((selected_cart->>'isFullCart')::boolean, false);
+
+    IF v_barcode_on THEN
+      BEGIN
+        v_cart_uuid := nullif(_cart_id, '')::uuid;
+      EXCEPTION WHEN invalid_text_representation THEN
+        v_cart_uuid := NULL;
+      END;
+      IF v_cart_uuid IS NOT NULL THEN
+        v_barcode := public.logistics_ensure_cart_barcode(v_cart_uuid);
+        selected_cart := selected_cart || jsonb_build_object('barcode', v_barcode);
+      END IF;
+    END IF;
+  END IF;
+
+  -- 1.0.176: het document wordt automatisch bepaald uit de order.
+  v_order := public.logistics_try_uuid(COALESCE(selected_cart->>'orderId', item.payload->>'orderId', item.payload->>'order_id'));
+  IF doc_code <> '' AND v_order IS NOT NULL THEN
+    layout_meta := public.logistics_document_for_order(v_order, doc_code);
+    target_layout := public.logistics_try_uuid(layout_meta->>'layout_id');
+    layout_reden := nullif(layout_meta->>'reden', '');
+  ELSIF doc_code <> '' THEN
+    layout_meta := public.logistics_document_layout_v2(doc_code, v_is_partial);
+    target_layout := public.logistics_try_uuid(layout_meta->>'layout_id');
+  END IF;
+
+  SELECT l.documenttype INTO layout_type
+    FROM public.document_layouts l
+   WHERE l.id = target_layout
+     AND l.actief IS TRUE;
+
+  IF layout_type IS NULL THEN
+    target_layout := NULL;
+  END IF;
+
+  doc_type := COALESCE(layout_type, v_types[1], 'vrij');
+
+  IF item.station_id IS NOT NULL THEN
+    SELECT k.print_plek_id INTO target_plek
+      FROM public.print_plek_koppelingen k
+     WHERE k.bron IN ('pickstation', 'pick_station')
+       AND k.bron_id = item.station_id::text
+     ORDER BY k.created_at
+     LIMIT 1;
+  END IF;
+
+  SELECT p.id INTO target_printer
+    FROM public.printers p
+   WHERE p.id = _printer_id
+     AND p.actief
+     AND nullif(p.extern_printer_id, '') IS NOT NULL;
+
+  pdf_url := nullif(item.payload->>'pdf_url', '');
+  pdf_b64 := nullif(item.payload->>'pdf_base64', '');
+  herkomst := nullif(item.payload->>'herkomst', '');
+
+  IF NOT COALESCE(_is_herprint, false) AND _cart_id IS NOT NULL THEN
+    v_sleutel := 'pakbon:' || item.id::text || ':' || _cart_id || ':'
+              || coalesce(target_layout::text, '-') || ':' || coalesce(target_printer::text, '-');
+  END IF;
+
+  INSERT INTO public.print_jobs(
+    printer_id, layout_id, documenttype, documentnaam, status, foutmelding,
+    payload, gebruiker_naam, pdf_url, pdf_base64, herkomst, is_herprint, idempotentie_sleutel
+  )
+  VALUES (
+    target_printer,
+    target_layout,
+    doc_type,
+    COALESCE(item.document_number, 'Pickdocument'),
+    'wachtend',
+    CASE
+      WHEN target_layout IS NULL AND pdf_url IS NULL AND pdf_b64 IS NULL
+        THEN COALESCE(layout_reden, 'Maak of activeer een ' || COALESCE(nullif(doc_code, ''), 'document') || 'layout in Layouts en printers.')
+      ELSE NULL
+    END,
+    jsonb_build_object(
+      'source', 'pickstation',
+      'queue_item_id', item.id,
+      'station_id', item.station_id,
+      'print_plek_id', target_plek,
+      'session_id', _session_id,
+      'is_herprint', COALESCE(_is_herprint, false),
+      'document_number', item.document_number,
+      'document_type_code', COALESCE(nullif(doc_code, ''), dt.code),
+      'report_key', dt.report_key,
+      'print_template', dt.print_template,
+      'order_number', COALESCE(selected_cart->>'orderNumber', item.order_number),
+      'customer_name', item.customer_name,
+      'reference', item.reference,
+      'layout_id', target_layout,
+      'layout_keuze', layout_meta->>'keuze',
+      'layout_variant', CASE WHEN v_is_partial THEN 'partial_order' ELSE 'full_cart' END,
+      'barcode', CASE WHEN v_barcode_on THEN COALESCE(v_barcode, item.barcode) ELSE item.barcode END,
+      'country_code', item.country_code,
+      'cart_id', _cart_id,
+      'cart', selected_cart,
+      'data', COALESCE(item.payload, '{}'::jsonb) || jsonb_build_object(
+        'print_plek_id', target_plek,
+        'cart_id', _cart_id,
+        'cart', selected_cart,
+        'orderId', COALESCE(selected_cart->>'orderId', item.payload->>'orderId'),
+        'orderNumber', COALESCE(selected_cart->>'orderNumber', item.order_number)
+      )
+    ),
+    'Pickstation',
+    pdf_url,
+    pdf_b64,
+    herkomst,
+    COALESCE(_is_herprint, false),
+    v_sleutel
+  )
+  RETURNING id INTO job_id;
+
+  PERFORM public.logistics_enqueue_sticker_with_slip(_queue_item_id, _printer_id, _session_id, COALESCE(_is_herprint,false), _cart_id, job_id);
+  UPDATE public.pick_queue SET print_job_id = job_id WHERE id = _queue_item_id;
+
+  RETURN job_id;
+END;
+$function$;
+
+REVOKE EXECUTE ON FUNCTION public.logistics_own_sticker_sync(integer) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_own_sticker_sync(integer) TO service_role;
+REVOKE EXECUTE ON FUNCTION public.logistics_document_for_order(uuid, text) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_document_for_order(uuid, text) TO authenticated, service_role;
+REVOKE EXECUTE ON FUNCTION public.logistics_document_selection_status() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_document_selection_status() TO authenticated, service_role;
+
+-- Veiligheid: draaien met de rechten van de aanroeper.
+ALTER FUNCTION public.logistics_document_selection_status() SECURITY INVOKER;
+ALTER FUNCTION public.logistics_document_for_order(uuid, text) SECURITY INVOKER;
+
+-- ===== 1.0.176 reserveringen FO + pakbon centrale keuze =====
+-- 1.0.176: reserveringen (Voorraad 1.0.93) en pakbon via centrale documentkeuze (Pickschermen 1.0.56).
+CREATE OR REPLACE FUNCTION public.logistics_recompute_reserved_targeted(p_product_id uuid)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_t0 timestamptz := clock_timestamp();
+  v_max_lines constant integer := 500;
+  v_max_keys constant integer := 200;
+  v_trace_ms constant numeric := 500;
+  v_nkeys integer; v_nkeys_prev integer := -1; v_nlines integer := 0; v_changed integer := 0; v_ms numeric;
+  oi_rec record; part record; member_rec record;
+  v_key text; v_last_key text; v_remaining numeric; v_available numeric; v_take numeric; v_err text;
+  v_skipped jsonb := '[]'::jsonb; v_skipped_qty numeric := 0;
+  v_struct jsonb := '[]'::jsonb; v_struct_qty numeric := 0;
+  v_freeze boolean := public.logistics_plan_setting('verdeling_bevriezen_actief', 0) = 1;
+  v_frozen_ids uuid[]; v_line_ids uuid[];
+BEGIN
+  IF p_product_id IS NULL THEN RETURN jsonb_build_object('status', 'geen_product'); END IF;
+  IF current_setting('app.recomputing_reserved', true) = 'on' THEN RETURN jsonb_build_object('status', 'al_bezig'); END IF;
+  PERFORM set_config('app.recomputing_reserved', 'on', true);
+
+  DROP TABLE IF EXISTS _rt_open;
+  DROP TABLE IF EXISTS _rt_pexp;
+  DROP TABLE IF EXISTS _rt_gm;
+  DROP TABLE IF EXISTS _rt_raw;
+  DROP TABLE IF EXISTS _rt_pkeys;
+  DROP TABLE IF EXISTS _rt_keys;
+  DROP TABLE IF EXISTS _rt_lines;
+  DROP TABLE IF EXISTS _rt_demand;
+  DROP TABLE IF EXISTS _rt_alloc;
+  DROP TABLE IF EXISTS _rt_frozen;
+  CREATE TEMP TABLE _rt_open (order_item_id uuid PRIMARY KEY, product_id uuid, qty numeric, created_at timestamptz, order_id uuid) ON COMMIT DROP;
+  CREATE TEMP TABLE _rt_pexp (product_id uuid, ord bigint, kind text, ref text, qty numeric, note text) ON COMMIT DROP;
+  CREATE TEMP TABLE _rt_gm (group_id uuid, raw_key text, canon_key text, ord bigint) ON COMMIT DROP;
+  CREATE TEMP TABLE _rt_raw (raw_key text PRIMARY KEY, canon_key text) ON COMMIT DROP;
+  CREATE TEMP TABLE _rt_pkeys (product_id uuid, canon_key text) ON COMMIT DROP;
+  CREATE TEMP TABLE _rt_keys (canon_key text PRIMARY KEY) ON COMMIT DROP;
+  CREATE TEMP TABLE _rt_lines (order_item_id uuid PRIMARY KEY) ON COMMIT DROP;
+  CREATE TEMP TABLE _rt_demand (trade_item_key text PRIMARY KEY, qty numeric NOT NULL DEFAULT 0) ON COMMIT DROP;
+  CREATE TEMP TABLE _rt_alloc (order_item_id uuid, trade_item_key text, qty numeric, source text, group_id uuid) ON COMMIT DROP;
+  CREATE TEMP TABLE _rt_frozen (order_item_id uuid PRIMARY KEY) ON COMMIT DROP;
+
+  INSERT INTO _rt_open
+  SELECT oi.id, oi.product_id, COALESCE(oi.quantity, 0)::numeric, o.created_at, oi.order_id
+    FROM logistics_active.order_items oi
+    JOIN public.orders o ON o.id = oi.order_id
+   WHERE o.status = 'Nog te picken' AND NOT public.logistics_reserved_order_excluded(o.id)
+     AND COALESCE(oi.quantity, 0) > 0
+     AND oi.product_id IS NOT NULL
+     AND NOT EXISTS (SELECT 1 FROM public.stock_mutation_log sml WHERE sml.order_item_id = oi.id AND sml.mutation_type = 'consumption');
+  -- Groepsregel naast eigen ledenregels: nooit reserveren.
+  DELETE FROM _rt_open o WHERE o.order_item_id IN (SELECT d.order_item_id FROM public.logistics_double_group_lines(NULL) d);
+
+  INSERT INTO _rt_pexp (product_id, ord, kind, ref, qty, note)
+  SELECT d.pid, e.ord, e.kind, e.ref, e.qty, e.note
+    FROM (SELECT DISTINCT product_id AS pid FROM _rt_open UNION SELECT p_product_id) d,
+         LATERAL public.logistics_expand_line(d.pid, 1) WITH ORDINALITY AS e(kind, ref, qty, note, ord);
+
+  INSERT INTO _rt_gm (group_id, raw_key, ord)
+  SELECT g.gid, m.raw_key, m.ord
+    FROM (SELECT DISTINCT ref::uuid AS gid FROM _rt_pexp WHERE kind = 'group') g,
+         LATERAL (
+           SELECT public.resolve_group_member_stock_key(pgi.trade_item_id) AS raw_key,
+                  row_number() OVER (ORDER BY pgi.sort_order ASC NULLS LAST, pgi.created_at ASC, pgi.id ASC) AS ord
+             FROM public.product_group_items pgi
+            WHERE pgi.product_group_id = g.gid) m
+   WHERE m.raw_key IS NOT NULL
+     AND m.raw_key NOT LIKE 'group:%';
+
+  INSERT INTO _rt_raw (raw_key, canon_key)
+  SELECT x.k, public.logistics_reserved_key(x.k)
+    FROM (SELECT ref AS k FROM _rt_pexp WHERE kind = 'item' UNION SELECT raw_key FROM _rt_gm) x;
+  UPDATE _rt_gm g SET canon_key = r.canon_key FROM _rt_raw r WHERE r.raw_key = g.raw_key;
+
+  INSERT INTO _rt_pkeys (product_id, canon_key)
+  SELECT DISTINCT e.product_id, r.canon_key
+    FROM _rt_pexp e JOIN _rt_raw r ON r.raw_key = e.ref
+   WHERE e.kind = 'item' AND r.canon_key IS NOT NULL
+  UNION
+  SELECT DISTINCT e.product_id, g.canon_key
+    FROM _rt_pexp e JOIN _rt_gm g ON g.group_id = e.ref::uuid
+   WHERE e.kind = 'group' AND g.canon_key IS NOT NULL;
+
+  INSERT INTO _rt_keys SELECT DISTINCT canon_key FROM _rt_pkeys WHERE product_id = p_product_id ON CONFLICT DO NOTHING;
+  LOOP
+    SELECT count(*) INTO v_nkeys FROM _rt_keys;
+    EXIT WHEN v_nkeys = v_nkeys_prev;
+    v_nkeys_prev := v_nkeys;
+    INSERT INTO _rt_lines
+    SELECT o.order_item_id FROM _rt_open o
+     WHERE EXISTS (SELECT 1 FROM _rt_pkeys pk JOIN _rt_keys k ON k.canon_key = pk.canon_key
+                    WHERE pk.product_id = o.product_id)
+    ON CONFLICT DO NOTHING;
+    INSERT INTO _rt_keys
+    SELECT DISTINCT pk.canon_key FROM _rt_pkeys pk
+      JOIN _rt_open o ON o.product_id = pk.product_id
+      JOIN _rt_lines l ON l.order_item_id = o.order_item_id
+    ON CONFLICT DO NOTHING;
+    SELECT count(*) INTO v_nlines FROM _rt_lines;
+    IF v_nlines > v_max_lines OR (SELECT count(*) FROM _rt_keys) > v_max_keys THEN
+      PERFORM set_config('app.recomputing_reserved', 'off', true);
+      PERFORM public.recompute_all_reserved_stock();
+      v_ms := round(extract(epoch FROM clock_timestamp() - v_t0) * 1000, 1);
+      PERFORM public.logistics_trace(jsonb_build_object(
+        'phase', 'reservering', 'step', 'reservering herberekenen', 'status', 'waarschuwing',
+        'actor', 'logistics_recompute_reserved_targeted', 'errorClass', 'omvang',
+        'reason', 'Gerichte herberekening te groot; volledige herberekening uitgevoerd.',
+        'values', jsonb_build_object('product_id', p_product_id, 'regels', v_nlines,
+                                     'sleutels', (SELECT count(*) FROM _rt_keys), 'duur_ms', v_ms)));
+      RETURN jsonb_build_object('status', 'volledig', 'regels', v_nlines, 'duur_ms', v_ms);
+    END IF;
+  END LOOP;
+
+  -- Bevroren regels eerst, naar rato van het huidige aantal.
+  IF v_freeze THEN
+    INSERT INTO _rt_frozen
+    SELECT o.order_item_id FROM _rt_open o JOIN _rt_lines l ON l.order_item_id = o.order_item_id
+     WHERE EXISTS (SELECT 1 FROM public.logistics_reservation_allocations a WHERE a.order_item_id = o.order_item_id AND a.source <> 'error')
+       AND public.logistics_allocation_frozen(o.order_id)
+    ON CONFLICT DO NOTHING;
+    INSERT INTO _rt_alloc
+    SELECT f.order_item_id, s.trade_item_key, s.qty, s.source, s.group_id
+      FROM _rt_frozen f
+      JOIN _rt_open o ON o.order_item_id = f.order_item_id
+      CROSS JOIN LATERAL public.logistics_frozen_allocation_scaled(f.order_item_id, o.qty) s;
+    INSERT INTO _rt_demand AS d
+    SELECT trade_item_key, SUM(qty) FROM _rt_alloc GROUP BY trade_item_key
+    ON CONFLICT (trade_item_key) DO UPDATE SET qty = d.qty + EXCLUDED.qty;
+    INSERT INTO _rt_keys SELECT DISTINCT trade_item_key FROM _rt_alloc ON CONFLICT DO NOTHING;
+  END IF;
+
+  FOR oi_rec IN
+    SELECT o.order_item_id AS id, o.product_id, o.qty
+      FROM _rt_open o JOIN _rt_lines l ON l.order_item_id = o.order_item_id
+     WHERE NOT EXISTS (SELECT 1 FROM _rt_frozen f WHERE f.order_item_id = o.order_item_id)
+     ORDER BY o.created_at, o.order_item_id
+  LOOP
+    SELECT string_agg(e.note, '; ') INTO v_err FROM _rt_pexp e WHERE e.product_id = oi_rec.product_id AND e.kind = 'error';
+    IF v_err IS NOT NULL THEN
+      v_struct := v_struct || jsonb_build_object('order_item_id', oi_rec.id, 'product_id', oi_rec.product_id, 'reden', v_err);
+      v_struct_qty := v_struct_qty + oi_rec.qty;
+      CONTINUE;
+    END IF;
+
+    FOR part IN
+      SELECT e.kind, e.ref, e.qty * oi_rec.qty AS qty
+        FROM _rt_pexp e WHERE e.product_id = oi_rec.product_id ORDER BY e.ord
+    LOOP
+      IF part.kind = 'item' THEN
+        SELECT canon_key INTO v_key FROM _rt_raw WHERE raw_key = part.ref;
+        IF v_key IS NULL THEN
+          v_skipped := v_skipped || to_jsonb(part.ref);
+          v_skipped_qty := v_skipped_qty + part.qty;
+        ELSE
+          INSERT INTO _rt_demand AS d VALUES (v_key, part.qty)
+            ON CONFLICT (trade_item_key) DO UPDATE SET qty = d.qty + EXCLUDED.qty;
+          INSERT INTO _rt_alloc VALUES (oi_rec.id, v_key, part.qty, 'item', NULL);
+        END IF;
+      ELSE
+        v_remaining := part.qty;
+        v_last_key := NULL;
+        FOR member_rec IN
+          SELECT g.canon_key FROM _rt_gm g WHERE g.group_id = part.ref::uuid ORDER BY g.ord
+        LOOP
+          v_key := member_rec.canon_key;
+          IF v_key IS NULL THEN CONTINUE; END IF;
+          v_last_key := v_key;
+          IF v_remaining <= 0 THEN CONTINUE; END IF;
+
+          SELECT GREATEST(COALESCE(MAX(s.physical_stock), 0)
+                          - COALESCE((SELECT d.qty FROM _rt_demand d WHERE d.trade_item_key = v_key), 0), 0)
+            INTO v_available
+            FROM public.trade_item_stock s
+           WHERE s.trade_item_key = v_key;
+
+          IF COALESCE(v_available, 0) <= 0 THEN CONTINUE; END IF;
+          v_take := LEAST(v_available, v_remaining);
+          INSERT INTO _rt_demand AS d VALUES (v_key, v_take)
+            ON CONFLICT (trade_item_key) DO UPDATE SET qty = d.qty + EXCLUDED.qty;
+          INSERT INTO _rt_alloc VALUES (oi_rec.id, v_key, v_take, 'group', part.ref::uuid);
+          v_remaining := v_remaining - v_take;
+        END LOOP;
+
+        IF v_remaining > 0 THEN
+          IF v_last_key IS NULL THEN
+            v_skipped := v_skipped || to_jsonb('group:' || part.ref);
+            v_skipped_qty := v_skipped_qty + v_remaining;
+          ELSE
+            INSERT INTO _rt_demand AS d VALUES (v_last_key, v_remaining)
+              ON CONFLICT (trade_item_key) DO UPDATE SET qty = d.qty + EXCLUDED.qty;
+            INSERT INTO _rt_alloc VALUES (oi_rec.id, v_last_key, v_remaining, 'group', part.ref::uuid);
+          END IF;
+        END IF;
+      END IF;
+    END LOOP;
+  END LOOP;
+
+  DELETE FROM public.logistics_reservation_allocations a
+   WHERE a.order_item_id IN (SELECT l.order_item_id FROM _rt_lines l);
+  INSERT INTO public.logistics_reservation_allocations (order_item_id, trade_item_key, qty, source, group_id, line_qty)
+  SELECT r.order_item_id, r.trade_item_key, SUM(r.qty), r.source, r.group_id, MAX(o.qty)
+    FROM _rt_alloc r
+    LEFT JOIN _rt_open o ON o.order_item_id = r.order_item_id
+   WHERE r.qty > 0
+   GROUP BY r.order_item_id, r.trade_item_key, r.source, r.group_id;
+
+  -- 1.0.176 (Voorraad 1.0.93): Floriday-orders op Floriday-leidende sleutels tellen niet mee
+  -- in reserved_stock; de toewijzingen zelf blijven bestaan. Oudere Voorraad: gedrag zoals nu + melding.
+  IF to_regprocedure('public.voorraad_floriday_leads_key(text)') IS NOT NULL THEN
+    UPDATE _rt_demand d
+       SET qty = COALESCE((
+             SELECT SUM(r.qty)
+               FROM _rt_alloc r
+               JOIN _rt_open op ON op.order_item_id = r.order_item_id
+               JOIN public.orders ord ON ord.id = op.order_id
+              WHERE r.trade_item_key = d.trade_item_key AND r.qty > 0
+                AND NOT (public.normalize_order_source(ord.order_source) = 'FO'
+                         AND COALESCE(public.voorraad_floriday_leads_key(d.trade_item_key), false))), 0);
+  ELSE
+    PERFORM public.logistics_trace(jsonb_build_object(
+      'phase', 'reservering', 'step', 'reservering herberekenen', 'status', 'waarschuwing',
+      'actor', 'logistics_recompute_reserved_targeted', 'errorClass', 'afhankelijkheid',
+      'reason', 'voorraad_floriday_leads_key ontbreekt (oudere Voorraad); Floriday-orders tellen nog mee in de reservering.',
+      'values', jsonb_build_object('product_id', p_product_id)));
+  END IF;
+
+  PERFORM set_config('stock.change_source', 'RESERVATION_RECOMPUTE', true);
+  UPDATE public.trade_item_stock s
+     SET reserved_stock = CEIL(COALESCE(d.qty, 0))::integer,
+         change_source  = 'RESERVATION_RECOMPUTE',
+         updated_at     = now()
+    FROM _rt_keys k
+    LEFT JOIN _rt_demand d ON d.trade_item_key = k.canon_key
+   WHERE s.trade_item_key = k.canon_key
+     AND s.reserved_stock IS DISTINCT FROM CEIL(COALESCE(d.qty, 0))::integer;
+  GET DIAGNOSTICS v_changed = ROW_COUNT;
+
+  v_ms := round(extract(epoch FROM clock_timestamp() - v_t0) * 1000, 1);
+
+  IF jsonb_array_length(v_skipped) > 0 THEN
+    PERFORM public.logistics_trace(jsonb_build_object(
+      'phase', 'reservering', 'step', 'reservering herberekenen', 'status', 'waarschuwing',
+      'actor', 'logistics_recompute_reserved_targeted', 'errorClass', 'ontbrekende_gegevens',
+      'reason', 'Geen voorraadrij en geen actieve Floriday-koppeling om die aan te maken; reservering voor deze artikelen niet berekend.',
+      'values', jsonb_build_object('product_id', p_product_id,
+        'sleutels', (SELECT jsonb_agg(DISTINCT x) FROM jsonb_array_elements_text(v_skipped) x),
+        'gemiste_vraag_stuks', v_skipped_qty)));
+  END IF;
+
+  IF jsonb_array_length(v_struct) > 0 THEN
+    PERFORM public.logistics_trace(jsonb_build_object(
+      'phase', 'reservering', 'step', 'reservering herberekenen', 'status', 'waarschuwing',
+      'actor', 'logistics_recompute_reserved_targeted', 'errorClass', 'structuur',
+      'reason', 'Samenstelling met een lus of te diepe nesting; voor deze bestelregels is niets gereserveerd.',
+      'values', jsonb_build_object('regels', v_struct, 'gemiste_vraag_stuks', v_struct_qty)));
+  END IF;
+
+  IF v_ms > v_trace_ms THEN
+    PERFORM public.logistics_trace(jsonb_build_object(
+      'phase', 'reservering', 'step', 'reservering herberekenen', 'status', 'waarschuwing',
+      'actor', 'logistics_recompute_reserved_targeted', 'errorClass', 'traag',
+      'reason', 'Gerichte herberekening duurde langer dan verwacht.',
+      'values', jsonb_build_object('product_id', p_product_id, 'regels', v_nlines,
+                                   'sleutels', (SELECT count(*) FROM _rt_keys), 'duur_ms', v_ms)));
+  END IF;
+
+  IF v_freeze THEN
+    SELECT array_agg(order_item_id) INTO v_frozen_ids FROM _rt_frozen;
+    SELECT array_agg(order_item_id) INTO v_line_ids FROM _rt_lines;
+    PERFORM public.logistics_report_frozen_shortage(v_frozen_ids);
+    PERFORM public.logistics_allocation_check_changes(v_line_ids);
+  END IF;
+
+  PERFORM set_config('app.recomputing_reserved', 'off', true);
+  RETURN jsonb_build_object('status', 'gericht', 'regels', v_nlines,
+                            'sleutels', (SELECT count(*) FROM _rt_keys), 'gewijzigd', v_changed, 'duur_ms', v_ms);
+END
+$function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_resolve_pick_document(_queue_item_id uuid, _voorbeeld boolean, _session_id text, _is_herprint boolean)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  item public.pick_queue;
+  dt public.pick_document_types;
+  doc_code text;
+  target_layout uuid;
+  target_plek uuid;
+  layout_meta jsonb;
+  v_types public.doc_layout_type[];
+  doc_type public.doc_layout_type := 'vrij';
+  layout_type public.doc_layout_type;
+  pdf_url text;
+  pdf_b64 text;
+  herkomst text;
+  v_variant text;
+  v_is_partial boolean := false;
+  v_cart_id uuid;
+  v_cart jsonb;
+  v_order_id uuid;
+  v_barcode text;
+  v_barcode_on boolean := public.logistics_pick_barcode_enabled();
+  v_ok boolean := true;
+  v_reden text;
+BEGIN
+  SELECT * INTO item FROM public.pick_queue WHERE id = _queue_item_id;
+  IF NOT FOUND THEN
+    RAISE EXCEPTION 'Dit document bestaat niet meer.' USING ERRCODE = 'P0002';
+  END IF;
+
+  SELECT * INTO dt FROM public.pick_document_types WHERE id = item.document_type_id;
+
+  doc_code := lower(btrim(coalesce(
+    nullif(item.payload->>'documentType', ''),
+    nullif(dt.code, ''),
+    ''
+  )));
+
+  v_types := public.logistics_document_type_map(doc_code);
+
+  BEGIN
+    v_cart_id := nullif(coalesce(
+      item.payload->>'cartId', item.payload->>'cart_id',
+      item.payload->'data'->>'cartId', item.payload->'data'->>'cart_id'
+    ), '')::uuid;
+  EXCEPTION WHEN invalid_text_representation THEN
+    v_cart_id := NULL;
+  END;
+
+  IF v_cart_id IS NOT NULL THEN
+    SELECT COALESCE(c.order_id, (
+      SELECT oi.order_id FROM logistics_active.order_cart_items ci
+        JOIN logistics_active.order_items oi ON oi.id = ci.order_item_id
+       WHERE ci.cart_id = c.id LIMIT 1))
+      INTO v_order_id
+      FROM logistics_active.order_carts c WHERE c.id = v_cart_id;
+
+    IF v_order_id IS NOT NULL THEN
+      SELECT c INTO v_cart
+        FROM jsonb_array_elements(public.logistics_cart_slip_plan(v_order_id)->'carts') AS c
+       WHERE (c->>'cartId')::uuid = v_cart_id;
+    END IF;
+
+    IF v_barcode_on THEN
+      v_barcode := COALESCE(
+        (SELECT b.barcode FROM public.logistics_cart_barcode b WHERE b.cart_id = v_cart_id),
+        public.logistics_cart_barcode_value(v_cart_id)
+      );
+      IF v_cart IS NOT NULL THEN
+        v_cart := v_cart || jsonb_build_object('barcode', v_barcode);
+      END IF;
+    END IF;
+  END IF;
+
+  IF v_cart IS NOT NULL THEN
+    v_is_partial := NOT COALESCE((v_cart->>'isFullCart')::boolean, false);
+  ELSE
+    v_variant := nullif(coalesce(
+      item.payload->>'slipVariant',
+      item.payload->'data'->>'slipVariant'
+    ), '');
+    IF v_variant IS NOT NULL THEN
+      v_is_partial := (v_variant = 'partial_order');
+    ELSIF nullif(coalesce(item.payload->>'pickUnit', item.payload->'data'->>'pickUnit'), '') IS NOT NULL THEN
+      v_is_partial := (coalesce(item.payload->>'pickUnit', item.payload->'data'->>'pickUnit') = 'order');
+    ELSE
+      v_is_partial := (item.cart_count IS NOT NULL AND item.cart_count <= 1);
+    END IF;
+  END IF;
+
+  -- 1.0.176 (Pickschermen 1.0.56): layout alleen via de centrale documentkeuze; payload.layout_id wordt genegeerd.
+  v_order_id := COALESCE(v_order_id, public.logistics_try_uuid(COALESCE(
+    v_cart->>'orderId', item.payload->>'orderId', item.payload->>'order_id', item.payload->'data'->>'orderId')));
+  IF doc_code <> '' AND v_order_id IS NOT NULL THEN
+    layout_meta := public.logistics_document_for_order(v_order_id, doc_code);
+    target_layout := public.logistics_try_uuid(layout_meta->>'layout_id');
+    v_ok := COALESCE(layout_meta->>'ok', 'true') <> 'false';
+    v_reden := nullif(layout_meta->>'reden', '');
+  ELSIF doc_code <> '' THEN
+    layout_meta := public.logistics_document_layout_v2(doc_code, v_is_partial);
+    target_layout := public.logistics_try_uuid(layout_meta->>'layout_id');
+  END IF;
+
+  SELECT l.documenttype INTO layout_type
+    FROM public.document_layouts l
+   WHERE l.id = target_layout AND l.actief IS TRUE;
+
+  IF layout_type IS NULL THEN target_layout := NULL; END IF;
+
+  doc_type := COALESCE(layout_type, v_types[1], 'vrij');
+
+  IF item.station_id IS NOT NULL THEN
+    SELECT k.print_plek_id INTO target_plek
+      FROM public.print_plek_koppelingen k
+     WHERE k.bron IN ('pickstation', 'pick_station')
+       AND k.bron_id = item.station_id::text
+     ORDER BY k.created_at
+     LIMIT 1;
+  END IF;
+
+  pdf_url  := nullif(item.payload->>'pdf_url', '');
+  pdf_b64  := nullif(item.payload->>'pdf_base64', '');
+  herkomst := nullif(item.payload->>'herkomst', '');
+
+  IF target_layout IS NULL AND v_reden IS NULL AND pdf_url IS NULL AND pdf_b64 IS NULL THEN
+    v_reden := 'Maak of activeer een ' || COALESCE(nullif(doc_code, ''), 'document') || 'layout in Layouts en printers.';
+  END IF;
+  IF NOT v_ok AND (pdf_url IS NOT NULL OR pdf_b64 IS NOT NULL) THEN v_ok := true; END IF;
+
+  RETURN jsonb_build_object(
+    'ok',            v_ok,
+    'reden',         CASE WHEN v_ok THEN NULL ELSE v_reden END,
+    'layout_keuze',  layout_meta->>'keuze',
+    'queue_item_id', item.id,
+    'station_id',    item.station_id,
+    'doc_code',      doc_code,
+    'layout_id',     target_layout,
+    'layout_variant', CASE WHEN v_is_partial THEN 'partial_order' ELSE 'full_cart' END,
+    'cart_id',       v_cart_id,
+    'cart',          v_cart,
+    'barcode',       v_barcode,
+    'documenttype',  doc_type,
+    'documentnaam',  COALESCE(item.document_number, 'Pickdocument'),
+    'pdf_url',       pdf_url,
+    'pdf_base64',    pdf_b64,
+    'herkomst',      herkomst,
+    'render_html',   nullif(item.payload->>'render_html', ''),
+    'print_plek_id', target_plek,
+    'foutmelding',
+      CASE WHEN target_layout IS NULL AND pdf_url IS NULL AND pdf_b64 IS NULL
+        THEN v_reden
+        ELSE NULL END,
+    'payload', jsonb_build_object(
+      'source', 'pickstation',
+      'voorbeeld', COALESCE(_voorbeeld, false),
+      'queue_item_id', item.id,
+      'station_id', item.station_id,
+      'print_plek_id', target_plek,
+      'session_id', _session_id,
+      'is_herprint', COALESCE(_is_herprint, false),
+      'document_number', item.document_number,
+      'document_type_code', COALESCE(nullif(doc_code, ''), dt.code),
+      'layout_variant', CASE WHEN v_is_partial THEN 'partial_order' ELSE 'full_cart' END,
+      'layout_id', target_layout,
+      'report_key', dt.report_key,
+      'print_template', dt.print_template,
+      'order_number', item.order_number,
+      'customer_name', item.customer_name,
+      'reference', item.reference,
+      'barcode', CASE WHEN v_barcode_on THEN COALESCE(v_barcode, item.barcode) ELSE item.barcode END,
+      'cart_id', v_cart_id,
+      'cart_index', v_cart->>'cartIndex',
+      'cart_total', v_cart->>'cartTotal',
+      'cart_label', v_cart->>'cartLabel',
+      'cart_items', COALESCE(v_cart->'items', '[]'::jsonb),
+      'country_code', item.country_code,
+      'data', (COALESCE(item.payload, '{}'::jsonb) - 'layout_id' - 'layout')
+                || jsonb_build_object('print_plek_id', target_plek)
+                || COALESCE(jsonb_build_object('cart', v_cart), '{}'::jsonb)
+    )
+  );
+END;
+$function$;
+
+CREATE OR REPLACE FUNCTION public.pick_enqueue_print_job(_queue_item_id uuid, _printer_id uuid DEFAULT NULL::uuid, _session_id text DEFAULT NULL::text, _is_herprint boolean DEFAULT false)
+ RETURNS uuid
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+declare
+  doc jsonb; target_printer uuid; job_id uuid; v_cart_id uuid;
+  v_doc_code text; v_plan jsonb; v_cart jsonb; v_last uuid; v_row_cart text;
+begin
+  select lower(btrim(coalesce(nullif(q.payload->>'documentType',''), nullif(t.code,''), ''))),
+         nullif(q.payload->>'cartId','')
+    into v_doc_code, v_row_cart
+    from public.pick_queue q
+    left join public.pick_document_types t on t.id = q.document_type_id
+   where q.id = _queue_item_id;
+
+  if v_doc_code = 'pakbon' then
+    -- Karregel: precies die ene kar. Orderregel: per kar één opdracht.
+    if v_row_cart is not null then
+      return public.pick_enqueue_print_job(_queue_item_id, _printer_id, _session_id,
+                                           coalesce(_is_herprint,false), v_row_cart);
+    end if;
+
+    begin
+      v_plan := public.pick_queue_cart_plan(_queue_item_id);
+    exception when others then v_plan := null; end;
+
+    if v_plan is null or jsonb_array_length(coalesce(v_plan->'carts','[]'::jsonb)) = 0 then
+      raise exception 'Het karplan voor dit document is nog niet klaar; er wordt geen pakbon zonder barcode geprint.' using errcode='check_violation';
+    end if;
+
+    for v_cart in select c from jsonb_array_elements(v_plan->'carts') as c loop
+      v_last := public.pick_enqueue_print_job(_queue_item_id, _printer_id, _session_id,
+                                              coalesce(_is_herprint,false), v_cart->>'cartId');
+    end loop;
+    return v_last;
+  end if;
+
+  doc := public.logistics_resolve_pick_document(_queue_item_id, false, _session_id, coalesce(_is_herprint,false));
+  -- 1.0.176: centrale documentkeuze zegt nee -> dit document niet maken, reden teruggeven.
+  if doc->>'ok' = 'false' then
+    raise exception '%', coalesce(nullif(doc->>'reden',''), 'Geen layout voor dit document.') using errcode='check_violation';
+  end if;
+
+  if nullif(doc->>'barcode','') is not null then
+    begin v_cart_id := nullif(doc->>'cart_id','')::uuid;
+    exception when invalid_text_representation then v_cart_id := null; end;
+    if v_cart_id is not null then perform public.logistics_ensure_cart_barcode(v_cart_id); end if;
+  end if;
+
+  select p.id into target_printer from public.printers p
+   where p.id = _printer_id and p.actief and nullif(p.extern_printer_id,'') is not null;
+
+  insert into public.print_jobs(
+    printer_id, layout_id, documenttype, documentnaam, status, foutmelding,
+    payload, gebruiker_naam, pdf_url, pdf_base64, herkomst, is_herprint)
+  values (target_printer, nullif(doc->>'layout_id','')::uuid,
+    (doc->>'documenttype')::public.doc_layout_type, doc->>'documentnaam', 'wachtend',
+    nullif(doc->>'foutmelding',''), doc->'payload', 'Pickstation',
+    nullif(doc->>'pdf_url',''), nullif(doc->>'pdf_base64',''), nullif(doc->>'herkomst',''),
+    coalesce(_is_herprint,false))
+  returning id into job_id;
+
+  perform public.logistics_enqueue_sticker_with_slip(_queue_item_id, _printer_id, _session_id,
+    coalesce(_is_herprint,false), nullif(doc->>'cart_id',''), job_id);
+  update public.pick_queue set print_job_id = job_id where id = _queue_item_id;
+
+  return job_id;
+end; $function$;
+
+CREATE OR REPLACE FUNCTION public.pick_enqueue_print_job(_queue_item_id uuid, _printer_id uuid, _session_id text, _is_herprint boolean, _cart_id text)
+ RETURNS uuid
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  item public.pick_queue;
+  dt public.pick_document_types;
+  doc_code text;
+  target_printer uuid;
+  target_layout uuid;
+  target_plek uuid;
+  layout_meta jsonb;
+  layout_reden text;
+  v_types public.doc_layout_type[];
+  doc_type public.doc_layout_type := 'vrij';
+  layout_type public.doc_layout_type;
+  pdf_url text;
+  pdf_b64 text;
+  herkomst text;
+  job_id uuid;
+  cart_plan jsonb := NULL;
+  selected_cart jsonb := NULL;
+  v_cart_uuid uuid;
+  v_barcode text;
+  v_barcode_on boolean := public.logistics_pick_barcode_enabled();
+  v_is_partial boolean := false;
+  v_sleutel text;
+  v_order uuid;
+BEGIN
+  SELECT * INTO item FROM public.pick_queue WHERE id = _queue_item_id;
+  IF NOT FOUND THEN RAISE EXCEPTION 'Dit document bestaat niet meer.'; END IF;
+  SELECT * INTO dt FROM public.pick_document_types WHERE id = item.document_type_id;
+  doc_code := lower(btrim(coalesce(nullif(item.payload->>'documentType', ''), nullif(dt.code, ''), '')));
+  v_types := public.logistics_document_type_map(doc_code);
+
+  IF _cart_id IS NOT NULL THEN
+    cart_plan := public.pick_queue_cart_plan(_queue_item_id);
+    SELECT c INTO selected_cart FROM jsonb_array_elements(COALESCE(cart_plan->'carts', '[]'::jsonb)) AS c
+     WHERE c->>'cartId' = _cart_id LIMIT 1;
+    IF selected_cart IS NULL THEN
+      RAISE EXCEPTION 'De gekozen kar bestaat niet meer in het actuele karplan.';
+    END IF;
+    v_is_partial := NOT COALESCE((selected_cart->>'isFullCart')::boolean, false);
+    IF v_barcode_on THEN
+      BEGIN
+        v_cart_uuid := nullif(_cart_id, '')::uuid;
+      EXCEPTION WHEN invalid_text_representation THEN
+        v_cart_uuid := NULL;
+      END;
+      IF v_cart_uuid IS NOT NULL THEN
+        v_barcode := public.logistics_ensure_cart_barcode(v_cart_uuid);
+        selected_cart := selected_cart || jsonb_build_object('barcode', v_barcode);
+      END IF;
+    END IF;
+  END IF;
+
+  -- 1.0.176: het document wordt automatisch bepaald uit de order.
+  v_order := public.logistics_try_uuid(COALESCE(selected_cart->>'orderId', item.payload->>'orderId', item.payload->>'order_id'));
+  IF doc_code <> '' AND v_order IS NOT NULL THEN
+    layout_meta := public.logistics_document_for_order(v_order, doc_code);
+    target_layout := public.logistics_try_uuid(layout_meta->>'layout_id');
+    layout_reden := nullif(layout_meta->>'reden', '');
+    IF layout_meta->>'ok' = 'false' AND nullif(item.payload->>'pdf_url', '') IS NULL AND nullif(item.payload->>'pdf_base64', '') IS NULL THEN
+      RAISE EXCEPTION '%', COALESCE(layout_reden, 'Geen layout voor dit document.') USING ERRCODE = 'check_violation';
+    END IF;
+  ELSIF doc_code <> '' THEN
+    layout_meta := public.logistics_document_layout_v2(doc_code, v_is_partial);
+    target_layout := public.logistics_try_uuid(layout_meta->>'layout_id');
+  END IF;
+
+  SELECT l.documenttype INTO layout_type FROM public.document_layouts l WHERE l.id = target_layout AND l.actief IS TRUE;
+  IF layout_type IS NULL THEN target_layout := NULL; END IF;
+  doc_type := COALESCE(layout_type, v_types[1], 'vrij');
+
+  IF item.station_id IS NOT NULL THEN
+    SELECT k.print_plek_id INTO target_plek FROM public.print_plek_koppelingen k
+     WHERE k.bron IN ('pickstation', 'pick_station') AND k.bron_id = item.station_id::text
+     ORDER BY k.created_at LIMIT 1;
+  END IF;
+
+  SELECT p.id INTO target_printer FROM public.printers p
+   WHERE p.id = _printer_id AND p.actief AND nullif(p.extern_printer_id, '') IS NOT NULL;
+
+  pdf_url := nullif(item.payload->>'pdf_url', '');
+  pdf_b64 := nullif(item.payload->>'pdf_base64', '');
+  herkomst := nullif(item.payload->>'herkomst', '');
+
+  IF NOT COALESCE(_is_herprint, false) AND _cart_id IS NOT NULL THEN
+    v_sleutel := 'pakbon:' || item.id::text || ':' || _cart_id || ':'
+              || coalesce(target_layout::text, '-') || ':' || coalesce(target_printer::text, '-');
+  END IF;
+
+  INSERT INTO public.print_jobs(
+    printer_id, layout_id, documenttype, documentnaam, status, foutmelding,
+    payload, gebruiker_naam, pdf_url, pdf_base64, herkomst, is_herprint, idempotentie_sleutel
+  )
+  VALUES (
+    target_printer, target_layout, doc_type, COALESCE(item.document_number, 'Pickdocument'), 'wachtend',
+    CASE WHEN target_layout IS NULL AND pdf_url IS NULL AND pdf_b64 IS NULL
+      THEN COALESCE(layout_reden, 'Maak of activeer een ' || COALESCE(nullif(doc_code, ''), 'document') || 'layout in Layouts en printers.')
+      ELSE NULL END,
+    jsonb_build_object(
+      'source', 'pickstation', 'queue_item_id', item.id, 'station_id', item.station_id,
+      'print_plek_id', target_plek, 'session_id', _session_id, 'is_herprint', COALESCE(_is_herprint, false),
+      'document_number', item.document_number, 'document_type_code', COALESCE(nullif(doc_code, ''), dt.code),
+      'report_key', dt.report_key, 'print_template', dt.print_template,
+      'order_number', COALESCE(selected_cart->>'orderNumber', item.order_number),
+      'customer_name', item.customer_name, 'reference', item.reference,
+      'layout_id', target_layout, 'layout_keuze', layout_meta->>'keuze',
+      'layout_variant', CASE WHEN v_is_partial THEN 'partial_order' ELSE 'full_cart' END,
+      'barcode', CASE WHEN v_barcode_on THEN COALESCE(v_barcode, item.barcode) ELSE item.barcode END,
+      'country_code', item.country_code, 'cart_id', _cart_id, 'cart', selected_cart,
+      'data', (COALESCE(item.payload, '{}'::jsonb) - 'layout_id' - 'layout') || jsonb_build_object(
+        'print_plek_id', target_plek, 'cart_id', _cart_id, 'cart', selected_cart,
+        'orderId', COALESCE(selected_cart->>'orderId', item.payload->>'orderId'),
+        'orderNumber', COALESCE(selected_cart->>'orderNumber', item.order_number))
+    ),
+    'Pickstation', pdf_url, pdf_b64, herkomst, COALESCE(_is_herprint, false), v_sleutel
+  )
+  RETURNING id INTO job_id;
+
+  PERFORM public.logistics_enqueue_sticker_with_slip(_queue_item_id, _printer_id, _session_id, COALESCE(_is_herprint,false), _cart_id, job_id);
+  UPDATE public.pick_queue SET print_job_id = job_id WHERE id = _queue_item_id;
+  RETURN job_id;
+END;
+$function$;
+
+-- ===== 1.0.176 verzenddocument Floriday bepalen =====
+-- 1.0.176: welk verzenddocument levert Floriday voor deze order (afleverbrief of veilingbrief).
+-- Bron: logistics_slip_shipping_note.fulfillment_order_id -> floriday_fulfillment_orders_cache.floriday_id,
+-- velden data->>'type', data->>'isReAuctioning', data->'deliveryNoteCodes'. Fail closed: niet gokken.
+CREATE OR REPLACE FUNCTION public.logistics_floriday_shipping_document(p_order_id uuid)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ STABLE
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_fo text;
+  v_data jsonb;
+  v_type text;
+BEGIN
+  IF to_regclass('public.logistics_slip_shipping_note') IS NULL OR to_regclass('public.floriday_fulfillment_orders_cache') IS NULL THEN
+    RETURN jsonb_build_object('ok', false, 'documenttype', NULL, 'fulfillment_order_id', NULL,
+      'reden', 'De Floriday-zendinggegevens ontbreken in deze omgeving; het verzenddocument kan niet worden bepaald.');
+  END IF;
+  SELECT s.fulfillment_order_id::text INTO v_fo
+    FROM public.logistics_slip_shipping_note s
+   WHERE s.order_id = p_order_id AND s.fulfillment_order_id IS NOT NULL
+   ORDER BY s.updated_at DESC NULLS LAST, s.created_at DESC LIMIT 1;
+  IF v_fo IS NULL THEN
+    RETURN jsonb_build_object('ok', false, 'documenttype', NULL, 'fulfillment_order_id', NULL,
+      'reden', 'Nog geen Floriday-zending bekend voor deze order; het verzenddocument volgt zodra Floriday die heeft vastgelegd.');
+  END IF;
+  SELECT c.data INTO v_data FROM public.floriday_fulfillment_orders_cache c
+   WHERE c.floriday_id::text = v_fo AND c.is_deleted IS NOT TRUE ORDER BY c.fetched_at DESC NULLS LAST LIMIT 1;
+  IF v_data IS NULL THEN
+    RETURN jsonb_build_object('ok', false, 'documenttype', NULL, 'fulfillment_order_id', v_fo,
+      'reden', 'De Floriday-zending van deze order is nog niet opgehaald; het verzenddocument volgt na de volgende Floriday-synchronisatie.');
+  END IF;
+  v_type := upper(coalesce(v_data->>'type', ''));
+  IF lower(coalesce(v_data->>'isReAuctioning', '')) = 'true' OR v_type LIKE '%CLOCK%' OR v_type LIKE '%AUCTION%' THEN
+    RETURN jsonb_build_object('ok', true, 'documenttype', 'veilingbrief', 'fulfillment_order_id', v_fo, 'reden', NULL);
+  END IF;
+  IF v_type = 'DIRECT_SALES' AND jsonb_typeof(v_data->'deliveryNoteCodes') = 'array'
+     AND jsonb_array_length(v_data->'deliveryNoteCodes') > 0 THEN
+    RETURN jsonb_build_object('ok', true, 'documenttype', 'afleverbrief', 'fulfillment_order_id', v_fo, 'reden', NULL);
+  END IF;
+  RETURN jsonb_build_object('ok', false, 'documenttype', NULL, 'fulfillment_order_id', v_fo,
+    'reden', 'Onbekend Floriday-zendingtype "' || coalesce(nullif(v_type, ''), 'leeg')
+             || '" of nog geen verzendbriefcode; het verzenddocument wordt niet gegokt.');
+END;
+$function$;
+REVOKE EXECUTE ON FUNCTION public.logistics_floriday_shipping_document(uuid) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_floriday_shipping_document(uuid) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_document_for_order(p_order_id uuid, p_documenttype text)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ STABLE
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_soort text := lower(btrim(coalesce(p_documenttype, '')));
+  v_floriday boolean;
+  v_bron text;
+  v_type text;
+  v_res jsonb;
+  v_n int; v_std int;
+  v_l public.document_layouts%ROWTYPE;
+  v_ship jsonb;
+  v_extra jsonb := '{}'::jsonb;
+BEGIN
+  IF v_soort = '' THEN
+    RETURN jsonb_build_object('ok', false, 'layout_id', NULL, 'reden', 'Geen documentsoort opgegeven.');
+  END IF;
+
+  -- 1.0.176: 'verzenddocument' wordt hier vertaald naar het echte document van de order.
+  IF v_soort IN ('verzenddocument', 'verzendbrief') THEN
+    SELECT o.order_source = 'floriday' INTO v_floriday FROM public.orders o WHERE o.id = p_order_id;
+    IF NOT FOUND THEN
+      RETURN jsonb_build_object('ok', false, 'layout_id', NULL, 'reden', 'Order niet gevonden.');
+    END IF;
+    IF coalesce(v_floriday, false) THEN
+      v_ship := public.logistics_floriday_shipping_document(p_order_id);
+      IF NOT coalesce((v_ship->>'ok')::boolean, false) THEN
+        RETURN jsonb_build_object('ok', false, 'layout_id', NULL, 'keuze', 'engine',
+          'fulfillment_order_id', v_ship->>'fulfillment_order_id', 'reden', v_ship->>'reden');
+      END IF;
+      v_soort := v_ship->>'documenttype';
+      v_extra := jsonb_build_object('verzenddocument_bepaald', v_soort,
+        'fulfillment_order_id', v_ship->>'fulfillment_order_id');
+    ELSE
+      v_soort := 'afleverbrief';
+      v_extra := jsonb_build_object('verzenddocument_bepaald', 'afleverbrief');
+    END IF;
+  END IF;
+
+  IF to_regprocedure('public.layout_voor_document(uuid,text)') IS NOT NULL THEN
+    EXECUTE 'SELECT to_jsonb(public.layout_voor_document($1, $2))' INTO v_res USING p_order_id, v_soort;
+    IF jsonb_typeof(v_res) IS DISTINCT FROM 'object' THEN
+      RETURN jsonb_build_object('ok', false, 'layout_id', NULL, 'keuze', 'layouts',
+        'reden', 'Layouts gaf geen bruikbaar antwoord voor ' || v_soort || '.') || v_extra;
+    END IF;
+    RETURN v_res || jsonb_build_object('keuze', 'layouts',
+      'ok', coalesce((v_res->>'ok')::boolean, nullif(v_res->>'layout_id', '') IS NOT NULL)) || v_extra;
+  END IF;
+  SELECT o.order_source = 'floriday' INTO v_floriday FROM public.orders o WHERE o.id = p_order_id;
+  IF v_floriday IS NULL THEN
+    SELECT EXISTS (SELECT 1 FROM public.orders WHERE id = p_order_id) INTO v_floriday;
+    IF NOT v_floriday THEN
+      RETURN jsonb_build_object('ok', false, 'layout_id', NULL, 'keuze', 'automatisch', 'reden', 'Order niet gevonden.');
+    END IF;
+    v_floriday := false;
+  END IF;
+  v_type := CASE
+    WHEN v_soort IN ('eigen_sticker', 'sticker', 'etiket') THEN 'sticker'
+    WHEN v_soort IN ('verzenddocument', 'verzendbrief', 'afleverbrief', 'afleverbon') THEN 'afleverbrief'
+    WHEN v_soort IN ('veilingbrief', 'veilingbon') THEN 'veilingbrief'
+    WHEN v_soort LIKE '%pakbon%' THEN 'pakbon'
+    WHEN v_soort LIKE '%productie%' THEN 'productiebon'
+    ELSE v_soort END;
+  v_bron := CASE
+    WHEN v_floriday AND v_soort <> 'eigen_sticker' AND v_type IN ('sticker', 'traysticker', 'afleverbrief', 'veilingbrief') THEN 'floriday'
+    ELSE 'eigen' END;
+  IF v_bron = 'eigen' AND v_type = 'veilingbrief' THEN
+    RETURN jsonb_build_object('ok', false, 'layout_id', NULL, 'keuze', 'automatisch',
+      'reden', 'Een veilingbrief hoort alleen bij een Floriday-order; voor een eigen order wordt de afleverbrief gebruikt.');
+  END IF;
+  SELECT count(*), count(*) FILTER (WHERE is_standaard IS TRUE) INTO v_n, v_std
+    FROM public.document_layouts
+   WHERE actief IS TRUE AND coalesce(bron, 'eigen') = v_bron AND documenttype::text = v_type;
+  IF v_n >= 1 THEN
+    SELECT * INTO v_l FROM public.document_layouts
+     WHERE actief IS TRUE AND coalesce(bron, 'eigen') = v_bron AND documenttype::text = v_type
+     ORDER BY is_standaard DESC NULLS LAST, updated_at DESC LIMIT 1;
+  END IF;
+  IF v_l.id IS NULL THEN
+    RETURN jsonb_build_object('ok', false, 'layout_id', NULL, 'keuze', 'automatisch', 'bron', v_bron, 'documenttype', v_type,
+      'reden', CASE WHEN v_bron = 'floriday'
+        THEN 'Geen actieve ' || v_type || '-layout met bron Floriday. Activeer de Floriday-systeemlayout in Layouts en printers.'
+        ELSE 'Maak of activeer een ' || v_type || 'layout in Layouts en printers.' END) || v_extra;
+  END IF;
+  RETURN jsonb_build_object('ok', true, 'layout_id', v_l.id, 'keuze', 'automatisch', 'bron', v_bron,
+    'documenttype', v_type, 'breedte_mm', v_l.breedte_mm, 'hoogte_mm', v_l.hoogte_mm, 'reden', NULL) || v_extra;
+END;
+$function$;
+
+
+-- ===== 1.0.178: fusten en land per kar, eigen traystickers =====
+-- 1.0.178 A: fusten en land per kar in control_get_todays_carts (achteraan toegevoegd)
+DO $m$ BEGIN
+  IF pg_get_function_result('public.control_get_todays_carts()'::regprocedure) NOT LIKE '%crates_on_cart%' THEN
+    DROP FUNCTION public.control_get_todays_carts();
+  END IF;
+END $m$;
+
+CREATE OR REPLACE FUNCTION public.control_get_todays_carts()
+ RETURNS TABLE(cart_number_id uuid, cart_number text, order_source text, order_id text, cart_index integer, order_number text, pick_date date, status text, printed_at timestamp with time zone, printed_today boolean, crates_on_cart integer, country_code text)
+ LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+  WITH vandaag AS (
+    SELECT (now() AT TIME ZONE public.logistics_tz())::date AS d
+  ),
+  idx AS (
+    SELECT DISTINCT ON (i.cart_id) i.*
+    FROM public.logistics_cart_index((SELECT d FROM vandaag), (SELECT d FROM vandaag)) i
+    ORDER BY i.cart_id, i.order_number
+  ),
+  gecontroleerd AS (
+    SELECT cci.cart_number_id, cci.order_source, cci.order_id, cci.cart_index
+      FROM public.cart_control_items cci
+      JOIN public.cart_control_sessions ccs ON ccs.id = cci.session_id
+     WHERE ccs.control_date = (SELECT d FROM vandaag)
+       AND cci.action = 'checked'
+  )
+  SELECT
+    i.cart_id,
+    COALESCE(cn.cart_number, i.cart_label),
+    i.order_source,
+    i.order_uuid::text,
+    i.cart_index,
+    i.order_number,
+    i.pick_date,
+    COALESCE(cn.status, 'pending'),
+    i.printed_at,
+    (i.printed_at >= (SELECT d FROM vandaag)::timestamptz),
+    (SELECT sum(ci.crates)::int FROM public.order_cart_items ci WHERE ci.cart_id = i.cart_id),
+    (SELECT CASE WHEN upper(btrim(l.country)) ~ '^[A-Z]{2}$' THEN upper(btrim(l.country)) END
+       FROM public.orders o
+       JOIN public.customer_delivery_locations l
+         ON l.id = public.logistics_try_uuid(o.custom_fields->>'delivery_location')
+      WHERE o.id = i.order_uuid
+      LIMIT 1)
+  FROM idx i
+  LEFT JOIN public.cart_numbers cn
+    ON cn.order_source = i.order_source
+   AND cn.order_id = i.order_uuid::text
+   AND cn.cart_index = i.cart_index
+  LEFT JOIN gecontroleerd g1 ON g1.cart_number_id = i.cart_id
+  LEFT JOIN gecontroleerd g2
+    ON g2.order_source = i.order_source
+   AND g2.order_id = i.order_uuid::text
+   AND g2.cart_index = i.cart_index
+  WHERE COALESCE(cn.status, 'pending') <> 'delivered'
+    AND g1.cart_number_id IS NULL
+    AND g2.order_id IS NULL
+  ORDER BY i.order_number, i.cart_index;
+$function$;
+REVOKE ALL ON FUNCTION public.control_get_todays_carts() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.control_get_todays_carts() TO authenticated, service_role;
+
+-- 1.0.178 B: eigen traystickers
+ALTER TABLE public.logistics_sticker_prints DROP CONSTRAINT IF EXISTS logistics_sticker_prints_soort_check;
+ALTER TABLE public.logistics_sticker_prints ADD CONSTRAINT logistics_sticker_prints_soort_check
+  CHECK (soort = ANY (ARRAY['sticker','traysticker','eigen_sticker','eigen_traysticker']));
+
+CREATE OR REPLACE FUNCTION public.logistics_own_traysticker_sync(p_limit integer DEFAULT 200)
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE
+  s jsonb; v_tray text; v_rel text; v_station text;
+  r record; v_bron text; v_keep text[] := '{}'; n int := 0; n_geblokkeerd int := 0; n_vrij int := 0; n_uit int := 0;
+BEGIN
+  SELECT settings INTO s FROM public.logistics_rule_configs
+   ORDER BY is_active DESC, (status = 'actief') DESC, updated_at DESC LIMIT 1;
+  v_tray := public.logistics_rule_text(s, 'pickstations', 'traysticker_release', 'uit');
+  IF v_tray = 'uit' THEN
+    RETURN jsonb_build_object('trayRelease', v_tray, 'regels', 0);
+  END IF;
+  v_rel := public.logistics_rule_text(s, 'pickstations', 'sticker_release', 'with_pick_release');
+  v_station := CASE WHEN v_rel = 'with_packing_slip'
+                    THEN public.logistics_rule_text(s, 'pickstations', 'packing_slip_station', '')
+                    ELSE public.logistics_rule_text(s, 'pickstations', 'sticker_station', '') END;
+
+  FOR r IN
+    SELECT o.id AS order_id, o.order_number, ci.cart_id,
+           bool_or(ci.layer_index IS NULL) AS zonder_indeling,
+           array_agg(DISTINCT ci.layer_index) FILTER (WHERE ci.layer_index IS NOT NULL) AS lagen
+      FROM public.orders o
+      JOIN public.order_items oi ON oi.order_id = o.id
+      JOIN public.order_cart_items ci ON ci.order_item_id = oi.id
+     WHERE coalesce(o.order_source, '') <> 'floriday'
+       AND o.deleted_at IS NULL AND o.cancelled_at IS NULL
+       AND coalesce(o.status, '') <> 'geannuleerd'
+       AND oi.quarantined_at IS NULL
+       AND o.delivery_date >= current_date - 1
+     GROUP BY o.id, o.order_number, ci.cart_id
+     LIMIT greatest(1, p_limit)
+  LOOP
+    IF r.zonder_indeling OR r.lagen IS NULL THEN
+      v_bron := r.order_id::text || ':' || r.cart_id::text || ':geen-indeling';
+      v_keep := v_keep || v_bron;
+      INSERT INTO public.logistics_sticker_prints (soort, bron_id, order_id, order_number, cart_id, kopieen, status, reden)
+      VALUES ('eigen_traysticker', v_bron, r.order_id, r.order_number, r.cart_id, 1, 'geblokkeerd',
+              'Trayindeling ontbreekt voor deze kar: niet elke orderregel heeft een tray (laag). Deel de kar opnieuw in; de rest van de order gaat door.')
+      ON CONFLICT DO NOTHING;
+      n_geblokkeerd := n_geblokkeerd + 1;
+      CONTINUE;
+    END IF;
+    FOR i IN 1 .. array_length(r.lagen, 1) LOOP
+      v_bron := r.order_id::text || ':' || r.cart_id::text || ':' || r.lagen[i]::text;
+      v_keep := v_keep || v_bron;
+      INSERT INTO public.logistics_sticker_prints (soort, bron_id, order_id, order_number, cart_id, kopieen, print_plek_id, status, reden)
+      VALUES ('eigen_traysticker', v_bron, r.order_id, r.order_number, r.cart_id, 1,
+              public.logistics_sticker_cart_plek(r.cart_id, v_station), 'wacht_op_moment', 'Wacht op de pakbon van deze kar.')
+      ON CONFLICT DO NOTHING;
+      n := n + 1;
+    END LOOP;
+  END LOOP;
+
+  -- Indeling hersteld of tray vervallen: niet meer printen (alleen nog niet geprinte rijen).
+  UPDATE public.logistics_sticker_prints p
+     SET status = 'niet_printen', reden = 'Tray hoort niet meer bij deze kar of order vervallen.', updated_at = now()
+   WHERE p.soort = 'eigen_traysticker' AND p.status IN ('wacht_op_moment', 'geblokkeerd', 'klaar')
+     AND NOT (p.bron_id = ANY (v_keep))
+     AND p.order_id IN (SELECT o.id FROM public.orders o WHERE o.delivery_date >= current_date - 1);
+  GET DIAGNOSTICS n_uit = ROW_COUNT;
+
+  -- Vrijgave: met de pakbon van de kar (zoals eigen stickers).
+  UPDATE public.logistics_sticker_prints p
+     SET status = 'klaar', reden = NULL,
+         print_plek_id = coalesce(p.print_plek_id, public.logistics_sticker_cart_plek(p.cart_id, v_station)),
+         updated_at = now()
+   WHERE p.soort = 'eigen_traysticker' AND p.status = 'wacht_op_moment'
+     AND p.cart_id IS NOT NULL AND public.logistics_cart_slip_queued(p.cart_id);
+  GET DIAGNOSTICS n_vrij = ROW_COUNT;
+
+  RETURN jsonb_build_object('trayRelease', v_tray, 'trays', n, 'geblokkeerd', n_geblokkeerd, 'vrijgegeven', n_vrij, 'niet_printen', n_uit);
+END; $function$;
+REVOKE ALL ON FUNCTION public.logistics_own_traysticker_sync(integer) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_own_traysticker_sync(integer) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_own_traysticker_payload(p_id uuid)
+ RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE p record; o record; v_laag int; v_nr int; v_tot int; v_loc text; v_prod jsonb;
+BEGIN
+  SELECT * INTO p FROM public.logistics_sticker_prints WHERE id = p_id AND soort = 'eigen_traysticker';
+  IF p.id IS NULL THEN RETURN jsonb_build_object('ok', false, 'reden', 'Traysticker niet gevonden.'); END IF;
+  v_laag := nullif(split_part(p.bron_id, ':', 3), '')::int;
+  SELECT * INTO o FROM public.orders WHERE id = p.order_id;
+  SELECT count(DISTINCT ci.layer_index),
+         count(DISTINCT ci.layer_index) FILTER (WHERE ci.layer_index <= v_laag)
+    INTO v_tot, v_nr
+    FROM public.order_cart_items ci JOIN public.order_items oi ON oi.id = ci.order_item_id
+   WHERE oi.order_id = p.order_id AND ci.cart_id = p.cart_id AND ci.layer_index IS NOT NULL;
+  SELECT coalesce(jsonb_agg(jsonb_build_object(
+           'artikelnummer', prd.article_number,
+           'naam', coalesce(ci.product_name, oi.product_name),
+           'aantal', coalesce(ci.crates_in_layer, ci.crates)) ORDER BY coalesce(ci.product_name, oi.product_name)), '[]'::jsonb)
+    INTO v_prod
+    FROM public.order_cart_items ci JOIN public.order_items oi ON oi.id = ci.order_item_id
+    LEFT JOIN public.products prd ON prd.id = coalesce(ci.product_id, oi.product_id)
+   WHERE oi.order_id = p.order_id AND ci.cart_id = p.cart_id AND ci.layer_index = v_laag;
+  SELECT nullif(btrim(concat_ws(', ', nullif(btrim(l.name), ''), nullif(btrim(l.city), ''), nullif(btrim(l.country), ''))), '')
+    INTO v_loc
+    FROM public.customer_delivery_locations l
+   WHERE l.id = public.logistics_try_uuid(o.custom_fields->>'delivery_location');
+  IF v_tot IS NULL OR v_tot = 0 OR jsonb_array_length(v_prod) = 0 THEN
+    RETURN jsonb_build_object('ok', false, 'reden', 'Trayindeling ontbreekt voor deze tray. Deel de kar opnieuw in.');
+  END IF;
+  RETURN jsonb_build_object('ok', true, 'payload', jsonb_build_object(
+    'order_id', o.id, 'order_number', o.order_number, 'ordernummer', o.order_number,
+    'klantnaam', o.customer_name, 'leverdatum', o.delivery_date, 'afleverlocatie', v_loc,
+    'cart_id', p.cart_id, 'tray_nummer', v_nr, 'tray_totaal', v_tot, 'tray_producten', v_prod));
+END; $function$;
+REVOKE ALL ON FUNCTION public.logistics_own_traysticker_payload(uuid) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_own_traysticker_payload(uuid) TO service_role;
+-- ===== 1.0.178 correctie: eigen traysticker per fust =====
+-- 1.0.178 correctie: eigen traysticker per FUST (niet per laag).
+-- Sleutel: order:kar:karregel:fustnummer. Crates onbekend: één geblokkeerde rij per karregel.
+-- Planten op fust x van y binnen een orderregel: ppc, laatste fust = de rest (nooit <= 0).
+CREATE OR REPLACE FUNCTION public.logistics_tray_plants(p_ppc integer, p_regel_totaal integer, p_fust integer, p_fusten integer)
+RETURNS integer LANGUAGE sql IMMUTABLE SET search_path = public AS $tp$
+  SELECT CASE
+    WHEN p_ppc IS NULL OR p_ppc <= 0 THEN NULL
+    WHEN p_fust < p_fusten OR p_regel_totaal IS NULL THEN p_ppc
+    WHEN p_regel_totaal - p_ppc * (p_fusten - 1) > 0 THEN p_regel_totaal - p_ppc * (p_fusten - 1)
+    ELSE p_ppc
+  END
+$tp$;
+
+CREATE OR REPLACE FUNCTION public.logistics_own_traysticker_sync(p_limit integer DEFAULT 200)
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE
+  s jsonb; v_tray text; v_rel text; v_station text;
+  r record; v_bron text; v_keep text[] := '{}'; n int := 0; n_geblokkeerd int := 0; n_vrij int := 0; n_uit int := 0;
+BEGIN
+  SELECT settings INTO s FROM public.logistics_rule_configs
+   ORDER BY is_active DESC, (status = 'actief') DESC, updated_at DESC LIMIT 1;
+  v_tray := public.logistics_rule_text(s, 'pickstations', 'traysticker_release', 'uit');
+  IF v_tray = 'uit' THEN
+    RETURN jsonb_build_object('trayRelease', v_tray, 'regels', 0);
+  END IF;
+  v_rel := public.logistics_rule_text(s, 'pickstations', 'sticker_release', 'with_pick_release');
+  v_station := CASE WHEN v_rel = 'with_packing_slip'
+                    THEN public.logistics_rule_text(s, 'pickstations', 'packing_slip_station', '')
+                    ELSE public.logistics_rule_text(s, 'pickstations', 'sticker_station', '') END;
+
+  FOR r IN
+    SELECT o.id AS order_id, o.order_number, ci.cart_id, ci.id AS ci_id, ci.crates
+      FROM public.orders o
+      JOIN public.order_items oi ON oi.order_id = o.id
+      JOIN public.order_cart_items ci ON ci.order_item_id = oi.id
+     WHERE coalesce(o.order_source, '') <> 'floriday'
+       AND o.deleted_at IS NULL AND o.cancelled_at IS NULL
+       AND coalesce(o.status, '') <> 'geannuleerd'
+       AND oi.quarantined_at IS NULL
+       AND o.delivery_date >= current_date - 1
+     ORDER BY o.order_number, ci.cart_id, ci.created_at, ci.id
+     LIMIT greatest(1, p_limit)
+  LOOP
+    IF r.crates IS NULL OR r.crates <= 0 THEN
+      v_bron := r.order_id::text || ':' || r.cart_id::text || ':' || r.ci_id::text || ':onbekend';
+      v_keep := v_keep || v_bron;
+      INSERT INTO public.logistics_sticker_prints (soort, bron_id, order_id, order_number, cart_id, kopieen, status, reden)
+      VALUES ('eigen_traysticker', v_bron, r.order_id, r.order_number, r.cart_id, 1, 'geblokkeerd',
+              'Aantal fusten onbekend voor deze regel op de kar. De rest van de order gaat door.')
+      ON CONFLICT DO NOTHING;
+      n_geblokkeerd := n_geblokkeerd + 1;
+      CONTINUE;
+    END IF;
+    FOR k IN 1 .. r.crates LOOP
+      v_bron := r.order_id::text || ':' || r.cart_id::text || ':' || r.ci_id::text || ':' || k::text;
+      v_keep := v_keep || v_bron;
+      INSERT INTO public.logistics_sticker_prints (soort, bron_id, order_id, order_number, cart_id, kopieen, print_plek_id, status, reden)
+      VALUES ('eigen_traysticker', v_bron, r.order_id, r.order_number, r.cart_id, 1,
+              public.logistics_sticker_cart_plek(r.cart_id, v_station), 'wacht_op_moment', 'Wacht op de pakbon van deze kar.')
+      ON CONFLICT DO NOTHING;
+      n := n + 1;
+    END LOOP;
+  END LOOP;
+
+  -- Oude laagsleutels, vervallen fusten of orders: niet meer printen (alleen nog niet geprinte rijen, geen DELETE).
+  UPDATE public.logistics_sticker_prints p
+     SET status = 'niet_printen', reden = 'Fust hoort niet meer bij deze kar of order vervallen.', updated_at = now()
+   WHERE p.soort = 'eigen_traysticker' AND p.status IN ('wacht_op_moment', 'geblokkeerd', 'klaar')
+     AND NOT (p.bron_id = ANY (v_keep))
+     AND p.order_id IN (SELECT o.id FROM public.orders o WHERE o.delivery_date >= current_date - 1);
+  GET DIAGNOSTICS n_uit = ROW_COUNT;
+
+  UPDATE public.logistics_sticker_prints p
+     SET status = 'klaar', reden = NULL,
+         print_plek_id = coalesce(p.print_plek_id, public.logistics_sticker_cart_plek(p.cart_id, v_station)),
+         updated_at = now()
+   WHERE p.soort = 'eigen_traysticker' AND p.status = 'wacht_op_moment'
+     AND p.cart_id IS NOT NULL AND public.logistics_cart_slip_queued(p.cart_id);
+  GET DIAGNOSTICS n_vrij = ROW_COUNT;
+
+  RETURN jsonb_build_object('trayRelease', v_tray, 'fusten', n, 'geblokkeerd', n_geblokkeerd, 'vrijgegeven', n_vrij, 'niet_printen', n_uit);
+END; $function$;
+REVOKE ALL ON FUNCTION public.logistics_own_traysticker_sync(integer) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_own_traysticker_sync(integer) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_own_traysticker_payload(p_id uuid)
+ RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE
+  p record; o record; c record; v_ci uuid; v_k int; v_nr int; v_tot int; v_loc text;
+  v_ppc int; v_regel_tot int; v_item_voor int; v_item_fusten int; v_aantal int; v_prod jsonb;
+BEGIN
+  SELECT * INTO p FROM public.logistics_sticker_prints WHERE id = p_id AND soort = 'eigen_traysticker';
+  IF p.id IS NULL THEN RETURN jsonb_build_object('ok', false, 'reden', 'Traysticker niet gevonden.'); END IF;
+  v_ci := public.logistics_try_uuid(split_part(p.bron_id, ':', 3));
+  v_k := CASE WHEN split_part(p.bron_id, ':', 4) ~ '^[0-9]+$' THEN split_part(p.bron_id, ':', 4)::int END;
+  IF v_ci IS NULL OR v_k IS NULL THEN
+    RETURN jsonb_build_object('ok', false, 'reden', 'Aantal fusten onbekend');
+  END IF;
+  SELECT ci.*, oi.unit, oi.quantity, oi.plants_per_crate AS ppc_regel, oi.product_name AS oi_naam,
+         prd.article_number, prd.plants_per_crate AS ppc_product, ci.order_item_id AS item_id
+    INTO c
+    FROM public.order_cart_items ci JOIN public.order_items oi ON oi.id = ci.order_item_id
+    LEFT JOIN public.products prd ON prd.id = coalesce(ci.product_id, oi.product_id)
+   WHERE ci.id = v_ci;
+  IF c.id IS NULL OR c.crates IS NULL OR c.crates < v_k THEN
+    RETURN jsonb_build_object('ok', false, 'reden', 'Aantal fusten onbekend');
+  END IF;
+  SELECT * INTO o FROM public.orders WHERE id = p.order_id;
+
+  -- Fustnummer x van y binnen de order (alle karren), volgorde kar, regel, fust.
+  WITH alle AS (
+    SELECT ci.id, ci.crates, row_number() OVER (ORDER BY ci.cart_id, ci.created_at, ci.id) AS rn
+      FROM public.order_cart_items ci JOIN public.order_items oi ON oi.id = ci.order_item_id
+     WHERE oi.order_id = p.order_id AND oi.quarantined_at IS NULL AND coalesce(ci.crates, 0) > 0
+  )
+  SELECT sum(crates)::int,
+         coalesce(sum(crates) FILTER (WHERE rn < (SELECT rn FROM alle WHERE id = v_ci)), 0)::int + v_k
+    INTO v_tot, v_nr FROM alle;
+
+  -- Planten per fust: karregel, dan orderregel, dan product. Laatste fust van de regel: de rest.
+  v_ppc := coalesce(nullif(c.plants_per_crate, 0), nullif(c.ppc_regel, 0), nullif(c.ppc_product, 0))::int;
+  IF v_ppc IS NULL THEN
+    RETURN jsonb_build_object('ok', false, 'reden', 'Planten per fust onbekend (niet op de regel en niet bij het product). Vul planten per fust in.');
+  END IF;
+  v_regel_tot := public.logistics_own_sticker_count(c.unit, c.quantity, c.ppc_regel, c.ppc_product);
+  SELECT coalesce(sum(ci.crates) FILTER (WHERE (ci.cart_id, ci.created_at, ci.id) < (c.cart_id, c.created_at, c.id)), 0)::int,
+         coalesce(sum(ci.crates), 0)::int
+    INTO v_item_voor, v_item_fusten
+    FROM public.order_cart_items ci WHERE ci.order_item_id = c.item_id AND coalesce(ci.crates, 0) > 0;
+  v_aantal := public.logistics_tray_plants(v_ppc, v_regel_tot, v_item_voor + v_k, v_item_fusten);
+
+  v_prod := jsonb_build_array(jsonb_strip_nulls(jsonb_build_object(
+    'artikelnummer', c.article_number,
+    'naam', coalesce(c.product_name, c.oi_naam),
+    'aantal', v_aantal,
+    'onderdelen', CASE WHEN jsonb_typeof(to_jsonb(c.components)) = 'array' AND jsonb_array_length(to_jsonb(c.components)) > 0
+                       THEN to_jsonb(c.components) END)));
+
+  SELECT nullif(btrim(concat_ws(', ', nullif(btrim(l.name), ''), nullif(btrim(l.city), ''), nullif(btrim(l.country), ''))), '')
+    INTO v_loc
+    FROM public.customer_delivery_locations l
+   WHERE l.id = public.logistics_try_uuid(o.custom_fields->>'delivery_location');
+
+  RETURN jsonb_build_object('ok', true, 'payload', jsonb_build_object(
+    'order_id', o.id, 'order_number', o.order_number, 'ordernummer', o.order_number,
+    'klantnaam', o.customer_name, 'leverdatum', o.delivery_date, 'afleverlocatie', v_loc,
+    'cart_id', p.cart_id, 'tray_nummer', v_nr, 'tray_totaal', v_tot, 'tray_producten', v_prod));
+END; $function$;
+REVOKE ALL ON FUNCTION public.logistics_own_traysticker_payload(uuid) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_own_traysticker_payload(uuid) TO service_role;
+
+-- ===== 1.0.179: noodreparaties karindeling =====
+-- 1.0.179 fase 1: noodreparaties karindeling (alle ordersoorten FO/HO/MO/AO).
+-- Alleen eigen Engine-objecten; idempotent; geen omgevingswaarden; geen datacorrectie.
+
+-- 3. Bevestigingen van een onwaarschijnlijke belading: één per order en verpakking.
+CREATE TABLE IF NOT EXISTS public.logistics_belading_bevestigingen (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  order_id uuid NOT NULL,
+  verpakking_sleutel text NOT NULL,
+  redenen text[] NOT NULL DEFAULT '{}',
+  bevestigd_door uuid,
+  bevestigd_op timestamptz NOT NULL DEFAULT now(),
+  created_at timestamptz NOT NULL DEFAULT now(),
+  UNIQUE (order_id, verpakking_sleutel)
+);
+GRANT SELECT ON public.logistics_belading_bevestigingen TO authenticated;
+GRANT ALL ON public.logistics_belading_bevestigingen TO service_role;
+ALTER TABLE public.logistics_belading_bevestigingen ENABLE ROW LEVEL SECURITY;
+DO $p$ BEGIN
+  IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE tablename = 'logistics_belading_bevestigingen' AND policyname = 'beheer leest bevestigingen') THEN
+    CREATE POLICY "beheer leest bevestigingen" ON public.logistics_belading_bevestigingen
+      FOR SELECT TO authenticated USING (public.logistics_is_beheer());
+  END IF;
+END $p$;
+
+CREATE OR REPLACE FUNCTION public.logistics_belading_bevestig(p_order_id uuid, p_sleutel text, p_redenen text[] DEFAULT '{}')
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+BEGIN
+  IF NOT public.logistics_is_beheer() THEN
+    RAISE EXCEPTION 'Alleen beheer mag een belading bevestigen.';
+  END IF;
+  IF p_order_id IS NULL OR coalesce(btrim(p_sleutel), '') = '' THEN
+    RAISE EXCEPTION 'Order en verpakking zijn verplicht.';
+  END IF;
+  INSERT INTO public.logistics_belading_bevestigingen (order_id, verpakking_sleutel, redenen, bevestigd_door)
+  VALUES (p_order_id, p_sleutel, coalesce(p_redenen, '{}'), auth.uid())
+  ON CONFLICT (order_id, verpakking_sleutel) DO NOTHING;
+  PERFORM public.logistics_plan_enqueue(p_order_id, 'belading bevestigd');
+  RETURN jsonb_build_object('ok', true);
+END; $function$;
+REVOKE ALL ON FUNCTION public.logistics_belading_bevestig(uuid, text, text[]) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_belading_bevestig(uuid, text, text[]) TO authenticated, service_role;
+
+-- 5. Lease bezet: opdracht blijft open en komt later terug (nooit 'done' zonder indeling).
+CREATE OR REPLACE FUNCTION public.logistics_plan_retry_later(p_id uuid, p_seconds integer DEFAULT 30)
+ RETURNS void LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+BEGIN
+  UPDATE public.logistics_plan_queue
+     SET status = 'pending', claimed_at = NULL,
+         next_attempt_at = now() + make_interval(secs => greatest(5, least(coalesce(p_seconds, 30), 600))),
+         error = 'Indeling van deze buffer was bezet; later opnieuw.', updated_at = now()
+   WHERE id = p_id AND status IN ('running', 'pending');
+END; $function$;
+REVOKE ALL ON FUNCTION public.logistics_plan_retry_later(uuid, integer) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_plan_retry_later(uuid, integer) TO service_role;
+
+-- 6. Oude SQL-indeler onbruikbaar: geen EXECUTE voor PUBLIC, anon of authenticated.
+DO $r$ BEGIN
+  IF to_regprocedure('public.logistics_plan_all(uuid)') IS NOT NULL THEN
+    REVOKE ALL ON FUNCTION public.logistics_plan_all(uuid) FROM PUBLIC, anon, authenticated;
+  END IF;
+  IF to_regprocedure('public.logistics_plan_buffer_sql(uuid)') IS NOT NULL THEN
+    REVOKE ALL ON FUNCTION public.logistics_plan_buffer_sql(uuid) FROM PUBLIC, anon, authenticated;
+  END IF;
+END $r$;
+
+-- 7. Karnummers aan het kar-id (stabiel na herindeling). Kolom en index alleen toevoegen.
+DO $c$ BEGIN
+  IF to_regclass('public.cart_numbers') IS NULL THEN
+    RAISE NOTICE 'logistiek-engine: cart_numbers ontbreekt (andere module), kar-id-koppeling overgeslagen';
+  ELSE
+    ALTER TABLE public.cart_numbers ADD COLUMN IF NOT EXISTS cart_id uuid;
+    IF NOT EXISTS (SELECT 1 FROM pg_indexes WHERE indexname = 'cart_numbers_pick_date_cart_id_uniq') THEN
+      IF EXISTS (SELECT 1 FROM public.cart_numbers WHERE cart_id IS NOT NULL GROUP BY pick_date, cart_id HAVING count(*) > 1) THEN
+        RAISE NOTICE 'logistiek-engine: dubbele kar-id per dag in cart_numbers; unieke index niet aangemaakt';
+      ELSE
+        CREATE UNIQUE INDEX cart_numbers_pick_date_cart_id_uniq ON public.cart_numbers (pick_date, cart_id) WHERE cart_id IS NOT NULL;
+      END IF;
+    END IF;
+  END IF;
+END $c$;
+
+-- Dubbele kar-indexen per order (twee karren met hetzelfde volgnummer): alleen-lezen lijst.
+CREATE OR REPLACE FUNCTION public.logistics_cart_seq_dubbel(p_order_uuid uuid DEFAULT NULL)
+ RETURNS TABLE(order_uuid uuid, cart_index integer, cart_ids uuid[])
+ LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+  WITH ruw AS (
+    SELECT oc.id AS cart_id, oc.cart_number AS cart_index, oc.order_id AS order_uuid
+      FROM logistics_active.order_carts oc
+     WHERE oc.order_id IS NOT NULL AND (p_order_uuid IS NULL OR oc.order_id = p_order_uuid)
+    UNION
+    SELECT oc.id, oc.cart_number, oi.order_id
+      FROM logistics_active.order_carts oc
+      JOIN public.order_cart_items oci ON oci.cart_id = oc.id
+      JOIN logistics_active.order_items oi ON oi.id = oci.order_item_id
+     WHERE oc.order_id IS NULL AND oi.order_id IS NOT NULL AND (p_order_uuid IS NULL OR oi.order_id = p_order_uuid)
+  )
+  SELECT order_uuid, cart_index, array_agg(DISTINCT cart_id ORDER BY cart_id)
+    FROM ruw GROUP BY order_uuid, cart_index HAVING count(DISTINCT cart_id) > 1;
+$function$;
+REVOKE ALL ON FUNCTION public.logistics_cart_seq_dubbel(uuid) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_cart_seq_dubbel(uuid) TO service_role;
+
+-- logistics_cart_seq: nooit stil een kar laten vallen. Bij een dubbel volgnummer: fout.
+-- Karnummer eerst via kar-id, anders via order + index (bestaande nummers).
+CREATE OR REPLACE FUNCTION public.logistics_cart_seq(p_order_uuid uuid DEFAULT NULL::uuid)
+ RETURNS TABLE(order_uuid uuid, cart_id uuid, cart_index integer, cart_seq integer, cart_number text, cart_total integer)
+ LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE d record;
+BEGIN
+  SELECT * INTO d FROM public.logistics_cart_seq_dubbel(p_order_uuid) LIMIT 1;
+  IF d.order_uuid IS NOT NULL THEN
+    RAISE EXCEPTION 'Karnummering ongeldig: order % heeft % karren met volgnummer %. Deel de order opnieuw in; er wordt geen kar weggelaten.',
+      d.order_uuid, array_length(d.cart_ids, 1), d.cart_index;
+  END IF;
+  RETURN QUERY
+  WITH deelname AS (
+    SELECT oc.id AS cart_id, oc.cart_number AS cart_index, oc.order_id AS order_uuid
+      FROM public.order_carts oc
+     WHERE oc.order_id IS NOT NULL AND (p_order_uuid IS NULL OR oc.order_id = p_order_uuid)
+    UNION
+    SELECT oc.id, oc.cart_number, oi.order_id
+      FROM public.order_carts oc
+      JOIN public.order_cart_items oci ON oci.cart_id = oc.id
+      JOIN logistics_active.order_items oi ON oi.id = oci.order_item_id
+     WHERE oc.order_id IS NULL AND oi.order_id IS NOT NULL AND (p_order_uuid IS NULL OR oi.order_id = p_order_uuid)
+  ),
+  genummerd AS (
+    SELECT dd.order_uuid, dd.cart_id, dd.cart_index,
+      dense_rank() OVER (PARTITION BY dd.order_uuid ORDER BY dd.cart_index)::int AS cart_seq,
+      count(*) OVER (PARTITION BY dd.order_uuid)::int AS cart_total
+    FROM deelname dd
+  )
+  SELECT g.order_uuid, g.cart_id, g.cart_index, g.cart_seq,
+    COALESCE(
+      (SELECT cn.cart_number FROM public.cart_numbers cn WHERE cn.cart_id = g.cart_id ORDER BY cn.assigned_at DESC LIMIT 1),
+      (SELECT cn.cart_number FROM public.cart_numbers cn WHERE cn.order_id = g.order_uuid::text AND cn.cart_index = g.cart_index LIMIT 1),
+      g.cart_seq::text),
+    g.cart_total
+  FROM genummerd g;
+END; $function$;
+REVOKE ALL ON FUNCTION public.logistics_cart_seq(uuid) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_cart_seq(uuid) TO authenticated, service_role;
+
+-- 8. Kar wisselen: eerst vergrendelen en pickup_locked controleren, dan pas verwijderen; geen stille 1.
+CREATE OR REPLACE FUNCTION public.logistics_apply_cart_swap(p_delete_ids uuid[], p_new_carts jsonb)
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_del uuid[] := COALESCE(p_delete_ids, ARRAY[]::uuid[]);
+  v_cart jsonb; v_row jsonb; v_id uuid; v_map jsonb := '[]'::jsonb;
+  v_jobs int := 0; v_carts int := 0; v_items int := 0; v_locked int;
+BEGIN
+  IF jsonb_typeof(COALESCE(p_new_carts, '[]'::jsonb)) <> 'array' THEN
+    RAISE EXCEPTION 'Nieuwe karren ontbreken of zijn ongeldig.';
+  END IF;
+  IF EXISTS (
+    SELECT 1 FROM jsonb_array_elements(COALESCE(p_new_carts, '[]'::jsonb)) c,
+                  jsonb_array_elements(COALESCE(c.value->'items', '[]'::jsonb)) i
+     WHERE coalesce((i.value->>'plants_per_crate')::numeric, 0) <= 0
+        OR coalesce((i.value->>'crates')::numeric, 0) < 0) THEN
+    RAISE EXCEPTION 'Karwissel geweigerd: een karregel mist planten per fust (belading_onvolledig).';
+  END IF;
+
+  IF array_length(v_del, 1) IS NOT NULL THEN
+    PERFORM 1 FROM public.order_carts WHERE id = ANY(v_del) ORDER BY id FOR UPDATE;
+    SELECT count(*) INTO v_locked FROM public.order_carts WHERE id = ANY(v_del) AND COALESCE(pickup_locked, false);
+    IF v_locked > 0 THEN
+      RAISE EXCEPTION 'Karwissel geweigerd: % kar(ren) zijn al vastgezet (opgehaald). Er is niets gewijzigd.', v_locked;
+    END IF;
+    UPDATE public.print_jobs
+       SET status = 'geannuleerd'::print_job_status,
+           foutmelding = 'Vervallen: kar verwijderd bij herindeling',
+           updated_at = now()
+     WHERE status IN ('wachtend'::print_job_status, 'bezig'::print_job_status)
+       AND (payload->>'cart_id') = ANY(SELECT id::text FROM unnest(v_del) AS id);
+    GET DIAGNOSTICS v_jobs = ROW_COUNT;
+    DELETE FROM public.pakbon_barcode_inhoud WHERE cart_id = ANY(SELECT id::text FROM unnest(v_del) AS id);
+    DELETE FROM public.order_cart_layer_positions WHERE cart_id = ANY(v_del);
+    DELETE FROM public.order_cart_items WHERE cart_id = ANY(v_del);
+    DELETE FROM public.order_carts WHERE id = ANY(v_del);
+    GET DIAGNOSTICS v_carts = ROW_COUNT;
+  END IF;
+
+  FOR v_cart IN SELECT value FROM jsonb_array_elements(COALESCE(p_new_carts, '[]'::jsonb)) LOOP
+    v_row := v_cart->'row';
+    v_id := gen_random_uuid();
+    INSERT INTO public.order_carts (id, order_id, buffer_id, cart_number, total_carts, is_auto, is_complete, source,
+      occupancy_pct, total_layers_used, carrier_type, carrier_type_id, max_layers, weight_kg, algorithm_version, layout_method)
+    SELECT v_id, r.order_id, r.buffer_id, r.cart_number, r.total_carts, COALESCE(r.is_auto, true), COALESCE(r.is_complete, false),
+           COALESCE(r.source, 'auto'), COALESCE(r.occupancy_pct, 0), COALESCE(r.total_layers_used, 0),
+           COALESCE(r.carrier_type, 'trolley'), r.carrier_type_id, r.max_layers, r.weight_kg, COALESCE(r.algorithm_version, 1), r.layout_method
+      FROM jsonb_to_record(v_row) AS r(order_id uuid, buffer_id uuid, cart_number integer, total_carts integer, is_auto boolean,
+           is_complete boolean, source text, occupancy_pct numeric, total_layers_used numeric, carrier_type text, carrier_type_id uuid,
+           max_layers integer, weight_kg numeric, algorithm_version integer, layout_method text);
+
+    INSERT INTO public.order_cart_items (cart_id, order_item_id, product_id, product_name, crates, boxes, weight_kg,
+      plants_per_crate, crates_per_layer, layers_per_cart, layer_fraction, layer_share_pct, layer_index, crates_in_layer, components)
+    SELECT v_id, i.order_item_id, i.product_id, i.product_name, i.crates, i.boxes, i.weight_kg,
+           i.plants_per_crate, COALESCE(i.crates_per_layer, 1), COALESCE(i.layers_per_cart, 1),
+           COALESCE(i.layer_fraction, 0), COALESCE(i.layer_share_pct, 0), i.layer_index, i.crates_in_layer,
+           CASE WHEN jsonb_typeof(i.components) = 'array' THEN i.components END
+      FROM jsonb_to_recordset(COALESCE(v_cart->'items', '[]'::jsonb)) AS i(order_item_id uuid, product_id uuid, product_name text,
+           crates integer, boxes integer, weight_kg numeric, plants_per_crate integer, crates_per_layer integer, layers_per_cart integer,
+           layer_fraction numeric, layer_share_pct numeric, layer_index integer, crates_in_layer integer, components jsonb);
+    v_items := v_items + jsonb_array_length(COALESCE(v_cart->'items', '[]'::jsonb));
+    v_map := v_map || jsonb_build_object('planIndex', (v_cart->>'planIndex')::integer, 'id', v_id);
+  END LOOP;
+
+  RETURN jsonb_build_object('karren', v_map, 'verwijderd', v_carts, 'printopdrachtenGeannuleerd', v_jobs, 'regels', v_items);
+END;
+$function$;
+REVOKE ALL ON FUNCTION public.logistics_apply_cart_swap(uuid[], jsonb) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_apply_cart_swap(uuid[], jsonb) TO service_role;
+
+-- 1. Autofix schrijft alleen een volledige, positieve Floriday-verpakking weg (0 = onbekend).
+CREATE OR REPLACE FUNCTION public.logistics_packing_autofix(p_limit integer DEFAULT 100)
+ RETURNS integer LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE r record; v_reden text; v_aantal integer := 0; v_ppc int; v_cpl int; v_lpc int;
+BEGIN
+  FOR r IN
+    SELECT d.* FROM public.logistics_packing_deviations d
+     WHERE d.resolved_at IS NULL AND d.scope = 'order_line' AND d.needs_human = false
+       AND d.order_id IS NOT NULL AND d.order_item_id IS NOT NULL
+     ORDER BY d.first_seen_at
+     LIMIT GREATEST(1, LEAST(p_limit, 500))
+  LOOP
+    v_reden := public.logistics_packing_block_reason(r.order_id, r.order_item_id);
+    IF v_reden IS NOT NULL THEN
+      UPDATE public.logistics_packing_deviations SET needs_human = true, human_reason = v_reden WHERE id = r.id;
+      CONTINUE;
+    END IF;
+    v_ppc := nullif(greatest(coalesce((r.floriday_packing->>'pieces_per_package')::numeric, 0), 0), 0)::int;
+    v_cpl := nullif(greatest(coalesce((r.floriday_packing->>'packages_per_layer')::numeric, 0), 0), 0)::int;
+    v_lpc := nullif(greatest(coalesce((r.floriday_packing->>'layers_per_load_carrier')::numeric, 0), 0), 0)::int;
+    IF v_ppc IS NULL OR v_cpl IS NULL OR v_lpc IS NULL THEN
+      UPDATE public.logistics_packing_deviations
+         SET needs_human = true,
+             human_reason = 'Floriday-verpakking onvolledig (0 of leeg = onbekend); niet automatisch overgenomen.'
+       WHERE id = r.id;
+      CONTINUE;
+    END IF;
+    UPDATE public.order_items oi
+       SET plants_per_crate = v_ppc, crates_per_layer = v_cpl, layers_per_cart = v_lpc
+     WHERE oi.id = r.order_item_id AND oi.packing_locked_at IS NULL;
+    IF FOUND THEN
+      v_aantal := v_aantal + 1;
+      UPDATE public.logistics_packing_deviations
+         SET auto_fixed_at = now(), resolved_at = now(), human_reason = 'automatisch bijgewerkt naar de Floriday-stand'
+       WHERE id = r.id;
+      PERFORM public.logistics_trace_event(r.order_id, 'stap:belading_synchronisatie', 'ok', 'belading bijgewerkt naar de Floriday-stand');
+    END IF;
+  END LOOP;
+  RETURN v_aantal;
+END;
+$function$;
+
+-- 9. Reconcile alleen bij een echte wijziging sinds de laatste afgeronde of geblokkeerde opdracht; kleinere porties.
+CREATE OR REPLACE FUNCTION public.logistics_reconcile_missing_plan_queue()
+ RETURNS integer LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE r record; n integer := 0;
+BEGIN
+  FOR r IN
+    SELECT o.id FROM public.orders o
+     WHERE o.deleted_at IS NULL
+       AND COALESCE(o.is_reservation,false) = false
+       AND o.plan_locked_at IS NULL
+       AND o.order_number IS NOT NULL
+       AND (o.created_at >= now() - interval '14 days' OR o.updated_at >= now() - interval '14 days')
+       AND NOT EXISTS (SELECT 1 FROM public.logistics_tasks t WHERE t.order_ref = o.order_number)
+       AND NOT EXISTS (SELECT 1 FROM public.logistics_plan_queue q
+                        WHERE q.order_id = o.id AND q.status IN ('pending','running'))
+       AND NOT EXISTS (
+         SELECT 1 FROM public.logistics_plan_queue q
+          WHERE q.order_id = o.id AND q.status IN ('geblokkeerd', 'done', 'opgelost')
+            AND q.updated_at >= COALESCE(o.updated_at, o.created_at)
+            AND NOT EXISTS (SELECT 1 FROM logistics_active.order_items oi WHERE oi.order_id = o.id AND oi.created_at > q.updated_at)
+            AND NOT EXISTS (SELECT 1 FROM logistics_active.order_items oi JOIN public.products p ON p.id = oi.product_id
+                             WHERE oi.order_id = o.id AND p.updated_at > q.updated_at))
+     ORDER BY o.created_at ASC
+     LIMIT 100
+  LOOP
+    PERFORM public.logistics_plan_enqueue(r.id, 'reconcile');
+    n := n + 1;
+  END LOOP;
+  RETURN n;
+END;
+$function$;
+
+-- 9. Eén open opdracht per order (index alleen als er geen dubbele open opdrachten zijn).
+DO $q$ BEGIN
+  IF NOT EXISTS (SELECT 1 FROM pg_indexes WHERE indexname = 'logistics_plan_queue_open_uniq') THEN
+    IF EXISTS (SELECT 1 FROM public.logistics_plan_queue WHERE status IN ('pending','running','geblokkeerd')
+                GROUP BY order_id HAVING count(*) > 1) THEN
+      RAISE NOTICE 'logistiek-engine: dubbele open planopdrachten; unieke index wacht op samenvoegen (akkoord nodig)';
+    ELSE
+      CREATE UNIQUE INDEX logistics_plan_queue_open_uniq ON public.logistics_plan_queue (order_id)
+        WHERE status IN ('pending','running','geblokkeerd');
+    END IF;
+  END IF;
+END $q$;
+
+-- Alleen-lezen lijst: orders met meer dan één open planopdracht.
+CREATE OR REPLACE FUNCTION public.logistics_plan_queue_dubbel()
+ RETURNS TABLE(order_id uuid, open_opdrachten bigint, oudste timestamptz, nieuwste timestamptz)
+ LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+  SELECT q.order_id, count(*), min(q.enqueued_at), max(q.enqueued_at)
+    FROM public.logistics_plan_queue q
+   WHERE q.status IN ('pending','running','geblokkeerd')
+   GROUP BY q.order_id HAVING count(*) > 1;
+$function$;
+REVOKE ALL ON FUNCTION public.logistics_plan_queue_dubbel() FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_plan_queue_dubbel() TO service_role;
+
+-- 10. Buffer uit: elke order krijgt een eigen buffer (sleutel solo:<order-id>) en wordt dus per order ingedeeld.
+CREATE OR REPLACE FUNCTION public.logistics_apply_buffer_decision(p_order_id uuid)
+ RETURNS uuid LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE
+  o public.orders%ROWTYPE;
+  cf jsonb; d jsonb; v_ref text; v_close timestamptz; v_key text;
+  v_buffer uuid; v_closed boolean; v_try int := 0; v_on_cart boolean; v_solo boolean := false;
+BEGIN
+  SELECT * INTO o FROM public.orders WHERE id = p_order_id;
+  IF NOT FOUND OR o.deleted_at IS NOT NULL THEN RETURN NULL; END IF;
+  cf := COALESCE(o.custom_fields, '{}'::jsonb);
+
+  IF public.logistics_order_buffer_excluded(o.id) THEN
+    IF o.buffer_id IS NOT NULL THEN
+      SELECT EXISTS (SELECT 1 FROM public.order_items oi
+                       JOIN logistics_active.order_cart_items ci ON ci.order_item_id = oi.id
+                       JOIN logistics_active.order_carts oc ON oc.id = ci.cart_id
+                      WHERE oi.order_id = o.id AND oc.buffer_id = o.buffer_id)
+        INTO v_on_cart;
+      IF NOT v_on_cart THEN
+        PERFORM set_config('logistics.buffer_writer', 'engine', true);
+        UPDATE public.orders SET buffer_id = NULL WHERE id = o.id;
+        BEGIN
+          INSERT INTO public.logistics_planner_trace(order_id, message)
+          VALUES (o.id, 'afgemeld; uit buffer gehaald');
+        EXCEPTION WHEN others THEN NULL; END;
+      END IF;
+    END IF;
+    RETURN NULL;
+  END IF;
+
+  d := public.logistics_buffer_decision(public.logistics_buffer_payload(o.id), NULL);
+
+  IF (d ->> 'reason') = 'buffering_disabled' THEN
+    v_solo := true;
+  ELSIF COALESCE((d ->> 'buffer')::boolean, false) IS NOT TRUE OR (d ->> 'bufferRef') IS NULL THEN
+    IF o.buffer_id IS NOT NULL THEN
+      UPDATE public.order_carts SET buffer_id = NULL WHERE order_id = o.id;
+      PERFORM set_config('logistics.buffer_writer', 'engine', true);
+      UPDATE public.orders SET buffer_id = NULL WHERE id = o.id;
+    END IF;
+    DELETE FROM public.order_buffers b
+     WHERE NOT EXISTS (SELECT 1 FROM public.orders x WHERE x.buffer_id = b.id)
+       AND NOT EXISTS (SELECT 1 FROM public.order_carts oc WHERE oc.buffer_id = b.id);
+    RETURN NULL;
+  END IF;
+
+  IF v_solo THEN
+    v_ref := 'solo:' || o.id::text;
+    v_close := NULL;
+  ELSE
+    v_ref := d ->> 'bufferRef';
+    BEGIN v_close := NULLIF(d ->> 'bufferCloseAt', '')::timestamptz;
+    EXCEPTION WHEN others THEN v_close := NULL; END;
+  END IF;
+
+  LOOP
+    v_key := CASE WHEN v_try = 0 THEN v_ref ELSE v_ref || '#' || v_try END;
+    SELECT id INTO v_buffer FROM public.order_buffers WHERE buffer_key = v_key;
+    IF v_buffer IS NULL THEN
+      INSERT INTO public.order_buffers (buffer_key, grouping_mode, pickup_date, pickup_location, customer_id, close_at)
+      VALUES (v_key, CASE WHEN v_solo THEN 'solo' ELSE 'engine' END,
+        COALESCE(cf ->> 'pickup_moment', cf ->> 'pickup_date', o.delivery_date::text),
+        COALESCE(cf ->> 'delivery_location_gln', cf ->> 'delivery_location_id', cf ->> 'delivery_location'),
+        o.customer_id, v_close)
+      ON CONFLICT (buffer_key) DO UPDATE SET grouping_mode = EXCLUDED.grouping_mode
+      RETURNING id INTO v_buffer;
+      EXIT;
+    END IF;
+    IF o.buffer_id = v_buffer OR v_solo THEN EXIT; END IF;
+
+    v_closed := public.logistics_buffer_closed_for_join(v_buffer);
+    IF NOT COALESCE(v_closed, false) THEN
+      UPDATE public.order_buffers
+         SET close_at = LEAST(COALESCE(close_at, v_close), COALESCE(v_close, close_at)), updated_at = now()
+       WHERE id = v_buffer;
+      EXIT;
+    END IF;
+    UPDATE public.order_buffers SET closed_at = COALESCE(closed_at, now()), updated_at = now() WHERE id = v_buffer;
+    v_try := v_try + 1; v_buffer := NULL;
+    IF v_try > 50 THEN RAISE EXCEPTION 'Kan geen open orderbuffer vinden voor sleutel %', v_ref; END IF;
+  END LOOP;
+
+  IF o.buffer_id IS DISTINCT FROM v_buffer THEN
+    PERFORM set_config('logistics.buffer_writer', 'engine', true);
+    UPDATE public.orders SET buffer_id = v_buffer WHERE id = o.id;
+    DELETE FROM public.order_buffers b
+     WHERE NOT EXISTS (SELECT 1 FROM public.orders x WHERE x.buffer_id = b.id)
+       AND NOT EXISTS (SELECT 1 FROM public.order_carts oc WHERE oc.buffer_id = b.id);
+  END IF;
+  RETURN v_buffer;
+END;
+$function$;
+
+-- 13. Eigen traystickers: zolang bij één regel van de order het fustaantal onbekend is, wachten ALLE
+--     eigen traystickers van die order ("Fustaantal van regel X onbekend"), zodat x van y klopt.
+CREATE OR REPLACE FUNCTION public.logistics_own_traysticker_sync(p_limit integer DEFAULT 200)
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE
+  s jsonb; v_tray text; v_rel text; v_station text;
+  r record; v_bron text; v_keep text[] := '{}'; v_wacht_orders uuid[] := '{}';
+  n int := 0; n_geblokkeerd int := 0; n_vrij int := 0; n_uit int := 0;
+BEGIN
+  SELECT settings INTO s FROM public.logistics_rule_configs
+   ORDER BY is_active DESC, (status = 'actief') DESC, updated_at DESC LIMIT 1;
+  v_tray := public.logistics_rule_text(s, 'pickstations', 'traysticker_release', 'uit');
+  IF v_tray = 'uit' THEN
+    RETURN jsonb_build_object('trayRelease', v_tray, 'regels', 0);
+  END IF;
+  v_rel := public.logistics_rule_text(s, 'pickstations', 'sticker_release', 'with_pick_release');
+  v_station := CASE WHEN v_rel = 'with_packing_slip'
+                    THEN public.logistics_rule_text(s, 'pickstations', 'packing_slip_station', '')
+                    ELSE public.logistics_rule_text(s, 'pickstations', 'sticker_station', '') END;
+
+  FOR r IN
+    WITH regels AS (
+      SELECT o.id AS order_id, o.order_number, ci.cart_id, ci.id AS ci_id, ci.crates, ci.created_at,
+             coalesce(ci.product_name, oi.product_name, 'onbekend') AS regelnaam
+        FROM public.orders o
+        JOIN public.order_items oi ON oi.order_id = o.id
+        JOIN public.order_cart_items ci ON ci.order_item_id = oi.id
+       WHERE coalesce(o.order_source, '') <> 'floriday'
+         AND o.deleted_at IS NULL AND o.cancelled_at IS NULL
+         AND coalesce(o.status, '') <> 'geannuleerd'
+         AND oi.quarantined_at IS NULL
+         AND o.delivery_date >= current_date - 1
+    )
+    SELECT g.*,
+           (SELECT min(x.regelnaam) FROM regels x WHERE x.order_id = g.order_id AND coalesce(x.crates, 0) <= 0) AS onbekende_regel
+      FROM regels g
+     ORDER BY g.order_number, g.cart_id, g.created_at, g.ci_id
+     LIMIT greatest(1, p_limit)
+  LOOP
+    IF r.onbekende_regel IS NOT NULL THEN
+      v_wacht_orders := v_wacht_orders || r.order_id;
+      v_bron := r.order_id::text || ':fustaantal-onbekend';
+      v_keep := v_keep || v_bron;
+      INSERT INTO public.logistics_sticker_prints (soort, bron_id, order_id, order_number, cart_id, kopieen, status, reden)
+      VALUES ('eigen_traysticker', v_bron, r.order_id, r.order_number, NULL, 1, 'geblokkeerd',
+              'Fustaantal van regel ' || r.onbekende_regel || ' onbekend. Alle traystickers van deze order wachten, zodat de nummering klopt.')
+      ON CONFLICT DO NOTHING;
+      n_geblokkeerd := n_geblokkeerd + 1;
+      CONTINUE;
+    END IF;
+    FOR k IN 1 .. r.crates LOOP
+      v_bron := r.order_id::text || ':' || r.cart_id::text || ':' || r.ci_id::text || ':' || k::text;
+      v_keep := v_keep || v_bron;
+      INSERT INTO public.logistics_sticker_prints (soort, bron_id, order_id, order_number, cart_id, kopieen, print_plek_id, status, reden)
+      VALUES ('eigen_traysticker', v_bron, r.order_id, r.order_number, r.cart_id, 1,
+              public.logistics_sticker_cart_plek(r.cart_id, v_station), 'wacht_op_moment', 'Wacht op de pakbon van deze kar.')
+      ON CONFLICT DO NOTHING;
+      -- Was hij eerder tegengehouden door een onbekend fustaantal: weer laten wachten op het moment.
+      UPDATE public.logistics_sticker_prints
+         SET status = 'wacht_op_moment', reden = 'Wacht op de pakbon van deze kar.', updated_at = now()
+       WHERE soort = 'eigen_traysticker' AND bron_id = v_bron AND status = 'geblokkeerd'
+         AND reden LIKE 'Fustaantal van regel %';
+      n := n + 1;
+    END LOOP;
+  END LOOP;
+
+  -- Order met onbekend fustaantal: alle nog niet geprinte stickers wachten (niet vervallen).
+  UPDATE public.logistics_sticker_prints p
+     SET status = 'geblokkeerd',
+         reden = (SELECT b.reden FROM public.logistics_sticker_prints b
+                   WHERE b.soort = 'eigen_traysticker' AND b.bron_id = p.order_id::text || ':fustaantal-onbekend' LIMIT 1),
+         updated_at = now()
+   WHERE p.soort = 'eigen_traysticker' AND p.status IN ('wacht_op_moment', 'klaar')
+     AND p.order_id = ANY (v_wacht_orders);
+  v_keep := v_keep || ARRAY(SELECT p.bron_id FROM public.logistics_sticker_prints p
+                             WHERE p.soort = 'eigen_traysticker' AND p.order_id = ANY (v_wacht_orders)
+                               AND p.reden LIKE 'Fustaantal van regel %');
+
+  UPDATE public.logistics_sticker_prints p
+     SET status = 'niet_printen', reden = 'Fust hoort niet meer bij deze kar of order vervallen.', updated_at = now()
+   WHERE p.soort = 'eigen_traysticker' AND p.status IN ('wacht_op_moment', 'geblokkeerd', 'klaar')
+     AND NOT (p.bron_id = ANY (v_keep))
+     AND p.order_id IN (SELECT o.id FROM public.orders o WHERE o.delivery_date >= current_date - 1);
+  GET DIAGNOSTICS n_uit = ROW_COUNT;
+
+  UPDATE public.logistics_sticker_prints p
+     SET status = 'klaar', reden = NULL,
+         print_plek_id = coalesce(p.print_plek_id, public.logistics_sticker_cart_plek(p.cart_id, v_station)),
+         updated_at = now()
+   WHERE p.soort = 'eigen_traysticker' AND p.status = 'wacht_op_moment'
+     AND p.cart_id IS NOT NULL AND public.logistics_cart_slip_queued(p.cart_id);
+  GET DIAGNOSTICS n_vrij = ROW_COUNT;
+
+  RETURN jsonb_build_object('trayRelease', v_tray, 'fusten', n, 'geblokkeerd', n_geblokkeerd, 'vrijgegeven', n_vrij, 'niet_printen', n_uit);
+END; $function$;
+REVOKE ALL ON FUNCTION public.logistics_own_traysticker_sync(integer) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_own_traysticker_sync(integer) TO service_role;