@flowselections/logistiek-engine 1.0.193 → 1.0.199

package/db/schema/logistiek-engine.sql

@@ -13,6 +13,25 @@
 -- Gegenereerd uit de database; niet met de hand bewerken.
 -- ============================================================================
 
+-- 1.0.196: vroege definitie van de toegangscontrole, zodat SQL-functies verderop
+-- bij een eerste installatie (lege database) al kunnen verwijzen. Identiek aan de
+-- definitie verderop; die blijft leidend.
+CREATE OR REPLACE FUNCTION public.logistics_acc_guard(p_level text, p_fn text)
+ RETURNS void LANGUAGE plpgsql STABLE SET search_path TO 'public'
+AS $function$
+BEGIN
+  IF public.logistics_acc_is_server() THEN RETURN; END IF;
+  IF pg_trigger_depth() > 0 THEN RETURN; END IF;
+  IF NOT public.logistics_acc_direct(p_fn) THEN RETURN; END IF;
+  IF p_level = 'ingelogd' AND auth.uid() IS NOT NULL THEN RETURN; END IF;
+  IF p_level = 'beheer' AND auth.uid() IS NOT NULL AND public.logistics_is_beheer() THEN RETURN; END IF;
+  RAISE EXCEPTION '%', CASE p_level
+      WHEN 'server' THEN 'Geen toegang: ' || p_fn || ' is alleen voor de server.'
+      WHEN 'beheer' THEN 'Geen toegang: ' || p_fn || ' is alleen voor beheer.'
+      ELSE 'Geen toegang: log in om ' || p_fn || ' te gebruiken.' END
+    USING ERRCODE = '42501';
+END $function$;
+
 SET check_function_bodies = off;
 
 DO $fs$ BEGIN
@@ -26902,7 +26921,7 @@ BEGIN
        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
+       AND public.logistics_order_date(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
@@ -26989,14 +27008,12 @@ $function$;
 -- 6. Pakbon van het pickstation: alleen de centrale beslisregel (geen layout uit payload of werkwijze).
 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;
+-- 1.0.197: rechten van logistics_document_for_order staan direct na de definitie (verderop).
 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).
@@ -27813,13 +27830,19 @@ BEGIN
     'documenttype', v_type, 'breedte_mm', v_l.breedte_mm, 'hoogte_mm', v_l.hoogte_mm, 'reden', NULL) || v_extra;
 END;
 $function$;
+-- 1.0.197: rechten na de definitie (een nieuwe Shell kent de functie hiervoor nog niet).
+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;
+ALTER FUNCTION public.logistics_document_for_order(uuid, text) SECURITY INVOKER;
 
 
 -- ===== 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();
+  IF to_regprocedure('public.control_get_todays_carts()') IS NOT NULL THEN
+    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 IF;
 END $m$;
 
@@ -28396,7 +28419,7 @@ BEGIN
          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
+         AND public.logistics_order_date(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
@@ -28445,7 +28468,7 @@ BEGIN
      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);
+     AND p.order_id IN (SELECT o.id FROM public.orders o WHERE public.logistics_order_date(o.delivery_date) >= current_date - 1);
   GET DIAGNOSTICS n_uit = ROW_COUNT;
 
   UPDATE public.logistics_sticker_prints p
@@ -28679,7 +28702,7 @@ BEGIN
       FROM public.orders o
       JOIN public.floriday_salesorders_cache s ON s.floriday_id = o.floriday_sales_order_id AND NOT coalesce(s.is_deleted,false)
       CROSS JOIN LATERAL jsonb_array_elements(CASE WHEN jsonb_typeof(s.data->'additionalServices') = 'array' THEN s.data->'additionalServices' ELSE '[]'::jsonb END) e
-     WHERE o.deleted_at IS NULL AND o.delivery_date >= current_date - 2
+     WHERE o.deleted_at IS NULL AND public.logistics_order_date(o.delivery_date) >= current_date - 2
        AND upper(coalesce(e->>'unit','')) = 'LABEL' AND (e->>'numberOfUnits') ~ '^\d+$'
        AND nullif(btrim(coalesce(e->>'stickerId','')),'') IS NOT NULL
        AND NOT EXISTS (SELECT 1 FROM public.floriday_customer_stickers_cache c WHERE c.floriday_id = e->>'stickerId')
@@ -28713,7 +28736,7 @@ BEGIN
       SELECT o.id, o.order_number, nullif(btrim(o.floriday_sales_order_id),'') AS sales
         FROM public.orders o
        WHERE o.deleted_at IS NULL AND nullif(btrim(o.floriday_sales_order_id),'') IS NOT NULL
-         AND o.delivery_date >= current_date - 2
+         AND public.logistics_order_date(o.delivery_date) >= current_date - 2
          AND EXISTS (SELECT 1 FROM logistics_active.order_carts oc WHERE oc.order_id = o.id)
        ORDER BY o.delivery_date LIMIT greatest(p_limit,1)
     LOOP
@@ -29987,6 +30010,8 @@ DO $fs$ DECLARE f text; BEGIN
       'logistics_set_order_carrier(uuid,uuid)','logistics_carrier_status()','logistics_carrier_set_backfill(boolean)',
       'logistics_carrier_preview_existing(integer)','logistics_carrier_promote_oud(uuid[],integer)',
       'logistics_order_carrier_label(uuid)','logistics_install_check()','logistics_order_departure(uuid)','logistics_resolve_carrier_for_location_many(jsonb)'] LOOP
+    -- 1.0.197: in een nieuwe Shell kan een functie hier nog ontbreken (verderop gedefinieerd, eigen rechten daar).
+    CONTINUE WHEN to_regprocedure('public.' || f) IS NULL;
     EXECUTE format('REVOKE ALL ON FUNCTION public.%s FROM PUBLIC, anon', f);
     EXECUTE format('GRANT EXECUTE ON FUNCTION public.%s TO authenticated, service_role', f);
   END LOOP;
@@ -30005,9 +30030,10 @@ END $fs$;
 -- 1.0.184: karrenlijst toont de vervoerder uit orders.carrier_id (achteraan toegevoegd).
 -- "Eigen vervoer" en "Afhalen" op carrier_kind / self_pickup, nooit op naam.
 DO $m$ BEGIN
-  IF to_regprocedure('public.control_get_todays_carts()') IS NOT NULL
-     AND pg_get_function_result('public.control_get_todays_carts()'::regprocedure) NOT LIKE '%carrier_name%' THEN
-    DROP FUNCTION public.control_get_todays_carts();
+  IF to_regprocedure('public.control_get_todays_carts()') IS NOT NULL THEN
+    IF pg_get_function_result('public.control_get_todays_carts()'::regprocedure) NOT LIKE '%carrier_name%' THEN
+      DROP FUNCTION public.control_get_todays_carts();
+    END IF;
   END IF;
 END $m$;
 
@@ -31832,3 +31858,2746 @@ BEGIN
 END $$;
 REVOKE ALL ON FUNCTION public.logistics_schedule_tasks_batch(jsonb) FROM PUBLIC, anon;
 GRANT EXECUTE ON FUNCTION public.logistics_schedule_tasks_batch(jsonb) TO authenticated, service_role;
+
+-- ===== 1.0.194: stickers, direct indelen, lichte ronde, printstatus (db/migrations/20261026110000) =====
+-- Logistiek Engine 1.0.194: stickers werken weer, direct indelen, lichte minuutronde, printstatus volgt print_jobs.
+-- Additief: CREATE OR REPLACE / IF NOT EXISTS; triggers via DO-blok met bestaan-check; geen REVOKE/DROP/cron.schedule.
+SET check_function_bodies = off;
+
+-- A1: leverdatum (tekst) veilig als datum lezen. NULL als het geen geldige YYYY-MM-DD is.
+CREATE OR REPLACE FUNCTION public.logistics_order_date(p text)
+RETURNS date LANGUAGE plpgsql IMMUTABLE PARALLEL SAFE SET search_path TO 'public' AS $$
+BEGIN
+  IF p IS NULL OR p !~ '^\d{4}-\d{2}-\d{2}' THEN RETURN NULL; END IF;
+  RETURN left(p, 10)::date;
+EXCEPTION WHEN OTHERS THEN
+  RETURN NULL;
+END $$;
+CREATE OR REPLACE FUNCTION public.logistics_order_date(p date)
+RETURNS date LANGUAGE sql IMMUTABLE PARALLEL SAFE SET search_path TO 'public' AS $$ SELECT p $$;
+
+-- B7: is de order geannuleerd? Werkt ook als cancelled_at/status in deze shell ontbreken.
+CREATE OR REPLACE FUNCTION public.logistics_order_geannuleerd(p_order_id uuid)
+RETURNS boolean LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE j jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_order_geannuleerd');
+  SELECT to_jsonb(o) INTO j FROM public.orders o WHERE o.id = p_order_id;
+  IF j IS NULL THEN RETURN false; END IF;
+  RETURN (j->>'cancelled_at') IS NOT NULL
+      OR lower(coalesce(j->>'status', '')) IN ('cancelled', 'canceled', 'geannuleerd');
+END $$;
+
+-- Toestand per minuutronde (watermerken) en vastlegging per wek-aanroep.
+CREATE TABLE IF NOT EXISTS public.logistics_tick_state (
+  key text PRIMARY KEY,
+  value jsonb NOT NULL DEFAULT '{}'::jsonb,
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+GRANT SELECT ON public.logistics_tick_state TO authenticated;
+GRANT ALL ON public.logistics_tick_state TO service_role;
+ALTER TABLE public.logistics_tick_state ENABLE ROW LEVEL SECURITY;
+DO $p$ BEGIN
+  IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE schemaname='public' AND tablename='logistics_tick_state' AND policyname='Beheer leest rondetoestand') THEN
+    CREATE POLICY "Beheer leest rondetoestand" ON public.logistics_tick_state FOR SELECT TO authenticated USING (public.logistics_is_beheer());
+  END IF;
+END $p$;
+
+CREATE TABLE IF NOT EXISTS public.logistics_kick_log (
+  id bigserial PRIMARY KEY,
+  kicked_at timestamptz NOT NULL DEFAULT clock_timestamp(),
+  request_id bigint,
+  skipped_reason text,
+  round_started_at timestamptz
+);
+CREATE INDEX IF NOT EXISTS logistics_kick_log_kicked_at_idx ON public.logistics_kick_log (kicked_at DESC);
+GRANT SELECT ON public.logistics_kick_log TO authenticated;
+GRANT ALL ON public.logistics_kick_log TO service_role;
+GRANT USAGE, SELECT ON SEQUENCE public.logistics_kick_log_id_seq TO service_role;
+ALTER TABLE public.logistics_kick_log ENABLE ROW LEVEL SECURITY;
+DO $p$ BEGIN
+  IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE schemaname='public' AND tablename='logistics_kick_log' AND policyname='Beheer leest wek-aanroepen') THEN
+    CREATE POLICY "Beheer leest wek-aanroepen" ON public.logistics_kick_log FOR SELECT TO authenticated USING (public.logistics_is_beheer());
+  END IF;
+END $p$;
+
+-- B2: time-out van de aanroep naar de Shell. Standaard 30000 ms; ongeldige waarde = luide fout.
+CREATE OR REPLACE FUNCTION public.logistics_tick_timeout_ms()
+RETURNS integer LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v text; n int;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_tick_timeout_ms');
+  SELECT NULLIF(btrim(value), '') INTO v FROM public.module_runtime_config WHERE key = 'logistics_tick_timeout_ms';
+  IF v IS NULL THEN RETURN 30000; END IF;
+  IF v !~ '^\d{3,6}$' THEN
+    RAISE EXCEPTION 'logistics_tick_timeout_ms in module_runtime_config is ongeldig (%); verwacht een getal in milliseconden', v;
+  END IF;
+  n := v::int;
+  IF n < 1000 OR n > 120000 THEN
+    RAISE EXCEPTION 'logistics_tick_timeout_ms (%) valt buiten 1000–120000 ms', n;
+  END IF;
+  RETURN n;
+END $$;
+
+-- Instellingen aanvullen (idempotent). Bestaande waarden blijven, behalve de oude claim-timeout 10.
+CREATE OR REPLACE FUNCTION public.logistics_ensure_tick_settings()
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_t int := 0; v_c int := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_ensure_tick_settings');
+  INSERT INTO public.module_runtime_config (key, value, updated_at)
+  VALUES ('logistics_tick_timeout_ms', '30000', now())
+  ON CONFLICT (key) DO NOTHING;
+  GET DIAGNOSTICS v_t = ROW_COUNT;
+  INSERT INTO public.logistics_plan_settings (key, value, updated_at)
+  VALUES ('claim_timeout_minutes', '2', now())
+  ON CONFLICT (key) DO UPDATE SET value = '2', updated_at = now()
+   WHERE NULLIF(btrim(public.logistics_plan_settings.value), '') IS NULL
+      OR btrim(public.logistics_plan_settings.value) = '10';
+  GET DIAGNOSTICS v_c = ROW_COUNT;
+  RETURN jsonb_build_object('timeoutIngesteld', v_t > 0, 'claimTimeoutBijgewerkt', v_c > 0);
+END $$;
+
+-- B5: periodieke ensure-stappen hooguit 1× per uur.
+CREATE OR REPLACE FUNCTION public.logistics_ensure_periodiek()
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_last timestamptz; v_r jsonb := '{}'::jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_ensure_periodiek');
+  SELECT (value->>'at')::timestamptz INTO v_last FROM public.logistics_tick_state WHERE key = 'ensure_periodiek';
+  IF v_last IS NOT NULL AND v_last > now() - interval '1 hour' THEN
+    RETURN jsonb_build_object('overgeslagen', 'binnen het uur', 'laatst', v_last);
+  END IF;
+  v_r := v_r || jsonb_build_object('rebuffer', public.logistics_ensure_rebuffer_setting());
+  v_r := v_r || jsonb_build_object('tick', public.logistics_ensure_tick_settings());
+  INSERT INTO public.logistics_tick_state(key, value, updated_at)
+  VALUES ('ensure_periodiek', jsonb_build_object('at', now()) || v_r, now())
+  ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+  RETURN v_r;
+END $$;
+
+-- B3: laadtoestand alleen bij wijziging in planwachtrij/taken, anders hooguit elke 5 minuten.
+CREATE OR REPLACE FUNCTION public.logistics_refresh_plan_state_als_nodig()
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_wm timestamptz; v_prev timestamptz; v_at timestamptz; v_res jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_refresh_plan_state_als_nodig');
+  SELECT greatest((SELECT max(updated_at) FROM public.logistics_plan_queue),
+                  (SELECT max(updated_at) FROM public.logistics_tasks)) INTO v_wm;
+  SELECT (value->>'wm')::timestamptz, (value->>'at')::timestamptz INTO v_prev, v_at
+    FROM public.logistics_tick_state WHERE key = 'refresh_plan_state';
+  IF v_at IS NOT NULL AND v_wm IS NOT DISTINCT FROM v_prev AND v_at > now() - interval '5 minutes' THEN
+    RETURN jsonb_build_object('overgeslagen', 'geen wijziging');
+  END IF;
+  v_res := public.logistics_refresh_plan_state(p_limit => 500);
+  INSERT INTO public.logistics_tick_state(key, value, updated_at)
+  VALUES ('refresh_plan_state', jsonb_build_object('wm', v_wm, 'at', now()), now())
+  ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+  RETURN v_res;
+END $$;
+
+-- B1: een wek-aanroep tijdens een lopende ronde oppakken vóór het slot vrijgaat.
+CREATE OR REPLACE FUNCTION public.logistics_kick_pending_take(p_since timestamptz)
+RETURNS boolean LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_val timestamptz;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_kick_pending_take');
+  SELECT NULLIF(s.value, '')::timestamptz INTO v_val FROM public.logistics_plan_settings s
+   WHERE s.key = 'kick_pending' FOR UPDATE;
+  IF v_val IS NULL THEN RETURN false; END IF;
+  UPDATE public.logistics_plan_settings s SET value = '', updated_at = now() WHERE s.key = 'kick_pending';
+  RETURN v_val IS NOT NULL AND v_val >= p_since;
+END $$;
+
+-- B0: start van de ronde koppelen aan de wek-aanroepen die erop wachtten.
+CREATE OR REPLACE FUNCTION public.logistics_kick_round_start()
+RETURNS integer LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE n int;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_kick_round_start');
+  UPDATE public.logistics_kick_log SET round_started_at = clock_timestamp()
+   WHERE round_started_at IS NULL AND kicked_at > now() - interval '2 minutes';
+  GET DIAGNOSTICS n = ROW_COUNT;
+  RETURN n;
+END $$;
+
+-- B0: meting per wek-aanroep: tijd wek, verzoek-id, antwoord van pg_net, start ronde.
+CREATE OR REPLACE FUNCTION public.logistics_kick_metingen(p_limit integer)
+RETURNS TABLE(kicked_at timestamptz, request_id bigint, skipped_reason text, antwoord_at timestamptz,
+              status_code integer, time_out boolean, fout text, round_started_at timestamptz,
+              wacht_tot_antwoord_ms integer, wacht_tot_ronde_ms integer)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_kick_metingen');
+  IF to_regclass('net._http_response') IS NULL THEN
+    RETURN QUERY SELECT k.kicked_at, k.request_id, k.skipped_reason, NULL::timestamptz, NULL::int, NULL::boolean,
+                        NULL::text, k.round_started_at, NULL::int,
+                        (extract(epoch FROM k.round_started_at - k.kicked_at) * 1000)::int
+                   FROM public.logistics_kick_log k ORDER BY k.kicked_at DESC LIMIT least(greatest(coalesce(p_limit, 50), 1), 500);
+    RETURN;
+  END IF;
+  RETURN QUERY EXECUTE $q$
+    SELECT k.kicked_at, k.request_id, k.skipped_reason, r.created, r.status_code, r.timed_out,
+           left(r.error_msg, 200), k.round_started_at,
+           (extract(epoch FROM r.created - k.kicked_at) * 1000)::int,
+           (extract(epoch FROM k.round_started_at - k.kicked_at) * 1000)::int
+      FROM public.logistics_kick_log k
+      LEFT JOIN net._http_response r ON r.id = k.request_id
+     ORDER BY k.kicked_at DESC LIMIT $1$q$ USING least(greatest(coalesce(p_limit, 50), 1), 500);
+END $$;
+
+-- A3: uitkomst van de HTTP-ronde (stickers) vastleggen in logistics_tick_runs.steps en rondetoestand.
+CREATE OR REPLACE FUNCTION public.logistics_tick_http_log(p_steps jsonb)
+RETURNS void LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_fouten jsonb := coalesce(p_steps->'stickerSyncFouten', '[]'::jsonb);
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_tick_http_log');
+  INSERT INTO public.logistics_tick_runs(started_at, finished_at, duration_ms, has_error, steps)
+  VALUES (coalesce((p_steps->>'gestart')::timestamptz, now()), now(),
+          nullif(p_steps->>'duurMs', '')::int,
+          jsonb_typeof(v_fouten) = 'array' AND jsonb_array_length(v_fouten) > 0,
+          jsonb_build_object('bron', 'http') || p_steps);
+  INSERT INTO public.logistics_tick_state(key, value, updated_at)
+  VALUES ('sticker_sync', jsonb_build_object('at', now(), 'fouten', v_fouten), now())
+  ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+END $$;
+
+-- C3: loopt er een (niet verlopen) pakbonopdracht voor deze order? Zelfde filter als logistics_cart_is_frozen.
+CREATE OR REPLACE FUNCTION public.logistics_order_print_actief(p_order_number text)
+RETURNS boolean LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v boolean;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_order_print_actief');
+  IF p_order_number IS NULL OR to_regclass('public.print_jobs') IS NULL THEN RETURN false; END IF;
+  EXECUTE $q$
+    SELECT EXISTS (
+      SELECT 1 FROM public.print_jobs pj
+       WHERE pj.documenttype::text = 'pakbon'
+         AND COALESCE(pj.is_herprint, false) = false
+         AND pj.status::text IN ('wachtend', 'bezig', 'voltooid')
+         AND COALESCE(pj.foutcode, '') NOT IN ('verlopen', 'expired')
+         AND COALESCE(pj.verwerkingsfase, '') NOT IN ('verlopen', 'expired')
+         AND (EXISTS (SELECT 1 FROM public.pick_queue q WHERE q.print_job_id = pj.id AND q.order_number = $1 AND q.cancelled_at IS NULL)
+              OR pj.payload->>'cart_id' IN (SELECT oc.id::text FROM logistics_active.order_carts oc
+                                              JOIN public.orders o ON o.id = oc.order_id WHERE o.order_number = $1)))$q$
+    INTO v USING p_order_number;
+  RETURN coalesce(v, false);
+END $$;
+
+-- C4: printstatus in batch (max. 500 ids, één rij per id).
+CREATE OR REPLACE FUNCTION public.logistics_print_status(p_queue_item_ids uuid[])
+RETURNS TABLE(queue_item_id uuid, status text, printnode_status text, fase text, fase_gestart_op timestamptz, melding text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_fgo text; v_log text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_print_status');
+  IF coalesce(cardinality(p_queue_item_ids), 0) > 500 THEN
+    RAISE EXCEPTION 'logistics_print_status: maximaal 500 ids per aanroep (gekregen: %)', cardinality(p_queue_item_ids)
+      USING ERRCODE = '22023';
+  END IF;
+  IF coalesce(cardinality(p_queue_item_ids), 0) = 0 THEN RETURN; END IF;
+  IF to_regclass('public.print_jobs') IS NULL THEN
+    RETURN QUERY SELECT u.id, 'geen_printmodule'::text, NULL::text, NULL::text, NULL::timestamptz,
+                        'De printmodule is in deze omgeving niet geïnstalleerd.'::text
+                   FROM (SELECT DISTINCT x AS id FROM unnest(p_queue_item_ids) x) u;
+    RETURN;
+  END IF;
+  -- fase_gestart_op komt van Layouts; alleen lezen als de kolom bestaat.
+  v_fgo := CASE WHEN EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='public'
+                               AND table_name='print_jobs' AND column_name='fase_gestart_op')
+                THEN 'pj.fase_gestart_op' ELSE 'NULL::timestamptz' END;
+  -- 'fase' = print_jobs.verwerkingsfase; ontbreekt die, dan de laatste print_job_logs-gebeurtenis.
+  v_log := CASE WHEN to_regclass('public.print_job_logs') IS NOT NULL
+                THEN 'SELECT l.gebeurtenis FROM public.print_job_logs l WHERE l.job_id = pj.id ORDER BY l.created_at DESC LIMIT 1'
+                ELSE 'SELECT NULL::text AS gebeurtenis' END;
+  RETURN QUERY EXECUTE format($q$
+    SELECT u.id,
+           CASE WHEN q.id IS NULL THEN 'onbekende_regel'
+                WHEN pj.id IS NULL THEN 'geen_opdracht'
+                ELSE pj.status::text END,
+           pj.printnode_status,
+           COALESCE(NULLIF(pj.verwerkingsfase, ''), lg.gebeurtenis),
+           %s,
+           COALESCE(NULLIF(pj.foutmelding, ''), NULLIF(pj.printnode_bericht, ''))
+      FROM (SELECT DISTINCT x AS id FROM unnest($1) x) u
+      LEFT JOIN public.pick_queue q ON q.id = u.id
+      LEFT JOIN public.print_jobs pj ON pj.id = q.print_job_id
+      LEFT JOIN LATERAL (%s) lg ON true$q$, v_fgo, v_log)
+    USING p_queue_item_ids;
+END $$;
+
+-- C2: printed_at/print_count volgen de echte uitkomst van de printopdracht.
+CREATE OR REPLACE FUNCTION public.logistics_print_job_voltooid_trg()
+RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  IF NEW.status::text = 'voltooid' AND (TG_OP = 'INSERT' OR OLD.status IS DISTINCT FROM NEW.status) THEN
+    UPDATE public.pick_queue q
+       SET printed_at = COALESCE(NEW.voltooid_op, now()),
+           print_count = CASE WHEN q.printed_at IS NULL OR q.printed_at < NEW.created_at
+                              THEN COALESCE(q.print_count, 0) + 1 ELSE q.print_count END,
+           updated_at = now()
+     WHERE q.print_job_id = NEW.id
+       AND q.printed_at IS DISTINCT FROM COALESCE(NEW.voltooid_op, now());
+  END IF;
+  RETURN NEW;
+EXCEPTION WHEN OTHERS THEN
+  -- Een printopdracht mag nooit mislukken door deze bijwerking; wel zichtbaar maken.
+  BEGIN
+    INSERT INTO public.logistics_trace_events(phase, step, status, reason)
+    VALUES ('printen', 'printed_at bijwerken na voltooid', 'mislukt', left(SQLERRM, 300));
+  EXCEPTION WHEN OTHERS THEN NULL; END;
+  RETURN NEW;
+END $$;
+
+DO $t$ BEGIN
+  IF to_regclass('public.print_jobs') IS NULL THEN
+    RAISE NOTICE 'logistiek-engine: print_jobs ontbreekt; printstatus-trigger wordt aangemaakt zodra de printmodule er is (opnieuw draaien)';
+  ELSIF NOT EXISTS (SELECT 1 FROM pg_trigger WHERE tgname = 'trg_logistics_print_job_voltooid' AND tgrelid = 'public.print_jobs'::regclass) THEN
+    CREATE TRIGGER trg_logistics_print_job_voltooid
+      AFTER INSERT OR UPDATE OF status ON public.print_jobs
+      FOR EACH ROW EXECUTE FUNCTION public.logistics_print_job_voltooid_trg();
+  END IF;
+END $t$;
+
+-- Installatiecontrole 1.0.194.
+CREATE OR REPLACE FUNCTION public.logistics_install_check_194()
+RETURNS TABLE(onderdeel text, ok boolean, toelichting text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v jsonb; v_at timestamptz; n int; v_pc boolean;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_install_check_194');
+  SELECT value INTO v FROM public.logistics_tick_state WHERE key = 'sticker_sync';
+  v_at := (v->>'at')::timestamptz;
+  onderdeel := 'Engine: sticker-sync laatste run zonder fout';
+  ok := v IS NOT NULL AND jsonb_array_length(coalesce(v->'fouten', '[]'::jsonb)) = 0 AND v_at > now() - interval '15 minutes';
+  toelichting := CASE WHEN v IS NULL THEN 'nog geen ronde vastgelegd (1.0.194 of nieuwer moet draaien)'
+                      WHEN v_at <= now() - interval '15 minutes' THEN 'laatste ronde ' || to_char(v_at, 'DD-MM HH24:MI') || ' (ouder dan 15 min)'
+                      WHEN ok THEN 'geen fouten (' || to_char(v_at, 'HH24:MI:SS') || ')'
+                      ELSE 'fout: ' || left((v->'fouten')::text, 300) END;
+  RETURN NEXT;
+
+  onderdeel := 'Engine: wek-aanroep gaat niet verloren (kick_pending-mechanisme aanwezig)';
+  ok := EXISTS (SELECT 1 FROM pg_proc WHERE pronamespace='public'::regnamespace AND proname='logistics_plan_kick' AND prosrc LIKE '%kick_pending%')
+    AND to_regprocedure('public.logistics_kick_pending_take(timestamptz)') IS NOT NULL;
+  toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Engine 1.0.194 via schemasync' END; RETURN NEXT;
+
+  onderdeel := 'Engine: tick-aanroep heeft eigen time-out';
+  SELECT count(*) INTO n FROM pg_proc WHERE pronamespace='public'::regnamespace
+     AND proname IN ('logistics_plan_kick', 'logistics_recalc_tick_kick') AND prosrc LIKE '%timeout_milliseconds%';
+  ok := n = 2;
+  BEGIN
+    toelichting := CASE WHEN ok THEN public.logistics_tick_timeout_ms() || ' ms' ELSE n || ' van 2 aanroepen met time-out' END;
+  EXCEPTION WHEN OTHERS THEN ok := false; toelichting := SQLERRM; END;
+  RETURN NEXT;
+
+  onderdeel := 'Engine: claim-timeout ≤ 3 min';
+  BEGIN
+    n := public.logistics_plan_setting('claim_timeout_minutes', 2)::int;
+    ok := n <= 3; toelichting := n || ' min';
+  EXCEPTION WHEN OTHERS THEN ok := false; toelichting := SQLERRM; END;
+  RETURN NEXT;
+
+  onderdeel := 'Engine: printstatus-trigger aanwezig';
+  ok := to_regclass('public.print_jobs') IS NOT NULL
+    AND EXISTS (SELECT 1 FROM pg_trigger WHERE tgname = 'trg_logistics_print_job_voltooid' AND tgrelid = 'public.print_jobs'::regclass);
+  toelichting := CASE WHEN to_regclass('public.print_jobs') IS NULL THEN 'print_jobs ontbreekt (printmodule niet geïnstalleerd)'
+                      WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: schemabestand opnieuw draaien' END;
+  RETURN NEXT;
+
+  -- printed_at volgt print_jobs pas echt als geen enkele functie hem nog bij het aanmaken zet.
+  SELECT EXISTS (SELECT 1 FROM pg_proc WHERE pronamespace='public'::regnamespace
+                  AND proname IN ('pick_complete_print', 'pick_complete_print_cart', 'pick_complete_print_carts')
+                  AND prosrc ~* 'printed_at\s*=\s*(now|clock_timestamp)') INTO v_pc;
+  onderdeel := 'Engine: printed_at volgt print_jobs';
+  ok := to_regprocedure('public.logistics_print_job_voltooid_trg()') IS NOT NULL AND NOT v_pc;
+  toelichting := CASE WHEN ok THEN 'printed_at wordt alleen gezet bij status voltooid'
+                      WHEN v_pc THEN 'Engine-trigger aanwezig, maar Pickschermen (pick_complete_print*) zet printed_at nog bij het aanmaken'
+                      ELSE 'ontbreekt: Engine 1.0.194' END;
+  RETURN NEXT;
+
+  onderdeel := 'Engine: leverdatum veilig als datum (logistics_order_date)';
+  ok := to_regprocedure('public.logistics_order_date(text)') IS NOT NULL
+    AND NOT EXISTS (SELECT 1 FROM pg_proc WHERE pronamespace='public'::regnamespace
+                     AND proname IN ('logistics_sticker_sync','logistics_own_sticker_sync','logistics_own_traysticker_sync')
+                     AND prosrc ~ '\mo\.delivery_date\s*>=');
+  toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'sticker-sync vergelijkt leverdatum nog als tekst' END; RETURN NEXT;
+END $$;
+
+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
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_own_sticker_sync');
+  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 public.logistics_order_date(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;
+
+  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;
+
+  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$
+;
+
+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
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_own_traysticker_sync');
+  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 public.logistics_order_date(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;
+      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;
+
+  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 public.logistics_order_date(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$
+;
+
+CREATE OR REPLACE FUNCTION public.logistics_sticker_sync(p_limit integer DEFAULT 200)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  s jsonb; v_rel text; v_station text; v_tray text;
+  st record; r_ord record; d jsonb; fi jsonb; v_n int; v_order uuid; v_onr text;
+  v_copies int; v_size numeric[]; v_type text; v_should text; v_keep uuid[]; v_del text; v_fo text; v_cart uuid;
+  v_crates_tot int; v_pieces_tot int; r record; v_rows int; v_cp jsonb; v_bron text; v_ncarts int; sv record;
+  n_st int := 0; n_tray int := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_sticker_sync');
+  SELECT settings INTO s FROM public.logistics_rule_configs
+   ORDER BY is_active DESC, (status = 'actief') DESC, updated_at DESC LIMIT 1;
+  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;
+  v_tray := public.logistics_rule_text(s, 'pickstations', 'traysticker_release', 'uit');
+
+  FOR st IN SELECT * FROM public.floriday_customer_stickers_cache ORDER BY updated_at DESC LIMIT greatest(p_limit,1) LOOP
+    n_st := n_st + 1;
+    d := coalesce(st.data, '{}'::jsonb);
+    fi := coalesce(d->'stickerFileInformation', '{}'::jsonb);
+    v_size := CASE WHEN st.sticker_width_mm IS NOT NULL AND st.sticker_height_mm IS NOT NULL
+                   THEN ARRAY[st.sticker_width_mm::numeric, st.sticker_height_mm::numeric]
+                   ELSE public.logistics_sticker_parse_size(d->'stickerSize') END;
+    v_type := upper(nullif(btrim(coalesce(st.sticker_type, d->>'stickerType', '')), ''));
+    v_should := lower(coalesce(st.should_be_printed::text, fi->>'shouldBePrinted', ''));
+
+    -- Koppeling volgens Suppliers API 2026v1: alleen via salesOrderId.
+    SELECT count(*), (array_agg(id))[1], (array_agg(order_number))[1] INTO v_n, v_order, v_onr
+      FROM public.orders WHERE deleted_at IS NULL
+       AND nullif(btrim(coalesce(st.sales_order_id, d->>'salesOrderId', '')), '') IS NOT NULL
+       AND floriday_sales_order_id = coalesce(st.sales_order_id, d->>'salesOrderId');
+
+    IF coalesce(st.is_deleted,false) OR lower(coalesce(d->>'isDeleted','')) = 'true' THEN
+      UPDATE public.logistics_sticker_prints SET status = 'niet_printen', reden = 'De koper heeft deze sticker verwijderd.'
+       WHERE soort = 'sticker' AND bron_id = st.floriday_id AND status NOT IN ('in_printwachtrij','afgemeld');
+      CONTINUE;
+    END IF;
+    IF lower(coalesce(d->>'isHandled','')) = 'true' THEN
+      UPDATE public.logistics_sticker_prints SET status = 'afgemeld', reden = 'Al afgemeld in Floriday.', handled_at = coalesce(handled_at, now())
+       WHERE soort = 'sticker' AND bron_id = st.floriday_id AND status <> 'afgemeld';
+      CONTINUE;
+    END IF;
+    IF v_n = 1 AND public.logistics_sales_order_external_fulfilled(v_order, coalesce(st.sales_order_id, d->>'salesOrderId')) THEN
+      UPDATE public.logistics_sticker_prints SET status = 'niet_printen', reden = 'Afgehandeld in Floriday; door ons niet geprint en niet afgemeld.'
+       WHERE soort = 'sticker' AND bron_id = st.floriday_id AND status NOT IN ('in_printwachtrij','afgemeld');
+      PERFORM public.logistics_sticker_upsert('sticker', st.floriday_id, v_order, v_onr, NULL, 0, v_size, NULL, NULL, 'niet_printen', 'Afgehandeld in Floriday; door ons niet geprint en niet afgemeld.');
+      CONTINUE;
+    END IF;
+    IF v_n <> 1 THEN
+      PERFORM public.logistics_sticker_upsert('sticker', st.floriday_id, NULL, NULL, NULL, 0, v_size, NULL, NULL, 'geblokkeerd',
+        format('Geen eenduidige order bij Floriday-verkooporder %s (%s gevonden).', coalesce(st.sales_order_id, d->>'salesOrderId', 'onbekend'), v_n));
+      UPDATE public.logistics_sticker_prints SET sticker_type = v_type WHERE soort='sticker' AND bron_id = st.floriday_id;
+      CONTINUE;
+    END IF;
+    IF v_should = 'false' THEN
+      -- Geen printopdracht; zichtbaar als 'niet_printen'. Wordt ook niet afgemeld in Floriday.
+      UPDATE public.logistics_sticker_prints SET status = 'niet_printen',
+             reden = 'Floriday: deze sticker hoeft niet geprint te worden (shouldBePrinted = false).'
+       WHERE soort = 'sticker' AND bron_id = st.floriday_id AND cart_id IS NOT NULL AND status NOT IN ('in_printwachtrij','afgemeld');
+      PERFORM public.logistics_sticker_upsert('sticker', st.floriday_id, v_order, v_onr, NULL, 0, v_size, NULL, NULL, 'niet_printen',
+        'Floriday: deze sticker hoeft niet geprint te worden (shouldBePrinted = false).');
+      UPDATE public.logistics_sticker_prints SET sticker_type = v_type WHERE soort='sticker' AND bron_id = st.floriday_id;
+      CONTINUE;
+    END IF;
+    IF lower(coalesce(fi->>'deliverSeparately','')) = 'true' THEN
+      PERFORM public.logistics_sticker_upsert('sticker', st.floriday_id, v_order, v_onr, NULL, 0, v_size, NULL, NULL, 'geblokkeerd',
+        'Sticker moet apart worden geleverd (deliverSeparately); kies handmatig hoe die mee gaat.');
+      UPDATE public.logistics_sticker_prints SET sticker_type = v_type WHERE soort='sticker' AND bron_id = st.floriday_id;
+      CONTINUE;
+    END IF;
+    IF nullif(btrim(coalesce(d->>'salesOrderCorrectionRequestId','')),'') IS NOT NULL THEN
+      PERFORM public.logistics_sticker_upsert('sticker', st.floriday_id, v_order, v_onr, NULL, 0, v_size, NULL, NULL, 'wacht_op_moment',
+        'Wacht tot de correctie op de verkooporder is verwerkt.');
+      CONTINUE;
+    END IF;
+    -- 1.0.182: aantal uit numberOfCopies -> additionalServices.numberOfUnits (LABEL) -> afgeleid uit stickersoort.
+    v_cp := public.logistics_sticker_copies(v_order, st.floriday_id, v_type, fi, nullif(btrim(coalesce(st.trade_item_id,'')),''));
+    v_copies := nullif(v_cp->>'aantal','')::int; v_bron := v_cp->>'bron';
+    IF coalesce(v_copies,0) <= 0 THEN
+      PERFORM public.logistics_sticker_upsert('sticker', st.floriday_id, v_order, v_onr, NULL, 0, v_size, NULL, NULL, 'geblokkeerd',
+        'Aantal stickers onbekend: geen numberOfCopies, geen numberOfUnits (LABEL) en niet af te leiden uit de stickersoort; niet geprint.');
+      UPDATE public.logistics_sticker_prints SET sticker_type = v_type, kopieen_bron = NULL WHERE soort='sticker' AND bron_id = st.floriday_id;
+      CONTINUE;
+    END IF;
+    IF v_type = 'DOCUMENT' THEN
+      SELECT oc.id INTO v_cart FROM logistics_active.order_carts oc WHERE oc.order_id = v_order ORDER BY oc.cart_number, oc.created_at LIMIT 1;
+      IF v_cart IS NULL THEN
+        PERFORM public.logistics_sticker_upsert('sticker', st.floriday_id, v_order, v_onr, NULL, v_copies, v_size, NULL, NULL, 'wacht_op_moment',
+          'Wacht tot de order op een kar staat.');
+      ELSE
+        PERFORM public.logistics_sticker_upsert('sticker', st.floriday_id, v_order, v_onr, v_cart, v_copies, v_size,
+          public.logistics_sticker_cart_plek(v_cart, v_station), NULL,
+          CASE WHEN public.logistics_cart_slip_queued(v_cart) THEN 'klaar' ELSE 'wacht_op_moment' END,
+          CASE WHEN public.logistics_cart_slip_queued(v_cart) THEN NULL ELSE 'Wacht op de pakbon van deze kar.' END);
+        UPDATE public.logistics_sticker_prints SET status = 'niet_printen', reden = 'Vervangen door regels per kar.'
+         WHERE soort = 'sticker' AND bron_id = st.floriday_id AND (cart_id IS NULL OR cart_id <> v_cart)
+           AND status NOT IN ('in_printwachtrij','afgemeld','niet_printen');
+      END IF;
+      UPDATE public.logistics_sticker_prints SET sticker_type = v_type, kopieen_bron = v_bron WHERE soort='sticker' AND bron_id = st.floriday_id;
+      CONTINUE;
+    END IF;
+    IF v_type IS NULL OR v_type NOT IN ('POT','PRODUCT','SLEEVE','PACKAGE','LAYER','LOAD_CARRIER') THEN
+      PERFORM public.logistics_sticker_upsert('sticker', st.floriday_id, v_order, v_onr, NULL, v_copies, v_size, NULL, NULL, 'geblokkeerd',
+        format('Onbekende of niet-ondersteunde stickersoort (%s); kies handmatig hoe deze sticker mee gaat.', coalesce(v_type,'leeg')));
+      UPDATE public.logistics_sticker_prints SET sticker_type = v_type WHERE soort='sticker' AND bron_id = st.floriday_id;
+      CONTINUE;
+    END IF;
+
+    v_keep := ARRAY[]::uuid[]; v_rows := 0; v_crates_tot := 0; v_pieces_tot := 0;
+    FOR r IN SELECT * FROM public.logistics_sticker_distribution(v_order, v_type, v_copies, nullif(btrim(coalesce(st.trade_item_id,'')),'')) LOOP
+      v_rows := v_rows + 1; v_keep := v_keep || r.cart_id;
+      v_crates_tot := v_crates_tot + r.crates; v_pieces_tot := v_pieces_tot + r.pieces;
+      PERFORM public.logistics_sticker_upsert('sticker', st.floriday_id, v_order, v_onr, r.cart_id, r.kopieen, v_size,
+        public.logistics_sticker_cart_plek(r.cart_id, v_station), NULL,
+        CASE WHEN public.logistics_cart_slip_queued(r.cart_id) THEN 'klaar' ELSE 'wacht_op_moment' END,
+        CASE WHEN public.logistics_cart_slip_queued(r.cart_id) THEN NULL ELSE 'Wacht op de pakbon van deze kar.' END);
+    END LOOP;
+    IF v_rows = 0 THEN
+      PERFORM public.logistics_sticker_upsert('sticker', st.floriday_id, v_order, v_onr, NULL, v_copies, v_size, NULL, NULL, 'geblokkeerd',
+        'De verdeling over karren sluit niet: de order staat (nog) niet op een kar, of de karren hebben geen fusten/stuks van dit artikel.');
+      UPDATE public.logistics_sticker_prints SET sticker_type = v_type WHERE soort='sticker' AND bron_id = st.floriday_id;
+      CONTINUE;
+    END IF;
+    UPDATE public.logistics_sticker_prints SET sticker_type = v_type, kopieen_bron = v_bron WHERE soort='sticker' AND bron_id = st.floriday_id;
+    IF (v_type IN ('PACKAGE','LAYER') AND v_crates_tot <> v_copies) OR (v_type IN ('POT','PRODUCT','SLEEVE') AND v_pieces_tot <> v_copies) THEN
+      BEGIN
+        INSERT INTO public.logistics_trace_events(phase, step, status, reason, order_ref)
+        SELECT 'stickers', 'Aantal klantstickers wijkt af', 'waarschuwing',
+               format('Floriday vraagt %s (%s); op de karren: %s fusten / %s stuks. Het aantal van Floriday wordt geprint.',
+                      v_copies, v_type, v_crates_tot, v_pieces_tot), v_onr
+         WHERE NOT EXISTS (SELECT 1 FROM public.logistics_trace_events e WHERE e.order_ref = v_onr AND e.step = 'Aantal klantstickers wijkt af'
+                             AND e.created_at > now() - interval '1 day');
+      EXCEPTION WHEN OTHERS THEN NULL; END;
+    END IF;
+    UPDATE public.logistics_sticker_prints SET status = 'niet_printen',
+           reden = CASE WHEN cart_id IS NULL THEN 'Vervangen door regels per kar.' ELSE 'Kar hoort niet meer bij deze sticker.' END
+     WHERE soort = 'sticker' AND bron_id = st.floriday_id
+       AND (cart_id IS NULL OR NOT (cart_id = ANY (v_keep)))
+       AND status NOT IN ('in_printwachtrij','afgemeld','niet_printen');
+  END LOOP;
+
+  -- 1.0.182: stickers die alleen in additionalServices van de verkooporder staan (stickercache leeg of nog niet bijgewerkt).
+  FOR sv IN
+    SELECT o.id AS order_id, o.order_number, e->>'stickerId' AS sticker_id, sum((e->>'numberOfUnits')::int)::int AS units
+      FROM public.orders o
+      JOIN public.floriday_salesorders_cache s ON s.floriday_id = o.floriday_sales_order_id AND NOT coalesce(s.is_deleted,false)
+      CROSS JOIN LATERAL jsonb_array_elements(CASE WHEN jsonb_typeof(s.data->'additionalServices') = 'array' THEN s.data->'additionalServices' ELSE '[]'::jsonb END) e
+     WHERE o.deleted_at IS NULL AND public.logistics_order_date(o.delivery_date) >= current_date - 2
+       AND upper(coalesce(e->>'unit','')) = 'LABEL' AND (e->>'numberOfUnits') ~ '^\d+$'
+       AND nullif(btrim(coalesce(e->>'stickerId','')),'') IS NOT NULL
+       AND NOT EXISTS (SELECT 1 FROM public.floriday_customer_stickers_cache c WHERE c.floriday_id = e->>'stickerId')
+       AND NOT public.logistics_sales_order_external_fulfilled(o.id, o.floriday_sales_order_id)
+     GROUP BY o.id, o.order_number, e->>'stickerId'
+     LIMIT greatest(p_limit,1)
+  LOOP
+    IF coalesce(sv.units,0) <= 0 THEN CONTINUE; END IF;
+    SELECT count(*), (array_agg(oc.id ORDER BY oc.cart_number, oc.created_at))[1] INTO v_ncarts, v_cart
+      FROM logistics_active.order_carts oc WHERE oc.order_id = sv.order_id;
+    IF v_ncarts = 1 THEN
+      PERFORM public.logistics_sticker_upsert('sticker', sv.sticker_id, sv.order_id, sv.order_number, v_cart, sv.units, NULL,
+        public.logistics_sticker_cart_plek(v_cart, v_station), NULL,
+        CASE WHEN public.logistics_cart_slip_queued(v_cart) THEN 'klaar' ELSE 'wacht_op_moment' END,
+        CASE WHEN public.logistics_cart_slip_queued(v_cart) THEN NULL ELSE 'Wacht op de pakbon van deze kar.' END);
+      UPDATE public.logistics_sticker_prints SET status = 'niet_printen', reden = 'Vervangen door regels per kar.'
+       WHERE soort = 'sticker' AND bron_id = sv.sticker_id AND (cart_id IS NULL OR cart_id <> v_cart)
+         AND status NOT IN ('in_printwachtrij','afgemeld','niet_printen');
+    ELSE
+      PERFORM public.logistics_sticker_upsert('sticker', sv.sticker_id, sv.order_id, sv.order_number, NULL, sv.units, NULL, NULL, NULL, 'wacht_op_moment',
+        CASE WHEN v_ncarts = 0 THEN 'Wacht tot de order op een kar staat.'
+             ELSE format('Stickersoort nog onbekend; wacht op de stickergegevens van Floriday om %s stickers over %s karren te verdelen.', sv.units, v_ncarts) END);
+    END IF;
+    UPDATE public.logistics_sticker_prints SET kopieen_bron = 'numberOfUnits' WHERE soort='sticker' AND bron_id = sv.sticker_id
+       AND status NOT IN ('in_printwachtrij','afgemeld');
+    n_st := n_st + 1;
+  END LOOP;
+
+  IF v_tray <> 'uit' THEN
+    FOR r_ord IN
+      SELECT o.id, o.order_number, nullif(btrim(o.floriday_sales_order_id),'') AS sales
+        FROM public.orders o
+       WHERE o.deleted_at IS NULL AND nullif(btrim(o.floriday_sales_order_id),'') IS NOT NULL
+         AND public.logistics_order_date(o.delivery_date) >= current_date - 2
+         AND EXISTS (SELECT 1 FROM logistics_active.order_carts oc WHERE oc.order_id = o.id)
+       ORDER BY o.delivery_date LIMIT greatest(p_limit,1)
+    LOOP
+      SELECT d2.floriday_id INTO v_del FROM public.floriday_delivery_orders_cache d2
+       WHERE d2.data @> jsonb_build_object('fulfillmentRequests', jsonb_build_array(jsonb_build_object('salesOrderId', r_ord.sales)))
+       ORDER BY d2.fetched_at DESC LIMIT 1;
+      IF v_del IS NULL THEN CONTINUE; END IF;
+      IF EXISTS (SELECT 1 FROM public.logistics_sticker_prints WHERE soort = 'traysticker' AND bron_id = v_del) THEN
+        v_fo := public.logistics_afhandeling_fulfillment_order(r_ord.id)->>'fulfillmentOrderId';
+        IF v_fo IS NOT NULL THEN
+          UPDATE public.logistics_sticker_prints SET fulfillment_order_id = v_fo
+           WHERE soort = 'traysticker' AND bron_id = v_del AND fulfillment_order_id IS DISTINCT FROM v_fo
+             AND status NOT IN ('in_printwachtrij','afgemeld');
+        END IF;
+        CONTINUE;
+      END IF;
+      SELECT oc.id INTO v_cart FROM logistics_active.order_carts oc WHERE oc.order_id = r_ord.id ORDER BY oc.cart_number, oc.created_at LIMIT 1;
+      v_fo := public.logistics_afhandeling_fulfillment_order(r_ord.id)->>'fulfillmentOrderId';
+      PERFORM public.logistics_sticker_upsert('traysticker', v_del, r_ord.id, r_ord.order_number, v_cart, 1, NULL,
+        public.logistics_sticker_cart_plek(v_cart, v_station), v_fo, 'wacht_op_moment',
+        'Wacht op geaccepteerde belading in Floriday.');
+      n_tray := n_tray + 1;
+    END LOOP;
+  END IF;
+
+  RETURN jsonb_build_object('stickers', n_st, 'trayNieuw', n_tray, 'release', v_rel, 'trayRelease', v_tray,
+                            'klantstickerMoment', 'with_packing_slip');
+END; $function$
+;
+
+CREATE OR REPLACE FUNCTION public.logistics_plan_kick()
+ RETURNS void
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_base text; v_key text; v_path text; v_last timestamptz;
+  v_debounce int := public.logistics_plan_setting('kick_debounce_seconds', 5)::int;
+  v_running boolean; v_req bigint; v_timeout int := public.logistics_tick_timeout_ms();
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_plan_kick');
+  -- Loopt er al een tick-ronde (slot 'tick:ronde')? Dan geen tweede ronde wekken.
+  -- Fail-closed: kan dit niet worden vastgesteld, dan valt de EXCEPTION-tak
+  -- hieronder en wordt de wek-aanroep overgeslagen; de minuut-cron is het vangnet.
+  SELECT EXISTS (
+    SELECT 1 FROM public.logistics_plan_locks
+     WHERE lock_key = 'tick:ronde' AND locked_until > now()
+  ) INTO v_running;
+  IF v_running IS DISTINCT FROM false THEN
+    -- 1.0.194: niet laten vallen; de lopende ronde pakt de vlag vóór het vrijgeven op.
+    INSERT INTO public.logistics_plan_settings(key, value, updated_at)
+    VALUES ('kick_pending', clock_timestamp()::text, now())
+    ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+    BEGIN
+      INSERT INTO public.logistics_kick_log(skipped_reason) VALUES ('ronde_loopt_vlag_gezet');
+    EXCEPTION WHEN OTHERS THEN NULL; END;
+    RETURN;
+  END IF;
+
+  SELECT value INTO v_base FROM public.module_runtime_config WHERE key = 'logistics_tick_base_url';
+  SELECT value INTO v_key FROM public.module_runtime_config WHERE key = 'logistics_tick_apikey';
+  SELECT value INTO v_path FROM public.module_runtime_config WHERE key = 'logistics_tick_path';
+  IF v_base IS NULL OR v_key IS NULL THEN RETURN; END IF;
+  v_path := COALESCE(v_path, '/api/public/hooks/logistics-recalc-tick');
+
+  SELECT NULLIF(value,'')::timestamptz INTO v_last
+  FROM public.logistics_plan_settings WHERE key = 'last_kick_at';
+  IF v_last IS NOT NULL AND v_last > now() - make_interval(secs => v_debounce) THEN
+    BEGIN INSERT INTO public.logistics_kick_log(skipped_reason) VALUES ('debounce'); EXCEPTION WHEN OTHERS THEN NULL; END;
+    RETURN;
+  END IF;
+
+  INSERT INTO public.logistics_plan_settings(key, value, updated_at)
+  VALUES ('last_kick_at', now()::text, now())
+  ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+
+  v_req := net.http_post(
+    url := rtrim(v_base,'/') || v_path,
+    headers := jsonb_build_object('Content-Type','application/json','apikey', v_key),
+    body := '{}'::jsonb,
+    timeout_milliseconds := v_timeout
+  );
+  BEGIN INSERT INTO public.logistics_kick_log(request_id) VALUES (v_req); EXCEPTION WHEN OTHERS THEN NULL; END;
+EXCEPTION WHEN OTHERS THEN
+  NULL;
+END;
+$function$
+;
+
+CREATE OR REPLACE FUNCTION public.logistics_recalc_tick_kick()
+ RETURNS bigint
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_base text; v_key text; v_path text; v_req bigint; v_host text;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_recalc_tick_kick');
+  BEGIN PERFORM public.logistics_tick_calls_resolve(); EXCEPTION WHEN others THEN NULL; END;
+
+  SELECT NULLIF(btrim(value),'') INTO v_base FROM public.module_runtime_config WHERE key = 'logistics_tick_base_url';
+  SELECT NULLIF(btrim(value),'') INTO v_key  FROM public.module_runtime_config WHERE key = 'logistics_tick_apikey';
+  SELECT NULLIF(btrim(value),'') INTO v_path FROM public.module_runtime_config WHERE key = 'logistics_tick_path';
+  v_host := substring(v_base from '^[a-zA-Z]+://([^/?#]+)');
+
+  IF v_base IS NULL OR v_key IS NULL THEN
+    INSERT INTO public.logistics_tick_calls (target_host, skipped_reason, engine_ok, error, resolved_at)
+    VALUES (v_host,
+            CASE WHEN v_base IS NULL THEN 'geen_adres' ELSE 'geen_sleutel' END,
+            false,
+            CASE WHEN v_base IS NULL THEN 'geen adres ingesteld' ELSE 'geen sleutel ingesteld' END,
+            now());
+    RAISE WARNING 'logistics_recalc_tick_kick: geen aanroep — logistics_tick_base_url en/of logistics_tick_apikey ontbreekt in module_runtime_config. Vul deze voor deze omgeving in.';
+    RETURN NULL;
+  END IF;
+  v_path := COALESCE(v_path, '/api/public/hooks/logistics-recalc-tick');
+  v_req := net.http_post(
+    url := rtrim(v_base,'/') || v_path,
+    headers := jsonb_build_object('Content-Type','application/json','apikey', v_key),
+    body := '{}'::jsonb,
+    timeout_milliseconds := public.logistics_tick_timeout_ms()
+  );
+  INSERT INTO public.logistics_tick_calls (request_id, target_host) VALUES (v_req, v_host);
+  RETURN v_req;
+END;
+$function$
+;
+
+CREATE OR REPLACE FUNCTION public.logistics_plan_release_stale()
+ RETURNS integer
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_n int := 0;
+  v_min int := public.logistics_plan_setting('claim_timeout_minutes', 2)::int;
+  v_max int := GREATEST(1, public.logistics_plan_setting('max_attempts', 3)::int);
+  v_txt text;
+  r record;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_plan_release_stale');
+  v_txt := 'de ronde heeft deze indeling na ' || v_min || ' minuten niet afgesloten (claim niet afgerond)';
+  FOR r IN
+    UPDATE public.logistics_plan_queue q
+       SET status = CASE WHEN q.attempts >= v_max OR q.reason_code = 'claim_niet_afgerond' THEN 'geblokkeerd' ELSE 'pending' END,
+           error = v_txt,
+           reason = CASE WHEN q.attempts >= v_max OR q.reason_code = 'claim_niet_afgerond'
+                         THEN v_txt || '; herhaald, daarom geblokkeerd' ELSE q.reason END,
+           reason_code = 'claim_niet_afgerond',
+           claimed_at = NULL,
+           next_attempt_at = now() + make_interval(mins => LEAST(30, GREATEST(1, q.attempts))),
+           updated_at = now()
+     WHERE q.status = 'running'
+       AND q.claimed_at < now() - make_interval(mins => v_min)
+    RETURNING q.order_id, q.attempts, q.status
+  LOOP
+    v_n := v_n + 1;
+    BEGIN
+      PERFORM public.logistics_trace_order_step(
+        r.order_id, 'stap:beladingindeling', 'claim niet afgerond',
+        CASE WHEN r.status = 'geblokkeerd' THEN 'mislukt' ELSE 'wacht' END,
+        'ronde sloot de indeling niet af',
+        CASE WHEN r.status = 'geblokkeerd'
+             THEN 'De ronde sloot de indeling voor de tweede keer niet af. De order is geblokkeerd zodat dit niet blijft herhalen; bekijk de reden en bied hem opnieuw aan.'
+             ELSE 'De ronde sloot de indeling niet af binnen ' || v_min || ' minuten. Eén nieuwe poging volgt.'
+        END,
+        'Karrenindeling', v_txt, 'regel');
+    EXCEPTION WHEN OTHERS THEN NULL;
+    END;
+  END LOOP;
+  RETURN v_n;
+END $function$
+;
+
+CREATE OR REPLACE FUNCTION public.logistics_plan_enqueue(p_order_id uuid, p_reason text DEFAULT 'change'::text)
+ RETURNS void
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_ok boolean;
+  v_id uuid;
+  v_status text;
+  v_decision text;
+  v_target uuid := p_order_id;
+  v_wacht jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_plan_enqueue');
+  IF COALESCE(current_setting('logistics.merging', true), '') <> '1' THEN
+    BEGIN
+      PERFORM set_config('logistics.merging', '1', true);
+      v_target := COALESCE(public.logistics_merge_floriday_lines(p_order_id), p_order_id);
+      PERFORM set_config('logistics.merging', '0', true);
+    EXCEPTION WHEN OTHERS THEN
+      v_target := p_order_id;
+    END;
+  END IF;
+
+  -- A2: wachttijd na een mislukte indeling respecteren bij automatische meldingen.
+  v_wacht := public.logistics_plan_wachttijd(v_target, p_reason);
+  IF COALESCE((v_wacht->>'wacht')::boolean, false) THEN
+    PERFORM public.logistics_plan_wachttijd_melden(v_target, p_reason, v_wacht);
+    RETURN;
+  END IF;
+
+  SELECT (o.deleted_at IS NULL AND COALESCE(o.is_reservation, false) = false AND o.plan_locked_at IS NULL)
+    INTO v_ok FROM public.orders o WHERE o.id = v_target;
+  -- 1.0.194: geannuleerde orders niet opnieuw indelen (alleen als de kolommen bestaan).
+  IF COALESCE(v_ok, false) AND public.logistics_order_geannuleerd(v_target) THEN
+    PERFORM public.logistics_trace_order_step(
+      v_target, 'stap:orders_combineren', 'order aanmelden voor indeling', 'overgeslagen',
+      'niet aangemeld', 'Order is geannuleerd', NULL);
+    RETURN;
+  END IF;
+  IF NOT COALESCE(v_ok, false) THEN
+    PERFORM public.logistics_trace_order_step(
+      v_target, 'stap:orders_combineren', 'order aanmelden voor indeling', 'overgeslagen',
+      'niet aangemeld', 'Order is verwijderd, samengevoegd, een reservering of de indeling staat vast', NULL);
+    RETURN;
+  END IF;
+
+  SELECT q.id, q.status INTO v_id, v_status
+    FROM public.logistics_plan_queue q
+   WHERE q.order_id = v_target
+     AND q.status IN ('pending', 'running', 'geblokkeerd')
+   ORDER BY q.updated_at DESC
+   LIMIT 1
+   FOR UPDATE;
+
+  IF v_id IS NULL THEN
+    BEGIN
+      INSERT INTO public.logistics_plan_queue(order_id, reason) VALUES (v_target, p_reason);
+      v_decision := 'nieuw aangemeld voor indeling';
+    EXCEPTION WHEN unique_violation THEN
+      v_decision := 'stond al in de wachtrij';
+    END;
+  ELSIF v_status = 'geblokkeerd' THEN
+    UPDATE public.logistics_plan_queue
+       SET status = 'pending', attempts = 0, reason = p_reason, reason_code = NULL,
+           error = NULL, claimed_at = NULL, next_attempt_at = now(), updated_at = now()
+     WHERE id = v_id;
+    v_decision := 'blokkade opgeheven, opnieuw aangemeld';
+  ELSE
+    UPDATE public.logistics_plan_queue
+       SET reason = p_reason, next_attempt_at = LEAST(next_attempt_at, now()), updated_at = now()
+     WHERE id = v_id;
+    v_decision := 'opnieuw aangemeld';
+  END IF;
+
+  PERFORM public.logistics_trace_order_step(
+    v_target, 'stap:orders_combineren', 'order aanmelden voor indeling', 'geslaagd',
+    v_decision, p_reason, 'Karrenindeling');
+
+  PERFORM public.logistics_plan_kick();
+END;
+$function$
+;
+
+CREATE OR REPLACE FUNCTION public.logistics_sync_pick_queue_core()
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_type_id uuid; v_station uuid; v_screen uuid; v_status uuid;
+  v_inserted integer := 0; v_updated integer := 0; v_closed integer := 0; v_candidates integer := 0;
+  v_today date; v_forced date; v_pickday date; v_target date; r_unit record; v_start timestamptz; v_due timestamptz;
+  v_carts integer; v_percart boolean := public.logistics_pick_barcode_enabled();
+  v_lines integer; v_breakdown jsonb; v_pickmode text; r_cart record; v_barcode text;
+  v_cart_lines integer; v_fix jsonb; v_cart_payload jsonb; v_cart_rows integer;
+  v_wait timestamptz; v_reason text; v_ok boolean;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_sync_pick_queue_core');
+  v_today := public.logistics_local_today();
+  v_forced := NULLIF(current_setting('logistics.forced_pick_day', true), '')::date;
+  SELECT id INTO v_type_id FROM public.pick_document_types WHERE code = 'pakbon' LIMIT 1;
+  IF v_type_id IS NULL THEN RETURN jsonb_build_object('error', 'documenttype pakbon ontbreekt'); END IF;
+  SELECT id INTO v_status FROM public.pick_document_statuses WHERE code = 'queued' LIMIT 1;
+  v_pickmode := COALESCE(public.logistics_pick_mode()->>'pickMode', '');
+
+  v_station := public.logistics_document_station('pakbon');
+  IF v_station IS NULL THEN
+    SELECT s.station_id INTO v_station FROM public.pick_station_screens s WHERE s.name ILIKE '%pakbon%' ORDER BY s.created_at LIMIT 1;
+  END IF;
+  IF v_station IS NULL THEN SELECT id INTO v_station FROM public.pick_stations ORDER BY created_at LIMIT 1; END IF;
+  SELECT s.id INTO v_screen FROM public.pick_station_screens s
+   WHERE s.station_id = v_station
+     AND (s.name ILIKE '%pakbon%' OR EXISTS (SELECT 1 FROM public.pick_screen_document_types d WHERE d.screen_id = s.id AND d.document_type_id = v_type_id))
+   ORDER BY s.created_at LIMIT 1;
+  IF v_screen IS NULL THEN
+    SELECT s.id INTO v_screen FROM public.pick_station_screens s WHERE s.station_id = v_station ORDER BY created_at LIMIT 1;
+  END IF;
+
+  -- Afsluiten in plaats van verwijderen.
+  v_closed := public.logistics_prune_handled_pick_queue();
+  -- Order geannuleerd of verwijderd: annuleren.
+  v_closed := v_closed + public.logistics_pick_queue_close(ARRAY(
+    SELECT q.id FROM public.pick_queue q
+     WHERE q.cancelled_at IS NULL AND q.completed_at IS NULL
+       AND NOT EXISTS (SELECT 1 FROM public.orders o WHERE o.order_number = q.order_number
+                        AND o.deleted_at IS NULL AND o.cancelled_at IS NULL AND coalesce(o.status, '') <> 'geannuleerd')),
+    'cancel', 'Order geannuleerd of verwijderd');
+  -- Kar bestaat niet meer: vervallen door herindeling.
+  v_closed := v_closed + public.logistics_pick_queue_close(ARRAY(
+    SELECT q.id FROM public.pick_queue q
+     WHERE q.cancelled_at IS NULL AND q.completed_at IS NULL AND q.printed_at IS NULL
+       AND (q.payload->>'cartRowFor') IS NOT NULL
+       AND NOT EXISTS (SELECT 1 FROM logistics_active.order_carts c WHERE c.id::text = q.reference)),
+    'cancel', 'Kar vervallen door herindeling');
+  -- Pickmethode niet meer "per kar": karregels vervallen.
+  IF v_pickmode <> 'cart' THEN
+    v_closed := v_closed + public.logistics_pick_queue_close(ARRAY(
+      SELECT q.id FROM public.pick_queue q
+       WHERE q.cancelled_at IS NULL AND q.completed_at IS NULL AND q.printed_at IS NULL
+         AND (q.payload->>'cartRowFor') IS NOT NULL),
+      'cancel', 'Kar vervallen: pickmethode is niet meer per kar');
+  END IF;
+
+  SELECT min(d) INTO v_pickday FROM (
+    SELECT public.logistics_order_pick_day(ord.order_number) AS d FROM public.orders ord
+     WHERE ord.order_number IS NOT NULL
+       AND public.logistics_order_is_topick(ord.id, ord.order_number)
+       AND NOT public.logistics_order_handled(ord.id)
+       AND public.logistics_order_released(ord.order_number)
+       AND EXISTS (SELECT 1 FROM public.logistics_tasks lt WHERE lt.order_ref = ord.order_number AND lt.task_type = 'pick.execute'
+                    AND lt.status NOT IN ('done','cancelled','superseded','skipped'))
+  ) s WHERE d >= v_today;
+  IF v_forced IS NOT NULL THEN v_pickday := v_forced; END IF;
+  v_target := v_pickday;
+
+  IF v_pickday IS NOT NULL THEN
+    SELECT count(*) INTO v_candidates FROM public.orders ord
+     WHERE ord.order_number IS NOT NULL
+       AND public.logistics_order_is_topick(ord.id, ord.order_number)
+       AND NOT public.logistics_order_handled(ord.id)
+       AND (v_forced IS NOT NULL OR public.logistics_order_released(ord.order_number))
+       AND public.logistics_order_pick_day(ord.order_number) = v_target
+       AND EXISTS (SELECT 1 FROM public.logistics_tasks lt WHERE lt.order_ref = ord.order_number AND lt.task_type = 'pick.execute'
+                    AND lt.status NOT IN ('done','cancelled','superseded','skipped'));
+  END IF;
+
+  IF v_pickday IS NULL OR COALESCE(v_candidates, 0) = 0 THEN
+    RETURN jsonb_build_object('station', v_station, 'screen', v_screen, 'pickdag', v_pickday, 'toegevoegd', 0,
+      'afgesloten', v_closed, 'kandidaten', COALESCE(v_candidates, 0),
+      'per_kar', v_pickmode = 'cart', 'kleinsteTelt', v_percart, 'pickmethode', v_pickmode,
+      'guard', 'geen kandidaten');
+  END IF;
+
+  -- 1.0.152: een geprinte regel blijft open tot scan, annulering of vervallen kar.
+
+  FOR r_unit IN
+    WITH kandidaat AS (
+      SELECT ord.id, ord.order_number, ord.customer_name, ord.delivery_date, ord.buffer_id, ord.custom_fields
+        FROM public.orders ord
+       WHERE ord.order_number IS NOT NULL
+         AND public.logistics_order_is_topick(ord.id, ord.order_number)
+         AND NOT public.logistics_order_handled(ord.id)
+         AND (v_forced IS NOT NULL OR public.logistics_order_released(ord.order_number))
+         AND public.logistics_order_pick_day(ord.order_number) = v_target
+         AND EXISTS (SELECT 1 FROM public.logistics_tasks lt WHERE lt.order_ref = ord.order_number AND lt.task_type = 'pick.execute'
+                      AND lt.status NOT IN ('done','cancelled','superseded','skipped'))
+    )
+    SELECT min(k.order_number) AS order_number,
+           (array_agg(k.id ORDER BY k.order_number))[1] AS lead_id,
+           array_agg(k.order_number ORDER BY k.order_number) AS refs,
+           array_agg(k.id ORDER BY k.order_number) AS ids,
+           (array_agg(k.buffer_id ORDER BY k.order_number) FILTER (WHERE k.buffer_id IS NOT NULL))[1] AS buffer_id,
+           count(*)::int AS leden,
+           (array_agg(k.customer_name ORDER BY k.order_number))[1] AS customer_name,
+           (array_agg(k.delivery_date ORDER BY k.order_number))[1] AS delivery_date,
+           (array_agg(k.custom_fields ORDER BY k.order_number))[1] AS custom_fields
+      FROM kandidaat k GROUP BY COALESCE(k.buffer_id::text, k.id::text) ORDER BY 1
+  LOOP
+    IF v_pickmode = 'cart' AND public.logistics_pakbon_old_order_row(r_unit.ids) THEN CONTINUE; END IF;
+    SELECT min(lt.planned_start), max(COALESCE(lt.due_at, lt.planned_end)) INTO v_start, v_due
+      FROM public.logistics_tasks lt WHERE lt.order_ref = ANY(r_unit.refs) AND lt.task_type IN ('print.packing_slip','pick.execute');
+    SELECT count(DISTINCT c.id)::integer INTO v_carts FROM logistics_active.order_carts c
+     WHERE c.order_id = ANY(r_unit.ids) OR (r_unit.buffer_id IS NOT NULL AND r_unit.leden > 1 AND c.buffer_id = r_unit.buffer_id AND c.order_id IS NULL);
+    SELECT count(*) INTO v_lines FROM logistics_active.order_items oi WHERE oi.order_id = ANY(r_unit.ids);
+    v_breakdown := public.pick_cart_breakdown(r_unit.lead_id);
+
+    IF v_pickmode = 'cart' THEN
+      v_cart_rows := 0;
+      FOR r_cart IN
+        SELECT DISTINCT c.id AS cart_id, c.cart_number FROM logistics_active.order_carts c
+         WHERE c.order_id = ANY(r_unit.ids)
+            OR (r_unit.buffer_id IS NOT NULL AND r_unit.leden > 1 AND c.buffer_id = r_unit.buffer_id AND c.order_id IS NULL)
+            OR EXISTS (SELECT 1 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 AND oi.order_id = ANY(r_unit.ids))
+         ORDER BY c.cart_number
+      LOOP
+        -- Kar al gescand: niets nieuws aanmaken.
+        IF public.logistics_cart_scanned(r_cart.cart_id) THEN CONTINUE; END IF;
+        v_ok := v_forced IS NOT NULL OR public.logistics_cart_released(r_cart.cart_id);
+        v_reason := CASE WHEN v_ok THEN NULL ELSE public.logistics_cart_release_reason(r_cart.cart_id) END;
+        v_wait := CASE WHEN v_ok THEN NULL ELSE public.logistics_cart_wait_until(r_cart.cart_id) END;
+
+        v_barcode := public.logistics_ensure_cart_barcode(r_cart.cart_id);
+        v_fix := public.logistics_cart_fixed_numbering(r_cart.cart_id);
+        SELECT count(*) INTO v_cart_lines FROM logistics_active.order_cart_items ci WHERE ci.cart_id = r_cart.cart_id;
+
+        v_cart_payload := jsonb_build_object(
+          'source','logistiek-engine','orderId', r_unit.lead_id, 'documentType','pakbon',
+          'pickDate', v_target, 'perCart', true, 'pickMode', 'cart',
+          'cartRowFor', r_unit.order_number, 'cartId', r_cart.cart_id,
+          'isFullCart', public.logistics_cart_is_full(r_cart.cart_id),
+          'barcode', v_barcode, 'cartCount', v_fix->'cartTotal', 'totalCarts', v_fix->'cartTotal',
+          'bufferId', r_unit.buffer_id, 'isBuffer', r_unit.leden > 1,
+          'bufferOrders', to_jsonb(r_unit.refs), 'orderIds', to_jsonb(r_unit.ids),
+          'printbaar', v_ok, 'wachtTot', v_wait, 'wachtReden', v_reason)
+          || COALESCE(v_breakdown, '{}'::jsonb) || v_fix;
+
+        IF EXISTS (SELECT 1 FROM public.pick_queue q WHERE q.reference = r_cart.cart_id::text
+                     AND q.document_type_id = v_type_id AND q.cancelled_at IS NULL) THEN
+          UPDATE public.pick_queue q
+             SET screen_id = COALESCE(v_screen, q.screen_id), station_id = COALESCE(v_station, q.station_id),
+                 customer_name = r_unit.customer_name, order_number = r_unit.order_number,
+                 document_number = 'PB-' || r_unit.order_number || '-K' || (v_fix->>'cartSeq'),
+                 line_count = v_cart_lines, cart_count = 1,
+                 due_at = COALESCE(v_wait, v_due, q.due_at),
+                 payload = COALESCE(q.payload, '{}'::jsonb) || v_cart_payload, updated_at = now()
+           WHERE q.reference = r_cart.cart_id::text AND q.document_type_id = v_type_id AND q.cancelled_at IS NULL
+             AND (q.screen_id, q.station_id, q.customer_name, q.order_number, q.document_number, q.line_count, q.cart_count, q.due_at, q.payload)
+                 IS DISTINCT FROM
+                 (COALESCE(v_screen, q.screen_id), COALESCE(v_station, q.station_id), r_unit.customer_name, r_unit.order_number,
+                  'PB-' || r_unit.order_number || '-K' || (v_fix->>'cartSeq'), v_cart_lines, 1,
+                  COALESCE(v_wait, v_due, q.due_at), COALESCE(q.payload, '{}'::jsonb) || v_cart_payload);
+          IF FOUND THEN v_updated := v_updated + 1; END IF;
+        ELSE
+          INSERT INTO public.pick_queue (station_id, screen_id, document_type_id, status_id, document_number, order_number, reference,
+            customer_name, delivery_address, line_count, cart_count, priority, announced_at, due_at, payload)
+          VALUES (v_station, v_screen, v_type_id, v_status,
+            'PB-' || r_unit.order_number || '-K' || (v_fix->>'cartSeq'), r_unit.order_number, r_cart.cart_id::text,
+            r_unit.customer_name, NULLIF(r_unit.custom_fields ->> 'delivery_address', ''),
+            v_cart_lines, 1, 30, now(), COALESCE(v_wait, v_due, (r_unit.delivery_date)::timestamptz), v_cart_payload)
+          ON CONFLICT DO NOTHING;
+          v_inserted := v_inserted + 1;
+        END IF;
+        v_cart_rows := v_cart_rows + 1;
+      END LOOP;
+
+      IF v_cart_rows > 0 THEN
+        v_closed := v_closed + public.logistics_pick_queue_close(ARRAY(
+          SELECT q.id FROM public.pick_queue q
+           WHERE q.order_number = ANY(r_unit.refs) AND q.document_type_id = v_type_id
+             AND (q.payload->>'cartRowFor') IS NULL AND q.printed_at IS NULL
+             AND q.cancelled_at IS NULL AND q.completed_at IS NULL),
+          'cancel', 'Orderregel vervangen door één regel per kar');
+      END IF;
+      -- Bij picken per kar nooit terugvallen op een orderregel.
+      CONTINUE;
+    END IF;
+
+    IF EXISTS (SELECT 1 FROM public.pick_queue q WHERE q.order_number = r_unit.order_number AND q.document_type_id = v_type_id
+                 AND (q.payload ->> 'cartRowFor') IS NULL AND q.cancelled_at IS NULL) THEN
+      UPDATE public.pick_queue q
+         SET screen_id = COALESCE(v_screen, q.screen_id), station_id = COALESCE(v_station, q.station_id),
+             customer_name = r_unit.customer_name, document_number = 'PB-' || r_unit.order_number,
+             line_count = v_lines, cart_count = COALESCE(v_carts, 0), due_at = COALESCE(v_due, q.due_at),
+             payload = COALESCE(q.payload, '{}'::jsonb)
+                       || jsonb_build_object('source','logistiek-engine','orderId', r_unit.lead_id, 'documentType','pakbon',
+                            'pickDate', v_target, 'perCart', v_percart, 'cartCount', COALESCE(v_carts, 0),
+                            'bufferId', r_unit.buffer_id, 'isBuffer', r_unit.leden > 1,
+                            'bufferOrders', to_jsonb(r_unit.refs), 'orderIds', to_jsonb(r_unit.ids))
+                       || COALESCE(v_breakdown, '{}'::jsonb),
+             updated_at = now()
+       WHERE q.order_number = r_unit.order_number AND q.document_type_id = v_type_id
+         AND (q.payload ->> 'cartRowFor') IS NULL AND q.cancelled_at IS NULL
+         AND (q.screen_id, q.station_id, q.customer_name, q.document_number, q.line_count, q.cart_count, q.due_at, q.payload)
+             IS DISTINCT FROM
+             (COALESCE(v_screen, q.screen_id), COALESCE(v_station, q.station_id), r_unit.customer_name, 'PB-' || r_unit.order_number,
+              v_lines, COALESCE(v_carts, 0), COALESCE(v_due, q.due_at),
+              COALESCE(q.payload, '{}'::jsonb)
+                       || jsonb_build_object('source','logistiek-engine','orderId', r_unit.lead_id, 'documentType','pakbon',
+                            'pickDate', v_target, 'perCart', v_percart, 'cartCount', COALESCE(v_carts, 0),
+                            'bufferId', r_unit.buffer_id, 'isBuffer', r_unit.leden > 1,
+                            'bufferOrders', to_jsonb(r_unit.refs), 'orderIds', to_jsonb(r_unit.ids))
+                       || COALESCE(v_breakdown, '{}'::jsonb));
+      IF FOUND THEN v_updated := v_updated + 1; END IF;
+      CONTINUE;
+    END IF;
+
+    INSERT INTO public.pick_queue (station_id, screen_id, document_type_id, status_id, document_number, order_number, reference,
+      customer_name, delivery_address, line_count, cart_count, priority, announced_at, due_at, payload)
+    VALUES (v_station, v_screen, v_type_id, v_status, 'PB-' || r_unit.order_number, r_unit.order_number, r_unit.order_number,
+      r_unit.customer_name, NULLIF(r_unit.custom_fields ->> 'delivery_address', ''), v_lines, COALESCE(v_carts, 0), 30, now(),
+      COALESCE(v_due, (r_unit.delivery_date)::timestamptz),
+      jsonb_build_object('source','logistiek-engine','orderId', r_unit.lead_id, 'documentType','pakbon', 'pickDate', v_target,
+        'perCart', v_percart, 'cartCount', COALESCE(v_carts, 0), 'bufferId', r_unit.buffer_id,
+        'isBuffer', r_unit.leden > 1, 'bufferOrders', to_jsonb(r_unit.refs), 'orderIds', to_jsonb(r_unit.ids))
+        || COALESCE(v_breakdown, '{}'::jsonb))
+    ON CONFLICT DO NOTHING;
+    v_inserted := v_inserted + 1;
+  END LOOP;
+
+  RETURN jsonb_build_object('station', v_station, 'screen', v_screen, 'pickdag', v_pickday,
+    'kandidaten', v_candidates, 'per_kar', v_pickmode = 'cart', 'kleinsteTelt', v_percart, 'pickmethode', v_pickmode,
+    'toegevoegd', v_inserted, 'bijgewerkt', v_updated, 'afgesloten', v_closed);
+END;
+$function$
+;
+
+CREATE OR REPLACE FUNCTION public.logistics_sync_pick_queue_backlog()
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_max integer := public.logistics_pick_backlog_max_days();
+  v_type_id uuid; v_status uuid; v_station uuid; v_screen uuid; v_pickmode text;
+  r_unit record; r_cart record; v_barcode text; v_seq integer; v_total integer;
+  v_lines integer; v_carts integer; v_payload jsonb; v_breakdown jsonb;
+  v_ins integer := 0; v_upd integer := 0; v_orders integer := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_sync_pick_queue_backlog');
+  IF v_max IS NULL THEN RETURN jsonb_build_object('achterstand', 'uit'); END IF;
+  v_pickmode := COALESCE(public.logistics_pick_mode()->>'pickMode', '');
+  IF v_pickmode <> 'cart' THEN
+    RETURN jsonb_build_object('achterstand', 'overgeslagen', 'reden', 'alleen bij picken per kar');
+  END IF;
+  SELECT id INTO v_type_id FROM public.pick_document_types WHERE code = 'pakbon' LIMIT 1;
+  SELECT id INTO v_status FROM public.pick_document_statuses WHERE code = 'queued' LIMIT 1;
+  IF v_type_id IS NULL THEN RETURN jsonb_build_object('achterstand', 'fout', 'reden', 'documenttype pakbon ontbreekt'); END IF;
+  v_station := public.logistics_document_station('pakbon');
+  IF v_station IS NULL THEN
+    SELECT s.station_id INTO v_station FROM public.pick_station_screens s WHERE s.name ILIKE '%pakbon%' ORDER BY s.created_at LIMIT 1;
+  END IF;
+  IF v_station IS NULL THEN SELECT id INTO v_station FROM public.pick_stations ORDER BY created_at LIMIT 1; END IF;
+  SELECT s.id INTO v_screen FROM public.pick_station_screens s
+   WHERE s.station_id = v_station
+     AND (s.name ILIKE '%pakbon%' OR EXISTS (SELECT 1 FROM public.pick_screen_document_types d WHERE d.screen_id = s.id AND d.document_type_id = v_type_id))
+   ORDER BY s.created_at LIMIT 1;
+
+  FOR r_unit IN
+    WITH k AS (
+      SELECT o.id, o.order_number, o.customer_name, o.delivery_date, o.buffer_id, o.custom_fields
+        FROM public.orders o WHERE o.order_number IS NOT NULL AND public.logistics_order_is_backlog(o.id))
+    SELECT min(k.order_number) AS order_number,
+           (array_agg(k.id ORDER BY k.order_number))[1] AS lead_id,
+           array_agg(k.order_number ORDER BY k.order_number) AS refs,
+           array_agg(k.id ORDER BY k.order_number) AS ids,
+           (array_agg(k.buffer_id ORDER BY k.order_number) FILTER (WHERE k.buffer_id IS NOT NULL))[1] AS buffer_id,
+           count(*)::int AS leden,
+           (array_agg(k.customer_name ORDER BY k.order_number))[1] AS customer_name,
+           min((k.delivery_date::text)::date) AS delivery_date,
+           (array_agg(k.custom_fields ORDER BY k.order_number))[1] AS custom_fields
+      FROM k GROUP BY COALESCE(k.buffer_id::text, k.id::text) ORDER BY 1
+  LOOP
+    IF public.logistics_pakbon_old_order_row(r_unit.ids) THEN CONTINUE; END IF;
+    v_orders := v_orders + 1;
+    SELECT count(DISTINCT c.id)::int INTO v_carts FROM logistics_active.order_carts c
+     WHERE c.order_id = ANY(r_unit.ids) OR (r_unit.buffer_id IS NOT NULL AND c.buffer_id = r_unit.buffer_id);
+    v_breakdown := public.pick_cart_breakdown(r_unit.lead_id);
+    FOR r_cart IN
+      SELECT DISTINCT c.id AS cart_id, c.cart_number, c.total_carts FROM logistics_active.order_carts c
+       WHERE c.order_id = ANY(r_unit.ids) OR (r_unit.buffer_id IS NOT NULL AND c.buffer_id = r_unit.buffer_id)
+       ORDER BY c.cart_number
+    LOOP
+      IF NOT public.logistics_cart_released(r_cart.cart_id) THEN CONTINUE; END IF;
+      v_barcode := public.logistics_ensure_cart_barcode(r_cart.cart_id);
+      v_seq := NULL; v_total := NULL;
+      SELECT s.cart_seq, s.cart_total INTO v_seq, v_total FROM public.logistics_cart_seq(r_unit.lead_id) s WHERE s.cart_id = r_cart.cart_id;
+      v_seq := COALESCE(v_seq, r_cart.cart_number);
+      v_total := COALESCE(v_total, r_cart.total_carts, v_carts);
+      SELECT count(*) INTO v_lines FROM logistics_active.order_cart_items ci WHERE ci.cart_id = r_cart.cart_id;
+      v_payload := jsonb_build_object(
+          'source','logistiek-engine','orderId', r_unit.lead_id, 'documentType','pakbon',
+          'pickDate', r_unit.delivery_date, 'perCart', true, 'pickMode', 'cart',
+          'cartRowFor', r_unit.order_number, 'cartId', r_cart.cart_id,
+          'cartSeq', v_seq, 'cartIndex', r_cart.cart_number, 'cartTotal', v_total,
+          'cartLabel', 'Kar ' || v_seq || ' van ' || COALESCE(v_total, v_seq),
+          'isFullCart', public.logistics_cart_is_full(r_cart.cart_id),
+          'barcode', v_barcode, 'cartCount', COALESCE(v_carts, 0),
+          'bufferId', r_unit.buffer_id, 'isBuffer', r_unit.leden > 1,
+          'bufferOrders', to_jsonb(r_unit.refs), 'orderIds', to_jsonb(r_unit.ids),
+          'backlog', true,
+          'backlogDays', (now() AT TIME ZONE public.logistics_tz())::date - r_unit.delivery_date,
+          'backlogLabel', 'Achterstand, leverdatum ' || to_char(r_unit.delivery_date, 'DD-MM'))
+        || COALESCE(v_breakdown, '{}'::jsonb);
+      IF EXISTS (SELECT 1 FROM public.pick_queue q WHERE q.reference = r_cart.cart_id::text AND q.document_type_id = v_type_id AND q.cancelled_at IS NULL) THEN
+        UPDATE public.pick_queue q
+           SET customer_name = r_unit.customer_name, order_number = r_unit.order_number,
+               document_number = 'PB-' || r_unit.order_number || '-K' || v_seq,
+               line_count = v_lines, cart_count = 1, is_urgent = true,
+               payload = COALESCE(q.payload, '{}'::jsonb) || v_payload, updated_at = now()
+         WHERE q.reference = r_cart.cart_id::text AND q.document_type_id = v_type_id AND q.cancelled_at IS NULL
+           AND q.printed_at IS NULL AND q.completed_at IS NULL
+           AND (q.customer_name, q.order_number, q.document_number, q.line_count, q.cart_count, q.is_urgent, q.payload)
+               IS DISTINCT FROM
+               (r_unit.customer_name, r_unit.order_number, 'PB-' || r_unit.order_number || '-K' || v_seq, v_lines, 1, true,
+                COALESCE(q.payload, '{}'::jsonb) || v_payload);
+        IF FOUND THEN v_upd := v_upd + 1; END IF;
+      ELSE
+        INSERT INTO public.pick_queue (
+          station_id, screen_id, document_type_id, status_id, document_number, order_number, reference,
+          customer_name, delivery_address, line_count, cart_count, priority, is_urgent, announced_at, due_at, payload
+        ) VALUES (
+          v_station, v_screen, v_type_id, v_status,
+          'PB-' || r_unit.order_number || '-K' || v_seq, r_unit.order_number, r_cart.cart_id::text,
+          r_unit.customer_name, NULLIF(r_unit.custom_fields ->> 'delivery_address', ''),
+          v_lines, 1, 30, true, now(), (r_unit.delivery_date)::timestamptz, v_payload
+        ) ON CONFLICT DO NOTHING;
+        v_ins := v_ins + 1;
+      END IF;
+    END LOOP;
+  END LOOP;
+  RETURN jsonb_build_object('achterstand', 'aan', 'maxDagen', v_max, 'eenheden', v_orders, 'toegevoegd', v_ins, 'bijgewerkt', v_upd);
+END $function$
+;
+
+CREATE OR REPLACE FUNCTION public.logistics_order_frozen(p_order_id uuid)
+ RETURNS boolean
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE v_number text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_order_frozen');
+  SELECT o.order_number INTO v_number FROM public.orders o WHERE o.id = p_order_id;
+  IF v_number IS NULL THEN RETURN false; END IF;
+  IF EXISTS (SELECT 1 FROM public.logistics_order_plan_exclusion x WHERE x.order_id = p_order_id) THEN RETURN true; END IF;
+  IF public.logistics_order_afgemeld(p_order_id) THEN RETURN true; END IF;
+  IF EXISTS (SELECT 1 FROM public.pick_queue q WHERE q.order_number = v_number AND q.cancelled_at IS NULL
+       AND (q.printed_at IS NOT NULL OR q.completed_at IS NOT NULL)) THEN RETURN true; END IF;
+  IF EXISTS (SELECT 1 FROM public.cart_control_items ci WHERE ci.order_number = v_number) THEN RETURN true; END IF;
+  IF public.logistics_order_print_actief(v_number) THEN RETURN true; END IF;
+  IF public.logistics_order_print_actief(v_number) THEN RETURN true; END IF;
+  RETURN false;
+END;
+$function$
+;
+
+CREATE OR REPLACE FUNCTION public.logistics_order_mergeable(p_order_id uuid)
+ RETURNS boolean
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_ok boolean;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_order_mergeable');
+  SELECT (o.deleted_at IS NULL
+          AND o.cancelled_at IS NULL
+          AND o.plan_locked_at IS NULL
+          AND COALESCE(o.is_reservation, false) = false
+          AND o.order_source = 'floriday'
+          AND o.floriday_order_group_key IS NOT NULL
+          AND NOT EXISTS (
+                SELECT 1
+                  FROM public.pick_queue q
+                 WHERE q.order_number = o.order_number
+                   AND (q.printed_at IS NOT NULL OR q.completed_at IS NOT NULL)
+              )
+          AND NOT public.logistics_order_print_actief(o.order_number))
+    INTO v_ok
+    FROM public.orders o
+   WHERE o.id = p_order_id;
+
+  RETURN COALESCE(v_ok, false);
+EXCEPTION WHEN OTHERS THEN
+  RETURN false;
+END $function$
+;
+
+CREATE OR REPLACE FUNCTION public.logistics_merge_partial_carts(p_limit integer DEFAULT 50)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+declare r record; v_count integer := 0;
+begin
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_merge_partial_carts');
+  if coalesce(public.logistics_pick_mode()->>'pickMode','') <> 'cart' then
+    return jsonb_build_object('overgeslagen', 'pickmethode is niet per kar');
+  end if;
+  if public.logistics_pick_partial_mode() <> 'after_checkin' then
+    return jsonb_build_object('overgeslagen', 'deelkarren mogen ook voor het aanmeldmoment');
+  end if;
+
+  for r in
+    select distinct o.id as order_id
+      from logistics_active.order_carts c
+      join lateral unnest(public.logistics_cart_order_refs(c.id)) ref on true
+      join public.orders o on o.order_number = ref
+     where not public.logistics_cart_is_full(c.id)
+       and not exists (select 1 from public.pick_queue q
+                        where q.reference = c.id::text and q.printed_at is not null)
+       and not public.logistics_order_print_actief(o.order_number)
+       and not public.logistics_order_print_actief(o.order_number)
+       and public.logistics_cart_checkin_at(c.id) is not null
+     limit greatest(coalesce(p_limit, 50), 1)
+  loop
+    begin
+      perform public.enqueue_cart_replan_if_unlocked(r.order_id);
+      v_count := v_count + 1;
+    exception when others then null;
+    end;
+  end loop;
+
+  return jsonb_build_object('opnieuw_ingedeeld', v_count);
+end; $function$
+;
+
+CREATE OR REPLACE FUNCTION public.logistics_order_is_frozen(p_order_id uuid)
+ RETURNS boolean
+ LANGUAGE sql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+  SELECT public.logistics_acc_guard('ingelogd', 'logistics_order_is_frozen');
+  SELECT EXISTS (
+    SELECT 1 FROM public.pick_queue p
+     WHERE p.cancelled_at IS NULL
+       AND (p.printed_at IS NOT NULL OR p.completed_at IS NOT NULL
+            OR jsonb_array_length(CASE WHEN jsonb_typeof(p.printed_cart_ids) = 'array' THEN p.printed_cart_ids ELSE '[]'::jsonb END) > 0)
+       AND (p.payload->>'orderId' = p_order_id::text
+            OR COALESCE(p.payload->'orderIds', '[]'::jsonb) ? p_order_id::text)
+  )
+  OR EXISTS (
+    SELECT 1 FROM logistics_active.order_carts oc
+     WHERE oc.order_id = p_order_id AND public.logistics_cart_is_frozen(oc.id)
+  )
+  OR public.logistics_order_print_actief((SELECT o.order_number FROM public.orders o WHERE o.id = p_order_id))
+  OR public.logistics_order_print_actief((SELECT o.order_number FROM public.orders o WHERE o.id = p_order_id))
+  OR EXISTS (
+    SELECT 1 FROM logistics_active.order_carts oc
+      JOIN logistics_active.order_cart_items oci ON oci.cart_id = oc.id
+      JOIN public.order_items oi ON oi.id = oci.order_item_id
+     WHERE oc.order_id IS NULL AND oi.order_id = p_order_id
+       AND public.logistics_cart_is_frozen(oc.id)
+  )
+$function$
+;
+
+CREATE OR REPLACE FUNCTION public.logistics_order_on_frozen_shared_cart(p_order_id uuid)
+ RETURNS boolean
+ LANGUAGE sql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+  SELECT public.logistics_acc_guard('server', 'logistics_order_on_frozen_shared_cart');
+  SELECT EXISTS (
+    SELECT 1 FROM public.logistics_shared_cart_peers(p_order_id) p
+      JOIN logistics_active.order_carts c ON c.id = p.cart_id
+      LEFT JOIN public.orders po ON po.id = p.peer_order_id
+     WHERE c.pickup_locked IS TRUE OR c.is_complete IS TRUE
+        OR public.logistics_cart_handled(COALESCE(po.order_number, p.peer_order_id::text), p.cart_number)
+        OR public.logistics_order_afgemeld(p.peer_order_id)
+        OR public.logistics_order_print_actief(po.order_number)
+        OR public.logistics_order_print_actief(po.order_number)
+        OR public.logistics_cart_is_frozen(p.cart_id)
+        OR EXISTS (SELECT 1 FROM public.pick_queue q WHERE q.cancelled_at IS NULL
+             AND q.payload->>'cartId' = p.cart_id::text
+             AND (q.printed_at IS NOT NULL OR q.completed_at IS NOT NULL)))
+$function$
+;
+
+CREATE OR REPLACE FUNCTION public.logistics_tick()
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE v_result jsonb := '{}'::jsonb; v_start timestamptz := clock_timestamp(); v_t timestamptz; v_err boolean := false;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_tick');
+  v_t := clock_timestamp();
+  BEGIN
+    PERFORM set_config('statement_timeout', '10000', true);
+    v_result := v_result || jsonb_build_object('vervoerder', public.logistics_carrier_recalc_run(200));
+  EXCEPTION WHEN OTHERS THEN
+    v_err := true; v_result := v_result || jsonb_build_object('vervoerder', left(SQLERRM, 200));
+  END;
+  v_result := v_result || jsonb_build_object('vervoerder_ms', (extract(epoch from clock_timestamp()-v_t)*1000)::int);
+
+  v_t := clock_timestamp();
+  BEGIN
+    PERFORM set_config('statement_timeout', '15000', true);
+    PERFORM public.logistics_rebuffer_pending();
+    v_result := v_result || jsonb_build_object('rebuffer', 'ok');
+  EXCEPTION WHEN OTHERS THEN
+    v_err := true;
+    IF SQLERRM ILIKE '%tijdzone%' THEN
+      v_result := v_result || jsonb_build_object('rebuffer', 'overgeslagen: tijdzone ontbreekt in Werktijden');
+      BEGIN
+        UPDATE public.logistics_rebuffer_state SET last_error = 'Herindelen overgeslagen: de tijdzone ontbreekt in Werktijden.', updated_at = now() WHERE id;
+      EXCEPTION WHEN OTHERS THEN NULL; END;
+    ELSE
+      v_result := v_result || jsonb_build_object('rebuffer', left(SQLERRM, 200));
+    END IF;
+  END;
+  v_result := v_result || jsonb_build_object('rebuffer_ms', (extract(epoch from clock_timestamp()-v_t)*1000)::int);
+
+  v_t := clock_timestamp();
+  BEGIN
+    PERFORM set_config('statement_timeout', '20000', true);
+    PERFORM public.run_logistics_tasks_dispatch();
+    v_result := v_result || jsonb_build_object('taken', 'ok');
+  EXCEPTION WHEN OTHERS THEN
+    v_err := true; v_result := v_result || jsonb_build_object('taken', left(SQLERRM, 200));
+  END;
+  v_result := v_result || jsonb_build_object('taken_ms', (extract(epoch from clock_timestamp()-v_t)*1000)::int);
+
+  v_t := clock_timestamp();
+  BEGIN
+    PERFORM set_config('statement_timeout', '20000', true);
+    v_result := v_result || jsonb_build_object('afgerond', public.logistics_order_finalize_run(25, 120));
+  EXCEPTION WHEN OTHERS THEN
+    v_err := true; v_result := v_result || jsonb_build_object('afgerond', left(SQLERRM, 200));
+  END;
+  v_result := v_result || jsonb_build_object('afgerond_ms', (extract(epoch from clock_timestamp()-v_t)*1000)::int);
+
+  -- 1.0.194: lichte ronde — pickwachtrij en laadtoestand in SQL, niet meer via HTTP.
+  v_t := clock_timestamp();
+  BEGIN
+    PERFORM set_config('statement_timeout', '15000', true);
+    v_result := v_result || jsonb_build_object('pickwachtrij', public.logistics_sync_pick_queue());
+  EXCEPTION WHEN OTHERS THEN
+    v_err := true; v_result := v_result || jsonb_build_object('pickwachtrij', left(SQLERRM, 200));
+  END;
+  v_result := v_result || jsonb_build_object('pickwachtrij_ms', (extract(epoch from clock_timestamp()-v_t)*1000)::int);
+
+  v_t := clock_timestamp();
+  BEGIN
+    PERFORM set_config('statement_timeout', '10000', true);
+    v_result := v_result || jsonb_build_object('laadtoestand', public.logistics_refresh_plan_state_als_nodig());
+  EXCEPTION WHEN OTHERS THEN
+    v_err := true; v_result := v_result || jsonb_build_object('laadtoestand', left(SQLERRM, 200));
+  END;
+  v_result := v_result || jsonb_build_object('laadtoestand_ms', (extract(epoch from clock_timestamp()-v_t)*1000)::int);
+
+  v_t := clock_timestamp();
+  BEGIN
+    PERFORM set_config('statement_timeout', '10000', true);
+    v_result := v_result || jsonb_build_object('instellingen', public.logistics_ensure_periodiek());
+  EXCEPTION WHEN OTHERS THEN
+    v_err := true; v_result := v_result || jsonb_build_object('instellingen', left(SQLERRM, 200));
+  END;
+  v_result := v_result || jsonb_build_object('instellingen_ms', (extract(epoch from clock_timestamp()-v_t)*1000)::int);
+
+  -- 1.0.194: lichte ronde — pickwachtrij en laadtoestand in SQL, niet meer via HTTP.
+  v_t := clock_timestamp();
+  BEGIN
+    PERFORM set_config('statement_timeout', '15000', true);
+    v_result := v_result || jsonb_build_object('pickwachtrij', public.logistics_sync_pick_queue());
+  EXCEPTION WHEN OTHERS THEN
+    v_err := true; v_result := v_result || jsonb_build_object('pickwachtrij', left(SQLERRM, 200));
+  END;
+  v_result := v_result || jsonb_build_object('pickwachtrij_ms', (extract(epoch from clock_timestamp()-v_t)*1000)::int);
+
+  v_t := clock_timestamp();
+  BEGIN
+    PERFORM set_config('statement_timeout', '10000', true);
+    v_result := v_result || jsonb_build_object('laadtoestand', public.logistics_refresh_plan_state_als_nodig());
+  EXCEPTION WHEN OTHERS THEN
+    v_err := true; v_result := v_result || jsonb_build_object('laadtoestand', left(SQLERRM, 200));
+  END;
+  v_result := v_result || jsonb_build_object('laadtoestand_ms', (extract(epoch from clock_timestamp()-v_t)*1000)::int);
+
+  v_t := clock_timestamp();
+  BEGIN
+    PERFORM set_config('statement_timeout', '10000', true);
+    v_result := v_result || jsonb_build_object('instellingen', public.logistics_ensure_periodiek());
+  EXCEPTION WHEN OTHERS THEN
+    v_err := true; v_result := v_result || jsonb_build_object('instellingen', left(SQLERRM, 200));
+  END;
+  v_result := v_result || jsonb_build_object('instellingen_ms', (extract(epoch from clock_timestamp()-v_t)*1000)::int);
+
+  BEGIN
+    INSERT INTO public.logistics_tick_runs(started_at, finished_at, duration_ms, has_error, steps)
+    VALUES (v_start, clock_timestamp(), (extract(epoch from clock_timestamp()-v_start)*1000)::int, v_err, v_result);
+  EXCEPTION WHEN OTHERS THEN NULL;
+  END;
+  PERFORM set_config('statement_timeout', '30000', true);
+  RETURN v_result;
+END $function$
+;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check()
+ RETURNS TABLE(onderdeel text, ok boolean, toelichting text)
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE c text; f text; t text; v_fav text; n bigint; s record;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_install_check');
+  FOREACH f IN ARRAY ARRAY[
+      'f:logistics_try_uuid','f:logistics_tz','f:logistics_is_beheer','f:logistics_buffer_payload','f:logistics_apply_order_buffer',
+      'f:logistics_apply_buffer_decision','f:logistics_rebuffer_pending','f:logistics_departure_calc','f:logistics_own_transport_departure',
+      'f:logistics_order_departure','f:logistics_brief_transport','f:logistics_order_frozen','f:logistics_order_is_frozen',
+      'f:logistics_order_finalize_run','f:run_logistics_tasks_dispatch','f:enqueue_cart_replan_if_unlocked','f:logistics_tick',
+      't:logistics_tick_runs',
+      'f:logistics_belading_bevestig','f:logistics_cart_seq_dubbel','f:logistics_plan_retry_later','f:logistics_own_traysticker_sync',
+      't:logistics_belading_bevestigingen',
+      'f:logistics_sticker_copies','f:logistics_sticker_etiket_status','f:logistics_sticker_order_counts','f:logistics_sticker_sync',
+      'c:logistics_sticker_prints.kopieen_bron',
+      'f:logistics_carrier_settings_ensure','t:logistics_carrier_settings','t:logistics_carrier_recalc_queue','t:logistics_carrier_events',
+      'f:logistics_carrier_status','f:logistics_carrier_set_backfill','f:logistics_carrier_preview_existing','c:control_get_todays_carts.carrier_name',
+      'f:logistics_plan_fail_log'] LOOP
+    onderdeel := 'Engine: ' || substr(f, 3);
+    ok := CASE left(f, 1)
+      WHEN 'f' THEN EXISTS (SELECT 1 FROM pg_proc p WHERE p.pronamespace = 'public'::regnamespace AND p.proname = substr(f, 3))
+      WHEN 't' THEN to_regclass('public.' || substr(f, 3)) IS NOT NULL
+      ELSE CASE WHEN split_part(substr(f, 3), '.', 1) = 'control_get_todays_carts'
+             THEN coalesce(pg_get_function_result(to_regprocedure('public.control_get_todays_carts()')), '') LIKE '%carrier_name%'
+             ELSE EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='public'
+                           AND table_name = split_part(substr(f, 3), '.', 1) AND column_name = split_part(substr(f, 3), '.', 2)) END
+    END;
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Engine-migratie (1.0.182 t/m 1.0.188) in dev uitvoeren en via schemasync verspreiden' END;
+    RETURN NEXT;
+  END LOOP;
+  FOREACH c IN ARRAY ARRAY['carrier_id','carrier_source','carrier_reason','carrier_resolved_at','carrier_set_by','carrier_set_at'] LOOP
+    onderdeel := 'orders.' || c;
+    ok := EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='public' AND table_name='orders' AND column_name=c);
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Engine-migratie' END; RETURN NEXT;
+  END LOOP;
+  FOREACH f IN ARRAY ARRAY['logistics_resolve_carrier(uuid)','logistics_resolve_carrier_many(uuid[])',
+      'logistics_resolve_carrier_for_location(uuid,uuid)','logistics_resolve_carrier_for_location_many(uuid[],uuid)',
+      'logistics_resolve_carrier_for_location_many(jsonb)',
+      'logistics_set_order_carrier(uuid,uuid)','logistics_carrier_recalc_run(integer)'] LOOP
+    onderdeel := 'functie ' || f; ok := to_regprocedure('public.' || f) IS NOT NULL;
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Engine-migratie' END; RETURN NEXT;
+  END LOOP;
+  FOREACH t IN ARRAY ARRAY['orders:trg_logistics_orders_carrier_fill','orders:trg_logistics_orders_carrier_changed',
+      'carriers:trg_logistics_carriers_enqueue','customer_delivery_locations:trg_logistics_locations_enqueue'] LOOP
+    onderdeel := 'trigger ' || split_part(t, ':', 2);
+    ok := EXISTS (SELECT 1 FROM pg_trigger g WHERE g.tgname = split_part(t, ':', 2)
+                   AND g.tgrelid = to_regclass('public.' || split_part(t, ':', 1)));
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Engine-migratie' END; RETURN NEXT;
+  END LOOP;
+  onderdeel := 'minuutronde rekent vervoerders';
+  ok := EXISTS (SELECT 1 FROM pg_proc WHERE proname = 'logistics_tick' AND prosrc LIKE '%logistics_carrier_recalc_run%');
+  toelichting := CASE WHEN ok THEN 'ja' ELSE 'nee' END; RETURN NEXT;
+  FOREACH c IN ARRAY ARRAY['carrier_kind','is_favorite','archived_at','delivery_location_glns'] LOOP
+    onderdeel := 'Afhandeling: carriers.' || c;
+    ok := EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='public' AND table_name='carriers' AND column_name=c);
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Afhandeling' END; RETURN NEXT;
+  END LOOP;
+  FOREACH f IN ARRAY ARRAY['afh_favorite_carrier','afh_city_code','afh_normalize_country','afh_normalize_nl_province'] LOOP
+    onderdeel := 'Afhandeling: ' || f || '()';
+    ok := EXISTS (SELECT 1 FROM pg_proc p WHERE p.pronamespace = 'public'::regnamespace AND p.proname = f);
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Afhandeling' END; RETURN NEXT;
+  END LOOP;
+  onderdeel := 'Favoriete vervoerder ingesteld en bruikbaar';
+  IF to_regprocedure('public.afh_favorite_carrier()') IS NULL THEN ok := false; toelichting := 'functie ontbreekt';
+  ELSE
+    BEGIN v_fav := public.logistics_carrier_favorite_id()::text; EXCEPTION WHEN OTHERS THEN v_fav := NULL; END;
+    ok := public.logistics_try_uuid(v_fav) IS NOT NULL AND public.logistics_carrier_skip_reason(public.logistics_try_uuid(v_fav)) IS NULL;
+    toelichting := CASE WHEN ok THEN 'ja' WHEN v_fav IS NULL THEN 'geen favoriet ingesteld (Afhandeling → Vervoerders)'
+                        ELSE public.logistics_carrier_skip_reason(public.logistics_try_uuid(v_fav)) END;
+  END IF;
+  RETURN NEXT;
+  onderdeel := 'Klanten: customers.default_carrier_id';
+  ok := EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='public' AND table_name='customers' AND column_name='default_carrier_id');
+  toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: Klanten' END; RETURN NEXT;
+  IF to_regclass('public.logistics_carrier_settings') IS NOT NULL AND to_regclass('public.orders') IS NOT NULL
+     AND EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema='public' AND table_name='orders' AND column_name='carrier_source') THEN
+    SELECT * INTO s FROM public.logistics_carrier_settings_ensure();
+    EXECUTE $q$SELECT count(*) FROM public.orders o
+      WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL
+        AND coalesce(o.delivery_date, '') ~ '^\d{4}-\d{2}-\d{2}' AND left(o.delivery_date, 10)::date >= current_date
+        AND (o.carrier_source = 'geen' OR (o.carrier_source IS NULL AND o.created_at >= $1))$q$ INTO n USING s.installed_at;
+    onderdeel := 'Open orders zonder vervoerder'; ok := n = 0; toelichting := n || ' order(s)'; RETURN NEXT;
+    onderdeel := 'Schakelaar bestaande orders'; ok := true;
+    toelichting := CASE WHEN coalesce(s.backfill_existing, false) THEN 'aan' ELSE 'uit (bestaande orders wachten op akkoord)' END; RETURN NEXT;
+  END IF;
+  -- 1.0.188: mislukte aanmelding voor (her)planning vanuit de ordertriggers.
+  SELECT count(*) INTO n FROM public.logistics_trace_events e
+   WHERE e.actor IN ('trg_logistics_plan_order_items', 'trg_logistics_plan_orders')
+     AND e.status = 'mislukt' AND e.created_at > now() - interval '24 hours';
+  onderdeel := 'Mislukte herplanning (laatste 24 uur)'; ok := n = 0;
+  toelichting := CASE WHEN n = 0 THEN 'geen' ELSE n || ' keer; laatste: ' || coalesce((SELECT coalesce(e.order_ref, '?') || ': ' || coalesce(e.error, '') FROM public.logistics_trace_events e
+     WHERE e.actor IN ('trg_logistics_plan_order_items', 'trg_logistics_plan_orders') AND e.status = 'mislukt'
+     ORDER BY e.created_at DESC LIMIT 1), '') END;
+  RETURN NEXT;
+  RETURN QUERY SELECT * FROM public.logistics_install_check_194();
+  RETURN QUERY SELECT * FROM public.logistics_install_check_196();
+  RETURN QUERY SELECT * FROM public.logistics_access_check();
+  RETURN QUERY SELECT * FROM public.logistics_overload_check();
+  RETURN QUERY SELECT * FROM public.logistics_check_190();
+END $function$
+;
+
+-- Bij installeren: instellingen aanvullen (idempotent).
+DO $e$ BEGIN
+  PERFORM public.logistics_ensure_tick_settings();
+  PERFORM public.logistics_ensure_rebuffer_setting();
+EXCEPTION WHEN OTHERS THEN
+  RAISE NOTICE 'logistiek-engine 1.0.194: instellingen aanvullen overgeslagen (%); de minuutronde doet dit alsnog', SQLERRM;
+END $e$;
+
+GRANT EXECUTE ON FUNCTION public.logistics_order_date(text) TO authenticated, service_role;
+GRANT EXECUTE ON FUNCTION public.logistics_order_date(date) TO authenticated, service_role;
+GRANT EXECUTE ON FUNCTION public.logistics_print_status(uuid[]) TO authenticated, service_role;
+GRANT EXECUTE ON FUNCTION public.logistics_kick_metingen(integer) TO authenticated, service_role;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_194() TO authenticated, service_role;
+
+-- ============================================================================
+-- logistiek-engine 1.0.196 — direct wekken, achterstand in één aanroep, gegevens
+-- voor karindeling, sticker opnieuw proberen, rebuffer-slot (additief, idempotent)
+-- ============================================================================
+-- 1.0.196 — direct wekken, achterstand in één aanroep, gegevens voor karindeling, sticker opnieuw, rebuffer-slot
+
+CREATE OR REPLACE FUNCTION public.logistics_plan_now_gate(p_order_ids uuid[])
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE
+  v_running boolean; v_last timestamptz;
+  v_debounce int := public.logistics_plan_setting('kick_debounce_seconds', 5)::int;
+  v_n int := coalesce(cardinality(p_order_ids), 0);
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_plan_now_gate');
+  IF v_n > 1000 THEN
+    RAISE EXCEPTION 'Maximaal 1000 orders per aanroep (ontvangen: %).', v_n USING ERRCODE = '22023';
+  END IF;
+  SELECT EXISTS (SELECT 1 FROM public.logistics_plan_locks WHERE lock_key = 'tick:ronde' AND locked_until > now())
+    INTO v_running;
+  IF v_running THEN
+    INSERT INTO public.logistics_plan_settings(key, value, updated_at)
+    VALUES ('kick_pending', clock_timestamp()::text, now())
+    ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+    BEGIN INSERT INTO public.logistics_kick_log(skipped_reason) VALUES ('plan_now_vlag_gezet'); EXCEPTION WHEN OTHERS THEN NULL; END;
+    RETURN jsonb_build_object('actie', 'vlag_gezet', 'orders', v_n);
+  END IF;
+  SELECT NULLIF(value,'')::timestamptz INTO v_last FROM public.logistics_plan_settings WHERE key = 'last_kick_at';
+  IF v_last IS NOT NULL AND v_last > now() - make_interval(secs => v_debounce) THEN
+    -- Binnen de wachttijd: niet laten vallen, de eerstvolgende ronde pakt de vlag op.
+    INSERT INTO public.logistics_plan_settings(key, value, updated_at)
+    VALUES ('kick_pending', clock_timestamp()::text, now())
+    ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+    BEGIN INSERT INTO public.logistics_kick_log(skipped_reason) VALUES ('plan_now_debounce'); EXCEPTION WHEN OTHERS THEN NULL; END;
+    RETURN jsonb_build_object('actie', 'debounce', 'orders', v_n);
+  END IF;
+  INSERT INTO public.logistics_plan_settings(key, value, updated_at)
+  VALUES ('last_kick_at', now()::text, now())
+  ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+  BEGIN INSERT INTO public.logistics_kick_log(skipped_reason) VALUES ('plan_now_start'); EXCEPTION WHEN OTHERS THEN NULL; END;
+  RETURN jsonb_build_object('actie', 'start', 'orders', v_n);
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_plan_now_gate(uuid[]) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_order_backlog_info_many(p_order_ids uuid[])
+RETURNS TABLE(order_id uuid, info jsonb, achterstand boolean, leverdatum date, dagen integer)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_order_backlog_info_many');
+  IF coalesce(cardinality(p_order_ids), 0) > 1000 THEN
+    RAISE EXCEPTION 'Maximaal 1000 orders per aanroep (ontvangen: %).', cardinality(p_order_ids) USING ERRCODE = '22023';
+  END IF;
+  RETURN QUERY
+  WITH ids AS (SELECT DISTINCT u AS id FROM unnest(coalesce(p_order_ids, '{}'::uuid[])) u WHERE u IS NOT NULL),
+  today AS (SELECT (now() AT TIME ZONE public.logistics_tz())::date AS d),
+  hit AS (
+    SELECT o.id, (o.delivery_date::text)::date AS ld
+      FROM public.orders o JOIN ids ON ids.id = o.id, today
+     WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL
+       AND COALESCE(o.is_reservation, false) = false
+       AND lower(coalesce(o.status, '')) = 'nog te picken'
+       AND NULLIF(o.delivery_date::text, '') IS NOT NULL
+       AND (o.delivery_date::text)::date < today.d
+       AND NOT public.logistics_order_handled(o.id)
+       AND NOT EXISTS (SELECT 1 FROM public.floriday_salesorders_cache fc
+          WHERE o.floriday_sales_order_id IS NOT NULL AND fc.floriday_id = o.floriday_sales_order_id AND fc.controlled_at IS NOT NULL)
+  )
+  SELECT ids.id,
+         CASE WHEN h.id IS NULL THEN NULL
+              ELSE jsonb_build_object('achterstand', true, 'leverdatum', h.ld, 'dagen', t.d - h.ld) END,
+         h.id IS NOT NULL, h.ld, CASE WHEN h.id IS NULL THEN NULL ELSE t.d - h.ld END
+    FROM ids CROSS JOIN today t LEFT JOIN hit h ON h.id = ids.id;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_order_backlog_info_many(uuid[]) TO authenticated, service_role;
+
+-- E4/E5: gegevens voor karindeling
+CREATE OR REPLACE FUNCTION public.logistics_data_gereedheid(p_product_ids uuid[] DEFAULT NULL)
+RETURNS TABLE(product_id uuid, product text, ladingdrager text, methode text, in_open_order boolean,
+              ontbrekend text[], velden jsonb, voorstel jsonb, uitleg text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_methode text; v_carrier text; c record;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_data_gereedheid');
+  SELECT CASE WHEN coalesce(s.settings->'karrenindeling'->'fields'->>'cart_layout_method', s.settings->'karrenindeling'->>'cart_layout_method') = 'afmetingen'
+              THEN 'afmetingen' ELSE 'belading' END,
+         nullif(btrim(coalesce(s.settings->'karrenindeling'->'fields'->>'default_carrier_type', s.settings->'karrenindeling'->>'default_carrier_type')), '')
+    INTO v_methode, v_carrier
+    FROM public.logistics_rule_configs s WHERE s.is_active ORDER BY s.updated_at DESC LIMIT 1;
+  v_methode := coalesce(v_methode, 'belading');
+  SELECT t.code, t.name, t.layer_length_cm, t.layer_width_cm, t.max_height_cm INTO c
+    FROM public.load_carrier_types t
+   WHERE t.is_active AND (t.code = v_carrier OR (v_carrier IS NULL AND t.is_default))
+   ORDER BY (t.code = v_carrier) DESC NULLS LAST LIMIT 1;
+
+  RETURN QUERY
+  WITH open_p AS (
+    SELECT DISTINCT oi.product_id FROM public.orders o JOIN public.order_items oi ON oi.order_id = o.id
+     WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL AND coalesce(o.is_reservation,false) = false
+       AND lower(coalesce(o.status,'')) = 'nog te picken' AND oi.product_id IS NOT NULL
+  ),
+  p AS (
+    SELECT pr.id, pr.product, pr.plants_per_crate, pr.crates_per_layer, pr.layers_per_cart,
+           NULLIF(regexp_replace(coalesce(pr.weight::text,''), '[^0-9.,]', '', 'g'), '') AS weight_txt,
+           pr.plant_height_cm, pr.fust_type_id, pr.floriday_packing_source,
+           ft.length_mm, ft.width_mm, ft.height_mm,
+           (op.product_id IS NOT NULL) AS in_open
+      FROM public.products pr
+      LEFT JOIN public.fust_types ft ON ft.id = pr.fust_type_id
+      LEFT JOIN open_p op ON op.product_id = pr.id
+     WHERE (p_product_ids IS NULL AND op.product_id IS NOT NULL) OR pr.id = ANY(p_product_ids)
+  ),
+  m AS (
+    SELECT p.*,
+      array_remove(ARRAY[
+        CASE WHEN coalesce(p.plants_per_crate,0) <= 0 THEN 'plants_per_crate' END,
+        CASE WHEN v_methode = 'belading' AND coalesce(p.crates_per_layer,0) <= 0 THEN 'crates_per_layer' END,
+        CASE WHEN v_methode = 'belading' AND coalesce(p.layers_per_cart,0) <= 0 THEN 'layers_per_cart' END,
+        CASE WHEN v_methode = 'afmetingen' AND p.fust_type_id IS NULL THEN 'fust_type_id' END,
+        CASE WHEN v_methode = 'afmetingen' AND coalesce(p.plant_height_cm,0) <= 0 THEN 'plant_height_cm' END,
+        CASE WHEN p.weight_txt IS NULL THEN 'weight' END
+      ], NULL) AS mist,
+      -- Fusten per laag uit fustmaat × laagmaat (beide oriëntaties, raster).
+      CASE WHEN p.length_mm > 0 AND p.width_mm > 0 AND c.layer_length_cm > 0 AND c.layer_width_cm > 0 THEN
+        greatest(floor(c.layer_length_cm*10 / p.length_mm) * floor(c.layer_width_cm*10 / p.width_mm),
+                 floor(c.layer_length_cm*10 / p.width_mm) * floor(c.layer_width_cm*10 / p.length_mm))::int END AS calc_cpl,
+      -- Lagen per kar uit planthoogte + fusthoogte tegen hoogte ladingdrager.
+      CASE WHEN coalesce(p.plant_height_cm,0) > 0 AND c.max_height_cm > 0 THEN
+        floor(c.max_height_cm / (p.plant_height_cm + coalesce(p.height_mm,0)/10.0))::int END AS calc_lpc
+    FROM p
+  )
+  SELECT m.id, m.product, c.code, v_methode, m.in_open, m.mist,
+    jsonb_build_object(
+      'plants_per_crate', jsonb_build_object('waarde', m.plants_per_crate, 'bron', CASE WHEN m.plants_per_crate > 0 THEN coalesce(m.floriday_packing_source, 'product') END),
+      'crates_per_layer', jsonb_build_object('waarde', m.crates_per_layer, 'bron', CASE WHEN m.crates_per_layer > 0 THEN coalesce(m.floriday_packing_source, 'product') END),
+      'layers_per_cart', jsonb_build_object('waarde', m.layers_per_cart, 'bron', CASE WHEN m.layers_per_cart > 0 THEN coalesce(m.floriday_packing_source, 'product') END),
+      'weight', jsonb_build_object('waarde', m.weight_txt, 'bron', CASE WHEN m.weight_txt IS NOT NULL THEN 'product' END),
+      'plant_height_cm', jsonb_build_object('waarde', m.plant_height_cm, 'bron', CASE WHEN m.plant_height_cm > 0 THEN 'product' END),
+      'fust_type_id', jsonb_build_object('waarde', m.fust_type_id, 'bron', CASE WHEN m.fust_type_id IS NOT NULL THEN 'product' END)),
+    jsonb_strip_nulls(jsonb_build_object(
+      'crates_per_layer', CASE WHEN m.calc_cpl > 0 THEN jsonb_build_object('waarde', m.calc_cpl, 'bron', 'berekend',
+          'berekening', format('fust %s×%s mm op laag %s×%s cm (%s)', m.length_mm, m.width_mm, c.layer_length_cm, c.layer_width_cm, c.name))
+        ELSE (SELECT jsonb_build_object('waarde', x.v, 'bron', 'vergelijkbaar', 'berekening', format('meest gebruikt bij %s product(en) met dezelfde fust', x.n))
+                FROM (SELECT p2.crates_per_layer v, count(*) n FROM public.products p2
+                       WHERE m.fust_type_id IS NOT NULL AND p2.fust_type_id = m.fust_type_id AND p2.crates_per_layer > 0 AND p2.id <> m.id
+                       GROUP BY 1 ORDER BY 2 DESC LIMIT 1) x) END,
+      'layers_per_cart', CASE WHEN m.calc_lpc > 0 THEN jsonb_build_object('waarde', m.calc_lpc, 'bron', 'berekend',
+          'berekening', format('hoogte %s cm / (plant %s cm + fust %s cm)', c.max_height_cm, m.plant_height_cm, round(coalesce(m.height_mm,0)/10.0,1)))
+        ELSE (SELECT jsonb_build_object('waarde', x.v, 'bron', 'vergelijkbaar', 'berekening', format('meest gebruikt bij %s product(en) met dezelfde fust', x.n))
+                FROM (SELECT p2.layers_per_cart v, count(*) n FROM public.products p2
+                       WHERE m.fust_type_id IS NOT NULL AND p2.fust_type_id = m.fust_type_id AND p2.layers_per_cart > 0 AND p2.id <> m.id
+                       GROUP BY 1 ORDER BY 2 DESC LIMIT 1) x) END)),
+    CASE WHEN cardinality(m.mist) = 0 THEN 'Compleet.'
+         ELSE format('Bij "%s" ontbreekt: %s. Vul dit in bij het product (Voorraad) of hier met "Invullen".', m.product,
+           array_to_string(ARRAY(SELECT CASE f WHEN 'plants_per_crate' THEN 'planten per fust' WHEN 'crates_per_layer' THEN 'fusten per laag'
+             WHEN 'layers_per_cart' THEN 'lagen per kar' WHEN 'fust_type_id' THEN 'fustsoort' WHEN 'plant_height_cm' THEN 'planthoogte'
+             WHEN 'weight' THEN 'gewicht per fust' ELSE f END FROM unnest(m.mist) f), ', ')) END
+  FROM m
+  ORDER BY cardinality(m.mist) DESC, m.in_open DESC, m.product
+  LIMIT 2000;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_data_gereedheid(uuid[]) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_data_vul_in(p_product_id uuid, p_veld text, p_waarde numeric)
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  PERFORM public.logistics_acc_guard('beheer', 'logistics_data_vul_in');
+  IF p_waarde IS NULL OR p_waarde <= 0 THEN
+    RAISE EXCEPTION 'Vul een getal groter dan 0 in.' USING ERRCODE = '22023';
+  END IF;
+  IF p_veld = 'plants_per_crate' THEN UPDATE public.products SET plants_per_crate = p_waarde, updated_at = now() WHERE id = p_product_id;
+  ELSIF p_veld = 'crates_per_layer' THEN UPDATE public.products SET crates_per_layer = p_waarde, updated_at = now() WHERE id = p_product_id;
+  ELSIF p_veld = 'layers_per_cart' THEN UPDATE public.products SET layers_per_cart = p_waarde, updated_at = now() WHERE id = p_product_id;
+  ELSIF p_veld = 'plant_height_cm' THEN UPDATE public.products SET plant_height_cm = p_waarde, updated_at = now() WHERE id = p_product_id;
+  ELSIF p_veld = 'weight' THEN UPDATE public.products SET weight = p_waarde, updated_at = now() WHERE id = p_product_id;
+  ELSE RAISE EXCEPTION 'Dit veld kan hier niet worden ingevuld: %', p_veld USING ERRCODE = '22023';
+  END IF;
+  IF NOT FOUND THEN RAISE EXCEPTION 'Product niet gevonden.' USING ERRCODE = 'P0002'; END IF;
+  RETURN jsonb_build_object('ok', true, 'productId', p_product_id, 'veld', p_veld, 'waarde', p_waarde);
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_data_vul_in(uuid, text, numeric) TO authenticated, service_role;
+
+-- 4: geweigerde sticker opnieuw proberen (status blijft binnen bestaande CHECK)
+CREATE OR REPLACE FUNCTION public.logistics_sticker_retry(p_id uuid)
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  PERFORM public.logistics_acc_guard('beheer', 'logistics_sticker_retry');
+  UPDATE public.logistics_sticker_prints
+     SET status = 'klaar', reden = NULL, print_job_id = NULL, attempts = 0, next_attempt_at = NULL, updated_at = now()
+   WHERE id = p_id AND status IN ('geblokkeerd', 'mislukt');
+  IF NOT FOUND THEN
+    RAISE EXCEPTION 'Deze sticker is niet geblokkeerd of mislukt; opnieuw proberen is niet nodig.' USING ERRCODE = '22023';
+  END IF;
+  RETURN jsonb_build_object('ok', true, 'id', p_id);
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_sticker_retry(uuid) TO authenticated, service_role;
+
+-- 6: rebuffer-instelling onder advisory lock (geen deadlock meer bij gelijktijdige aanroepen)
+CREATE OR REPLACE FUNCTION public.logistics_ensure_rebuffer_setting()
+RETURNS integer LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_n integer := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_ensure_rebuffer_setting');
+  -- 1.0.196: één tegelijk; bezet = overslaan zonder fout. Daarna rijen in vaste volgorde vergrendelen.
+  IF NOT pg_try_advisory_xact_lock(hashtext('logistics_ensure_rebuffer_setting')) THEN
+    RETURN 0;
+  END IF;
+  PERFORM 1 FROM public.logistics_rule_configs c
+   WHERE NOT coalesce(c.settings->'order_verwerking'->'fields' ? 'rebuffer_on_change', false)
+     AND NOT coalesce(c.settings->'order_verwerking' ? 'rebuffer_on_change', false)
+   ORDER BY c.id FOR UPDATE SKIP LOCKED;
+  UPDATE public.logistics_rule_configs c
+     SET settings = jsonb_set(coalesce(c.settings, '{}'::jsonb), '{order_verwerking}',
+           coalesce(c.settings->'order_verwerking', '{}'::jsonb)
+             || jsonb_build_object('fields', coalesce(c.settings->'order_verwerking'->'fields', '{}'::jsonb)
+                                            || jsonb_build_object('rebuffer_on_change', true)), true)
+   WHERE c.id IS NOT NULL
+     AND NOT coalesce(c.settings->'order_verwerking'->'fields' ? 'rebuffer_on_change', false)
+     AND NOT coalesce(c.settings->'order_verwerking' ? 'rebuffer_on_change', false);
+  GET DIAGNOSTICS v_n = ROW_COUNT;
+  RETURN v_n;
+END $$;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_196()
+RETURNS TABLE(controle text, ok boolean, toelichting text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_install_check_196');
+  RETURN QUERY SELECT 'Engine: direct wekken (plan-now) – sleutel ingesteld'::text,
+    EXISTS (SELECT 1 FROM public.module_runtime_config WHERE key = 'logistics_tick_apikey' AND nullif(btrim(value),'') IS NOT NULL),
+    'module_runtime_config logistics_tick_apikey; zonder sleutel antwoordt de route 500.'::text;
+  RETURN QUERY SELECT 'Engine: poort direct wekken aanwezig', to_regprocedure('public.logistics_plan_now_gate(uuid[])') IS NOT NULL, 'logistics_plan_now_gate';
+  RETURN QUERY SELECT 'Engine: achterstand in één aanroep', to_regprocedure('public.logistics_order_backlog_info_many(uuid[])') IS NOT NULL, 'logistics_order_backlog_info_many';
+  RETURN QUERY SELECT 'Engine: gegevens voor karindeling', to_regprocedure('public.logistics_data_gereedheid(uuid[])') IS NOT NULL, 'logistics_data_gereedheid';
+  RETURN QUERY SELECT 'Engine: sticker opnieuw proberen', to_regprocedure('public.logistics_sticker_retry(uuid)') IS NOT NULL, 'logistics_sticker_retry';
+  RETURN QUERY SELECT 'Engine: rebuffer-instelling onder slot',
+    coalesce(pg_get_functiondef('public.logistics_ensure_rebuffer_setting()'::regprocedure) LIKE '%pg_try_advisory_xact_lock%', false),
+    'voorkomt deadlock bij gelijktijdige aanroep';
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_196() TO authenticated, service_role;
+DO $do$ DECLARE d text;
+BEGIN
+  d := pg_get_functiondef('public.logistics_install_check()'::regprocedure);
+  IF position('logistics_install_check_196' in d) = 0 THEN
+    d := replace(d, $r$  RETURN QUERY SELECT * FROM public.logistics_access_check();$r$,
+                    $r$  RETURN QUERY SELECT * FROM public.logistics_install_check_196();
+  RETURN QUERY SELECT * FROM public.logistics_access_check();$r$);
+    EXECUTE d;
+  END IF;
+EXCEPTION WHEN undefined_function THEN NULL;
+END $do$;
+
+-- ===== 1.0.197 =====
+-- ============================================================================
+-- logistiek-engine 1.0.197 — unieke karnummering per buffer (incl. bevroren
+-- karren uit eerdere buffers), "van N" over alle karren, orderscherm telt via de
+-- buffer, fysieke beladingscontrole in de installatiecontrole (additief, idempotent)
+-- ============================================================================
+
+-- Kern zonder guard en zonder SECURITY DEFINER: RLS van de aanroeper blijft gelden.
+CREATE OR REPLACE FUNCTION public.logistics_order_unit_carts_core(p_order_ids uuid[])
+RETURNS TABLE(cart_id uuid, cart_number integer, buffer_id uuid, order_id uuid, display_seq integer, display_total integer)
+LANGUAGE sql STABLE SET search_path TO 'public' AS $$
+  WITH ords AS (
+    SELECT o.id, o.buffer_id FROM public.orders o WHERE o.id = ANY(coalesce(p_order_ids, '{}'::uuid[]))
+  ),
+  bufs AS (SELECT DISTINCT b.buffer_id FROM ords b WHERE b.buffer_id IS NOT NULL),
+  ords2 AS (
+    SELECT o.id FROM ords o
+    UNION
+    SELECT o.id FROM public.orders o
+     WHERE o.buffer_id IN (SELECT bb.buffer_id FROM bufs bb) AND o.deleted_at IS NULL AND o.cancelled_at IS NULL
+  ),
+  k AS (
+    SELECT c.id FROM logistics_active.order_carts c WHERE c.order_id IN (SELECT x.id FROM ords2 x)
+    UNION
+    SELECT ci.cart_id FROM logistics_active.order_cart_items ci
+      JOIN public.order_items oi ON oi.id = ci.order_item_id
+     WHERE oi.order_id IN (SELECT x.id FROM ords2 x)
+    UNION
+    SELECT c.id FROM logistics_active.order_carts c
+     WHERE c.order_id IS NULL AND c.buffer_id IN (SELECT bb.buffer_id FROM bufs bb)
+  ),
+  base AS (
+    SELECT c.id, c.cart_number, c.buffer_id, c.order_id, c.created_at,
+           min(c.created_at) OVER (PARTITION BY coalesce(c.buffer_id, c.id)) AS grp_at
+      FROM logistics_active.order_carts c WHERE c.id IN (SELECT k.id FROM k)
+  ),
+  f AS (
+    SELECT count(*)::int AS n, count(DISTINCT b.cart_number)::int AS nd,
+           coalesce(max(b.cart_number), 0)::int AS mx,
+           count(*) FILTER (WHERE b.cart_number IS NULL)::int AS leeg
+      FROM base b
+  )
+  SELECT b.id, b.cart_number, b.buffer_id, b.order_id,
+         CASE WHEN f.nd = f.n AND f.leeg = 0 THEN b.cart_number
+              ELSE row_number() OVER (ORDER BY b.grp_at, coalesce(b.buffer_id, b.id), b.cart_number NULLS LAST, b.id)::int END,
+         CASE WHEN f.nd = f.n AND f.leeg = 0 THEN greatest(f.n, f.mx) ELSE f.n END
+    FROM base b CROSS JOIN f
+$$;
+
+CREATE OR REPLACE FUNCTION public.logistics_order_unit_carts(p_order_ids uuid[])
+RETURNS TABLE(cart_id uuid, cart_number integer, buffer_id uuid, order_id uuid, display_seq integer, display_total integer)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_order_unit_carts');
+  IF coalesce(cardinality(p_order_ids), 0) > 1000 THEN
+    RAISE EXCEPTION 'Maximaal 1000 orders per aanroep (ontvangen: %).', cardinality(p_order_ids) USING ERRCODE = '22023';
+  END IF;
+  RETURN QUERY SELECT * FROM public.logistics_order_unit_carts_core(p_order_ids);
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_order_unit_carts(uuid[]) TO authenticated, service_role;
+
+-- Bestaande handtekening blijft; weergave nu uniek binnen de hele eenheid.
+CREATE OR REPLACE FUNCTION public.logistics_cart_fixed_numbering(p_cart_id uuid)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE c record; v_ids uuid[]; u record; v_total int;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_cart_fixed_numbering');
+  SELECT * INTO c FROM public.order_carts WHERE id = p_cart_id;
+  IF NOT FOUND THEN RETURN NULL; END IF;
+  IF c.archived_at IS NULL THEN
+    SELECT array_agg(DISTINCT s.x) INTO v_ids FROM (
+      SELECT c.order_id AS x
+      UNION SELECT oi.order_id FROM public.order_cart_items ci JOIN public.order_items oi ON oi.id = ci.order_item_id WHERE ci.cart_id = p_cart_id
+      UNION SELECT o.id FROM public.orders o WHERE c.buffer_id IS NOT NULL AND o.buffer_id = c.buffer_id AND o.deleted_at IS NULL
+    ) s WHERE s.x IS NOT NULL;
+    IF v_ids IS NOT NULL THEN
+      SELECT * INTO u FROM public.logistics_order_unit_carts_core(v_ids) z WHERE z.cart_id = p_cart_id;
+      IF FOUND AND u.display_seq IS NOT NULL THEN
+        RETURN jsonb_build_object('cartSeq', u.display_seq, 'cartIndex', u.display_seq, 'cartTotal', u.display_total,
+          'cartLabel', 'Kar ' || u.display_seq || ' van ' || u.display_total, 'storedCartNumber', c.cart_number);
+      END IF;
+    END IF;
+  END IF;
+  -- Terugval (gearchiveerde kar of geen orders): oude berekening.
+  SELECT greatest(coalesce(max(c2.total_carts), 0), count(*)::int, coalesce(c.cart_number, 0)) INTO v_total
+    FROM public.order_carts c2
+   WHERE (c.order_id IS NULL AND c.buffer_id IS NOT NULL AND c2.order_id IS NULL AND c2.buffer_id = c.buffer_id)
+      OR (c.order_id IS NOT NULL AND c2.order_id = c.order_id)
+      OR (c.order_id IS NULL AND c.buffer_id IS NULL AND c2.id = c.id);
+  RETURN jsonb_build_object('cartSeq', c.cart_number, 'cartIndex', c.cart_number, 'cartTotal', v_total,
+    'cartLabel', 'Kar ' || c.cart_number || ' van ' || v_total);
+END $$;
+
+-- Orderscherm: tel alle karren van de eenheid (buffer + karren met goederen van de order).
+CREATE OR REPLACE FUNCTION public.logistics_live_cart_count(p_order_ref text)
+RETURNS integer LANGUAGE sql STABLE SET search_path TO 'public' AS $$
+  SELECT COALESCE(
+    NULLIF((SELECT count(*)::int FROM public.logistics_order_unit_carts_core(
+              ARRAY(SELECT o.id FROM public.orders o WHERE o.order_number = p_order_ref AND o.deleted_at IS NULL))), 0),
+    public.logistics_order_cart_count(p_order_ref),
+    0);
+$$;
+
+-- Controle: actieve pakbonnen met dezelfde naam (alleen melden, niets wijzigen).
+CREATE OR REPLACE FUNCTION public.logistics_dubbele_pakbonnamen()
+RETURNS TABLE(document_number text, aantal integer, karren text[])
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_dubbele_pakbonnamen');
+  RETURN QUERY
+  SELECT q.document_number, count(*)::int, array_agg(q.reference ORDER BY q.reference)
+    FROM public.pick_queue q
+   WHERE q.cancelled_at IS NULL AND q.document_number LIKE 'PB-%-K%'
+   GROUP BY q.document_number HAVING count(*) > 1;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_dubbele_pakbonnamen() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_197()
+RETURNS TABLE(controle text, ok boolean, toelichting text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_dub int;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_install_check_197');
+  RETURN QUERY SELECT 'Engine: karnummering per eenheid'::text,
+    to_regprocedure('public.logistics_order_unit_carts(uuid[])') IS NOT NULL
+      AND coalesce(pg_get_functiondef('public.logistics_cart_fixed_numbering(uuid)'::regprocedure) LIKE '%logistics_order_unit_carts_core%', false),
+    'logistics_order_unit_carts + logistics_cart_fixed_numbering'::text;
+  RETURN QUERY SELECT 'Engine: orderscherm telt karren via de buffer',
+    coalesce(pg_get_functiondef('public.logistics_live_cart_count(text)'::regprocedure) LIKE '%logistics_order_unit_carts_core%', false),
+    'logistics_live_cart_count';
+  BEGIN
+    SELECT count(*) INTO v_dub FROM public.logistics_dubbele_pakbonnamen();
+    RETURN QUERY SELECT 'Engine: geen dubbele pakbonnamen', v_dub = 0,
+      CASE WHEN v_dub = 0 THEN 'geen' ELSE v_dub || ' naam/namen dubbel; de eerstvolgende pakbonronde zet het unieke nummer' END;
+  EXCEPTION WHEN undefined_table THEN
+    RETURN QUERY SELECT 'Engine: geen dubbele pakbonnamen', true, 'pick_queue ontbreekt in deze Shell';
+  END;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_197() TO authenticated, service_role;
+
+DO $do$ DECLARE d text;
+BEGIN
+  d := pg_get_functiondef('public.logistics_install_check()'::regprocedure);
+  IF position('logistics_install_check_197' in d) = 0 THEN
+    d := replace(d, $r$  RETURN QUERY SELECT * FROM public.logistics_access_check();$r$,
+                    $r$  RETURN QUERY SELECT * FROM public.logistics_install_check_197();
+  RETURN QUERY SELECT * FROM public.logistics_access_check();$r$);
+    EXECUTE d;
+  END IF;
+EXCEPTION WHEN undefined_function THEN NULL;
+END $do$;
+
+-- ============================================================================
+-- 1.0.198: maten hergebruiken uit Floricode/Floriday/Voorraad; niets stil invullen
+-- ============================================================================
+
+-- Bronregistratie van overgenomen of bevestigde waarden (Engine-eigendom).
+CREATE TABLE IF NOT EXISTS public.logistics_gegevens_bron (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  onderwerp text NOT NULL,
+  sleutel text NOT NULL,
+  veld text NOT NULL,
+  waarde text,
+  bron text NOT NULL,
+  toelichting text,
+  vastgelegd_door uuid,
+  vastgelegd_op timestamptz NOT NULL DEFAULT now(),
+  UNIQUE (onderwerp, sleutel, veld)
+);
+GRANT SELECT ON public.logistics_gegevens_bron TO authenticated;
+GRANT ALL ON public.logistics_gegevens_bron TO service_role;
+ALTER TABLE public.logistics_gegevens_bron ENABLE ROW LEVEL SECURITY;
+DO $do$ BEGIN
+  IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE schemaname = 'public' AND tablename = 'logistics_gegevens_bron' AND policyname = 'logistics_gegevens_bron_lezen') THEN
+    CREATE POLICY logistics_gegevens_bron_lezen ON public.logistics_gegevens_bron FOR SELECT TO authenticated USING (true);
+  END IF;
+END $do$;
+
+-- Positief getal uit tekst, anders NULL. Nooit een standaardwaarde.
+CREATE OR REPLACE FUNCTION public.logistics_pos_num(p text)
+RETURNS numeric LANGUAGE sql IMMUTABLE SET search_path TO 'public' AS $$
+  SELECT CASE WHEN replace(btrim(coalesce(p, '')), ',', '.') ~ '^[0-9]+(\.[0-9]+)?$'
+              THEN NULLIF(replace(btrim(p), ',', '.')::numeric, 0) END
+$$;
+GRANT EXECUTE ON FUNCTION public.logistics_pos_num(text) TO authenticated, service_role;
+
+-- VBN-kenmerkwaarde in cm. Met Floricode: alleen een omschrijving "N cm" telt;
+-- een bereik of andere tekst = onbekend. Zonder Floricode-tabel: de code zelf (cm).
+CREATE OR REPLACE FUNCTION public.logistics_vbn_cm(p_feature text, p_code text)
+RETURNS numeric LANGUAGE plpgsql STABLE SET search_path TO 'public' AS $$
+DECLARE v_desc text; v_found boolean := false;
+BEGIN
+  IF p_code IS NULL OR btrim(p_code) = '' THEN RETURN NULL; END IF;
+  IF to_regclass('public.floricode_records') IS NOT NULL THEN
+    EXECUTE $q$SELECT r.data->>'description' FROM public.floricode_records r
+                WHERE r.resource = 'FeatureValue' AND r.data->>'feature_type_id' = $1 AND r.data->>'code' = $2
+                ORDER BY (r.data->>'expiry_date') IS NULL DESC LIMIT 1$q$
+      INTO v_desc USING p_feature, p_code;
+    v_found := v_desc IS NOT NULL;
+  END IF;
+  IF v_found THEN
+    IF v_desc ~* '^\s*[0-9]+([.,][0-9]+)?\s*cm\s*$' THEN
+      RETURN public.logistics_pos_num(regexp_replace(v_desc, '[^0-9.,]', '', 'g'));
+    END IF;
+    RETURN NULL;
+  END IF;
+  RETURN public.logistics_pos_num(p_code);
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_vbn_cm(text, text) TO authenticated, service_role;
+
+-- 1: eigen terugval voor fustmaten. Per veld: Floricode -> Floriday custom package -> handmatig -> onbekend.
+CREATE OR REPLACE FUNCTION public.logistics_fust_maten_terugval()
+RETURNS TABLE(fust_type_id uuid, fust_key text, vbn_code integer, name text,
+              length_mm numeric, width_mm numeric, height_mm numeric,
+              lengte_bron text, breedte_bron text, hoogte_bron text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+#variable_conflict use_column
+DECLARE v_fc text; v_fd text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_fust_maten_terugval');
+  IF to_regprocedure('public.floricode_packaging_types()') IS NOT NULL THEN
+    v_fc := $q$SELECT DISTINCT ON (c.code::text)
+                 CASE WHEN c.code::text ~ '^[0-9]+$' THEN c.code::text::int END AS code,
+                 public.logistics_pos_num(c.length_mm::text) AS l, public.logistics_pos_num(c.width_mm::text) AS w,
+                 public.logistics_pos_num(c.height_mm::text) AS h
+               FROM public.floricode_packaging_types() c ORDER BY c.code::text, c.expiry_date DESC NULLS FIRST$q$;
+  ELSIF to_regclass('public.floricode_records') IS NOT NULL THEN
+    v_fc := $q$SELECT DISTINCT ON (r.data->>'code')
+                 CASE WHEN (r.data->>'code') ~ '^[0-9]+$' THEN (r.data->>'code')::int END AS code,
+                 public.logistics_pos_num(r.data->>'length') AS l, public.logistics_pos_num(r.data->>'width') AS w,
+                 public.logistics_pos_num(r.data->>'height') AS h
+               FROM public.floricode_records r WHERE r.resource = 'LoadCarrier'
+               ORDER BY r.data->>'code', (r.data->>'expiry_date') DESC NULLS FIRST$q$;
+  ELSE
+    v_fc := $q$SELECT NULL::int AS code, NULL::numeric AS l, NULL::numeric AS w, NULL::numeric AS h WHERE false$q$;
+  END IF;
+  IF to_regclass('public.floriday_packings_cache') IS NOT NULL THEN
+    v_fd := $q$SELECT DISTINCT ON (p.floriday_id) p.floriday_id AS id, p.data->>'customPackageId' AS id2,
+                 public.logistics_pos_num(coalesce(p.data->'dimension'->>'length', p.data->'dimensions'->>'length', p.data->>'lengthInMm', p.data->>'length')) AS l,
+                 public.logistics_pos_num(coalesce(p.data->'dimension'->>'width', p.data->'dimensions'->>'width', p.data->>'widthInMm', p.data->>'width')) AS w,
+                 public.logistics_pos_num(coalesce(p.data->'dimension'->>'height', p.data->'dimensions'->>'height', p.data->>'heightInMm', p.data->>'height')) AS h
+               FROM public.floriday_packings_cache p WHERE coalesce(p.is_deleted, false) = false
+               ORDER BY p.floriday_id, p.updated_at DESC NULLS LAST$q$;
+  ELSE
+    v_fd := $q$SELECT NULL::text AS id, NULL::text AS id2, NULL::numeric AS l, NULL::numeric AS w, NULL::numeric AS h WHERE false$q$;
+  END IF;
+  RETURN QUERY EXECUTE format($q$
+    WITH fc AS (%s), fd AS (%s)
+    SELECT f.id, f.fust_key, f.vbn_code, f.name,
+      coalesce(fc.l, fdx.l, public.logistics_pos_num(f.length_mm::text)),
+      coalesce(fc.w, fdx.w, public.logistics_pos_num(f.width_mm::text)),
+      coalesce(fc.h, fdx.h, public.logistics_pos_num(f.height_mm::text)),
+      CASE WHEN fc.l IS NOT NULL THEN 'floricode' WHEN fdx.l IS NOT NULL THEN 'floriday' WHEN public.logistics_pos_num(f.length_mm::text) IS NOT NULL THEN 'handmatig' ELSE 'onbekend' END,
+      CASE WHEN fc.w IS NOT NULL THEN 'floricode' WHEN fdx.w IS NOT NULL THEN 'floriday' WHEN public.logistics_pos_num(f.width_mm::text) IS NOT NULL THEN 'handmatig' ELSE 'onbekend' END,
+      CASE WHEN fc.h IS NOT NULL THEN 'floricode' WHEN fdx.h IS NOT NULL THEN 'floriday' WHEN public.logistics_pos_num(f.height_mm::text) IS NOT NULL THEN 'handmatig' ELSE 'onbekend' END
+    FROM public.fust_types f
+    LEFT JOIN fc ON fc.code = coalesce(f.vbn_code, CASE WHEN f.fust_key ~ '^vbn:[0-9]+$' THEN substr(f.fust_key, 5)::int END)
+    LEFT JOIN LATERAL (SELECT fd.l, fd.w, fd.h FROM fd
+                        WHERE nullif(f.custom_package_id, '') IS NOT NULL AND (fd.id = f.custom_package_id OR fd.id2 = f.custom_package_id)
+                        LIMIT 1) fdx ON true
+  $q$, v_fc, v_fd);
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_fust_maten_terugval() TO authenticated, service_role;
+
+-- 1: fustmaten. Voorraad (voorraad_fust_dimensions) als die bestaat, anders de eigen terugval.
+CREATE OR REPLACE FUNCTION public.logistics_fust_maten()
+RETURNS TABLE(fust_type_id uuid, fust_key text, vbn_code integer, name text,
+              length_mm numeric, width_mm numeric, height_mm numeric,
+              lengte_bron text, breedte_bron text, hoogte_bron text, pad text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+#variable_conflict use_column
+DECLARE j jsonb; v_src text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_fust_maten');
+  IF to_regprocedure('public.voorraad_fust_dimensions()') IS NOT NULL THEN
+    FOR j IN EXECUTE 'SELECT to_jsonb(x) FROM public.voorraad_fust_dimensions() x' LOOP
+      fust_type_id := (j->>'fust_type_id')::uuid;
+      fust_key := j->>'fust_key';
+      vbn_code := CASE WHEN (j->>'vbn_code') ~ '^[0-9]+$' THEN (j->>'vbn_code')::int END;
+      name := j->>'name';
+      length_mm := public.logistics_pos_num(j->>'length_mm');
+      width_mm := public.logistics_pos_num(j->>'width_mm');
+      height_mm := public.logistics_pos_num(j->>'height_mm');
+      v_src := nullif(j->>'dimension_source', 'onbekend');
+      lengte_bron := CASE WHEN length_mm IS NULL THEN 'onbekend' ELSE coalesce(j->>'length_source', j->>'lengte_bron', v_src, 'voorraad') END;
+      breedte_bron := CASE WHEN width_mm IS NULL THEN 'onbekend' ELSE coalesce(j->>'width_source', j->>'breedte_bron', v_src, 'voorraad') END;
+      hoogte_bron := CASE WHEN height_mm IS NULL THEN 'onbekend' ELSE coalesce(j->>'height_source', j->>'hoogte_bron', v_src, 'voorraad') END;
+      pad := 'voorraad';
+      RETURN NEXT;
+    END LOOP;
+    RETURN;
+  END IF;
+  RETURN QUERY SELECT t.fust_type_id, t.fust_key, t.vbn_code, t.name, t.length_mm, t.width_mm, t.height_mm,
+                      t.lengte_bron, t.breedte_bron, t.hoogte_bron, 'terugval'::text
+                 FROM public.logistics_fust_maten_terugval() t;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_fust_maten() TO authenticated, service_role;
+
+-- 2: eigen terugval voor artikelkenmerken (S15, S02, fust) uit het Floriday-handelsitem.
+-- Leest nooit products.custom_fields.
+CREATE OR REPLACE FUNCTION public.logistics_artikel_vbn_terugval(p_product_id uuid)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_ti text; v jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_artikel_vbn_terugval');
+  SELECT coalesce(nullif(p.floriday_trade_item_id, ''), nullif(p.trade_item_key, '')) INTO v_ti FROM public.products p WHERE p.id = p_product_id;
+  IF v_ti IS NULL OR to_regclass('public.floriday_trade_items_cache') IS NULL THEN
+    RETURN jsonb_build_object('bron', 'geen', 's02_cm', NULL, 's15_cm', NULL, 'vbn_package_code', NULL, 'custom_package_id', NULL);
+  END IF;
+  EXECUTE $q$
+    SELECT jsonb_build_object(
+      'bron', 'floriday_handelsitem',
+      's15_cm', public.logistics_vbn_cm('S15', (SELECT x->>'vbnValueCode' FROM jsonb_array_elements(coalesce(c.data->'characteristics', '[]'::jsonb)) x WHERE x->>'vbnCode' = 'S15' LIMIT 1)),
+      's02_cm', public.logistics_vbn_cm('S02', (SELECT x->>'vbnValueCode' FROM jsonb_array_elements(coalesce(c.data->'characteristics', '[]'::jsonb)) x WHERE x->>'vbnCode' = 'S02' LIMIT 1)),
+      'vbn_package_code', (SELECT CASE WHEN (pc->'package'->>'vbnPackageCode') ~ '^[0-9]+$' THEN (pc->'package'->>'vbnPackageCode')::int END
+                             FROM jsonb_array_elements(coalesce(c.data->'packingConfigurations', '[]'::jsonb)) pc
+                            ORDER BY (pc->>'primary')::boolean DESC NULLS LAST LIMIT 1),
+      'custom_package_id', (SELECT nullif(pc->'package'->>'customPackageId', '')
+                             FROM jsonb_array_elements(coalesce(c.data->'packingConfigurations', '[]'::jsonb)) pc
+                            ORDER BY (pc->>'primary')::boolean DESC NULLS LAST LIMIT 1))
+      FROM public.floriday_trade_items_cache c
+     WHERE (c.floriday_id = $1 OR c.data->>'tradeItemId' = $1) AND coalesce(c.is_deleted, false) = false
+     LIMIT 1$q$ INTO v USING v_ti;
+  RETURN coalesce(v, jsonb_build_object('bron', 'geen', 's02_cm', NULL, 's15_cm', NULL, 'vbn_package_code', NULL, 'custom_package_id', NULL));
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_artikel_vbn_terugval(uuid) TO authenticated, service_role;
+
+-- 2: artikelkenmerken. Voorraad (voorraad_article_vbn) als die bestaat, anders de eigen terugval.
+CREATE OR REPLACE FUNCTION public.logistics_artikel_vbn(p_product_id uuid)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE j jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_artikel_vbn');
+  IF to_regprocedure('public.voorraad_article_vbn(uuid)') IS NOT NULL THEN
+    EXECUTE 'SELECT to_jsonb(x) FROM public.voorraad_article_vbn($1) x LIMIT 1' INTO j USING p_product_id;
+    IF j ? 'voorraad_article_vbn' AND jsonb_typeof(j->'voorraad_article_vbn') = 'object' THEN j := j->'voorraad_article_vbn'; END IF;
+    j := coalesce(j, '{}'::jsonb);
+    RETURN jsonb_build_object(
+      'pad', 'voorraad',
+      'bron', coalesce(j->>'bron', j->>'source', 'voorraad'),
+      's15_cm', coalesce(public.logistics_pos_num(j->>'s15_cm'), public.logistics_vbn_cm('S15', j->'features'->>'S15')),
+      's02_cm', coalesce(public.logistics_pos_num(j->>'s02_cm'),
+                         CASE WHEN j->>'s02_source' = 'handmatig' THEN public.logistics_pos_num(j->>'s02')
+                              ELSE public.logistics_vbn_cm('S02', coalesce(j->>'s02', j->'features'->>'S02')) END),
+      'vbn_package_code', CASE WHEN coalesce(j->>'vbn_package_code', j->'fust'->>'vbn_code') ~ '^[0-9]+$' THEN coalesce(j->>'vbn_package_code', j->'fust'->>'vbn_code')::int END,
+      'custom_package_id', nullif(coalesce(j->>'custom_package_id', j->'fust'->>'custom_package_id'), ''));
+  END IF;
+  RETURN public.logistics_artikel_vbn_terugval(p_product_id) || jsonb_build_object('pad', 'terugval');
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_artikel_vbn(uuid) TO authenticated, service_role;
+
+-- 1+2: maten per product in één bron. Fustkeuze: handmatig -> VBN-code (rij met de meeste maten) -> custom package.
+-- Maten per veld; ontbreekt een veld bij de gekozen rij, dan uit een andere rij met dezelfde fust_key.
+-- Planthoogte geldt altijd INCLUSIEF pot: handmatig -> S15 (transporthoogte) -> S02 (min. planthoogte incl. pot).
+CREATE OR REPLACE FUNCTION public.logistics_product_maten(p_product_ids uuid[])
+RETURNS TABLE(product_id uuid, product_name text, plants_per_crate integer, fust_type_id uuid, fust_name text, fust_bron text,
+              fust_length_mm numeric, fust_width_mm numeric, fust_height_mm numeric,
+              lengte_bron text, breedte_bron text, hoogte_bron text,
+              plant_height_cm numeric, height_source text, weight_kg numeric,
+              pad_fust text, pad_artikel text, missing_reason text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+#variable_conflict use_column
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_product_maten');
+  IF p_product_ids IS NOT NULL AND cardinality(p_product_ids) > 2000 THEN
+    RAISE EXCEPTION 'Maximaal 2000 producten per aanvraag.' USING ERRCODE = '22023';
+  END IF;
+  RETURN QUERY
+  WITH fm AS (SELECT * FROM public.logistics_fust_maten()),
+  pr AS (
+    SELECT p.id, p.product, p.plants_per_crate, p.fust_type_id AS hand_fid, p.plant_height_cm AS hand_h, p.weight,
+           public.logistics_artikel_vbn(p.id) AS a
+      FROM public.products p
+     WHERE p_product_ids IS NULL OR p.id = ANY(p_product_ids)
+  ),
+  keuze AS (
+    SELECT pr.*,
+      (SELECT m.fust_type_id FROM fm m
+        WHERE (pr.a->>'vbn_package_code') ~ '^[0-9]+$'
+          AND (m.vbn_code = (pr.a->>'vbn_package_code')::int OR m.fust_key = 'vbn:' || (pr.a->>'vbn_package_code'))
+        ORDER BY ((m.length_mm IS NOT NULL)::int + (m.width_mm IS NOT NULL)::int + (m.height_mm IS NOT NULL)::int) DESC, m.fust_type_id
+        LIMIT 1) AS vbn_fid,
+      (SELECT f.id FROM public.fust_types f
+        WHERE nullif(pr.a->>'custom_package_id', '') IS NOT NULL AND f.custom_package_id = pr.a->>'custom_package_id'
+        ORDER BY f.created_at, f.id LIMIT 1) AS cp_fid
+      FROM pr
+  ),
+  k2 AS (
+    SELECT k.*, coalesce(k.hand_fid, k.vbn_fid, k.cp_fid) AS fid,
+      CASE WHEN k.hand_fid IS NOT NULL THEN 'handmatig' WHEN k.vbn_fid IS NOT NULL THEN 'vbn' WHEN k.cp_fid IS NOT NULL THEN 'floriday' END AS fbron
+      FROM keuze k
+  ),
+  maat AS (
+    SELECT k.*, m.name AS mname, m.pad AS mpad,
+      coalesce(m.length_mm, lx.length_mm) AS l, CASE WHEN m.length_mm IS NOT NULL THEN m.lengte_bron ELSE coalesce(lx.lengte_bron, 'onbekend') END AS lb,
+      coalesce(m.width_mm, wx.width_mm) AS w, CASE WHEN m.width_mm IS NOT NULL THEN m.breedte_bron ELSE coalesce(wx.breedte_bron, 'onbekend') END AS wb,
+      coalesce(m.height_mm, hx.height_mm) AS h, CASE WHEN m.height_mm IS NOT NULL THEN m.hoogte_bron ELSE coalesce(hx.hoogte_bron, 'onbekend') END AS hb
+      FROM k2 k
+      LEFT JOIN fm m ON m.fust_type_id = k.fid
+      LEFT JOIN LATERAL (SELECT m2.length_mm, m2.lengte_bron FROM fm m2 WHERE m.fust_key IS NOT NULL AND m2.fust_key = m.fust_key AND m2.length_mm IS NOT NULL ORDER BY m2.fust_type_id LIMIT 1) lx ON true
+      LEFT JOIN LATERAL (SELECT m2.width_mm, m2.breedte_bron FROM fm m2 WHERE m.fust_key IS NOT NULL AND m2.fust_key = m.fust_key AND m2.width_mm IS NOT NULL ORDER BY m2.fust_type_id LIMIT 1) wx ON true
+      LEFT JOIN LATERAL (SELECT m2.height_mm, m2.hoogte_bron FROM fm m2 WHERE m.fust_key IS NOT NULL AND m2.fust_key = m.fust_key AND m2.height_mm IS NOT NULL ORDER BY m2.fust_type_id LIMIT 1) hx ON true
+  ),
+  hoogte AS (
+    SELECT x.*,
+      public.logistics_pos_num(x.hand_h::text) AS hh,
+      public.logistics_pos_num(x.a->>'s15_cm') AS s15,
+      public.logistics_pos_num(x.a->>'s02_cm') AS s02,
+      (SELECT b.bron FROM public.logistics_gegevens_bron b
+        WHERE b.onderwerp = 'product' AND b.sleutel = x.id::text AND b.veld = 'plant_height_cm'
+          AND public.logistics_pos_num(b.waarde) = public.logistics_pos_num(x.hand_h::text) LIMIT 1) AS hand_bron
+      FROM maat x
+  )
+  SELECT h.id, h.product, h.plants_per_crate::int, h.fid, h.mname, h.fbron,
+    h.l, h.w, h.h, h.lb, h.wb, h.hb,
+    coalesce(h.hh, h.s15, h.s02),
+    CASE WHEN h.hh IS NOT NULL THEN coalesce(h.hand_bron, 'handmatig')
+         WHEN h.s15 IS NOT NULL THEN 'floricode_s15'
+         WHEN h.s02 IS NOT NULL THEN 'floricode_s02' END,
+    public.logistics_pos_num(regexp_replace(coalesce(h.weight::text, ''), '[^0-9.,]', '', 'g')),
+    coalesce(h.mpad, (SELECT fm.pad FROM fm LIMIT 1)), h.a->>'pad',
+    CASE
+      WHEN h.fid IS NULL AND h.a->>'vbn_package_code' IS NULL AND h.a->>'custom_package_id' IS NULL
+        THEN format('Bij "%s" is geen fustsoort bekend: kies de fustsoort bij het product in Voorraad.', h.product)
+      WHEN h.fid IS NULL
+        THEN format('Bij "%s" bestaat de fustsoort (VBN %s) niet in Voorraad → Fusten.', h.product, coalesce(h.a->>'vbn_package_code', h.a->>'custom_package_id'))
+      WHEN h.l IS NULL OR h.w IS NULL OR h.h IS NULL
+        THEN format('Fust %s heeft geen volledige maten in Floricode, Floriday of Voorraad → Fusten (ontbreekt: %s).', coalesce(h.mname, 'onbekend'),
+               array_to_string(array_remove(ARRAY[CASE WHEN h.l IS NULL THEN 'lengte' END, CASE WHEN h.w IS NULL THEN 'breedte' END, CASE WHEN h.h IS NULL THEN 'hoogte' END], NULL), ', '))
+      WHEN coalesce(h.hh, h.s15, h.s02) IS NULL
+        THEN format('Bij "%s" is de planthoogte inclusief pot onbekend (geen S15/S02 in Floricode of Floriday, niet handmatig ingevuld).', h.product)
+    END
+  FROM hoogte h;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_product_maten(uuid[]) TO authenticated, service_role;
+
+-- Bestaande view blijft met dezelfde kolommen werken; de bron is nu logistics_product_maten.
+DO $fs$ BEGIN
+  EXECUTE $v$CREATE OR REPLACE VIEW public.logistics_product_dimensions AS
+    SELECT m.product_id, m.product_name, m.plants_per_crate, m.fust_type_id,
+           CASE m.fust_bron WHEN 'vbn' THEN 'floriday' ELSE m.fust_bron END AS fust_source,
+           m.fust_name, m.fust_length_mm, m.fust_width_mm, m.fust_height_mm,
+           m.plant_height_cm, m.height_source,
+           CASE WHEN m.missing_reason IS NULL THEN coalesce(nullif(m.fust_bron, 'vbn'), 'floriday') ELSE 'onbekend' END AS dimension_source,
+           m.missing_reason
+      FROM public.logistics_product_maten(NULL) m$v$;
+EXCEPTION WHEN undefined_table OR undefined_column OR undefined_function OR invalid_table_definition THEN
+  RAISE NOTICE 'logistiek-engine: view logistics_product_dimensions niet vervangen: %', SQLERRM;
+END $fs$;
+
+-- 3+E4: gegevens voor karindeling, nu met bronnen uit logistics_product_maten.
+-- Gewicht per fust alleen gevraagd als de gebruikte ladingdrager een kg-grens heeft.
+-- Lagen per kar: laaghoogte = max(fusthoogte, planthoogte inclusief pot).
+CREATE OR REPLACE FUNCTION public.logistics_data_gereedheid(p_product_ids uuid[] DEFAULT NULL)
+RETURNS TABLE(product_id uuid, product text, ladingdrager text, methode text, in_open_order boolean,
+              ontbrekend text[], velden jsonb, voorstel jsonb, uitleg text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+#variable_conflict use_column
+DECLARE v_methode text; v_carrier text; c record; v_ids uuid[];
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_data_gereedheid');
+  SELECT CASE WHEN coalesce(s.settings->'karrenindeling'->'fields'->>'cart_layout_method', s.settings->'karrenindeling'->>'cart_layout_method') = 'afmetingen'
+              THEN 'afmetingen' ELSE 'belading' END,
+         nullif(btrim(coalesce(s.settings->'karrenindeling'->'fields'->>'default_carrier_type', s.settings->'karrenindeling'->>'default_carrier_type')), '')
+    INTO v_methode, v_carrier
+    FROM public.logistics_rule_configs s WHERE s.is_active ORDER BY s.updated_at DESC LIMIT 1;
+  v_methode := coalesce(v_methode, 'belading');
+  SELECT t.code, t.name, t.layer_length_cm, t.layer_width_cm, t.max_height_cm, t.max_weight_kg INTO c
+    FROM public.load_carrier_types t
+   WHERE t.is_active AND (t.code = v_carrier OR (v_carrier IS NULL AND t.is_default))
+   ORDER BY (t.code = v_carrier) DESC NULLS LAST LIMIT 1;
+
+  SELECT array_agg(DISTINCT x) INTO v_ids FROM (
+    SELECT oi.product_id AS x FROM public.orders o JOIN public.order_items oi ON oi.order_id = o.id
+     WHERE p_product_ids IS NULL AND o.deleted_at IS NULL AND o.cancelled_at IS NULL AND coalesce(o.is_reservation, false) = false
+       AND lower(coalesce(o.status, '')) = 'nog te picken' AND oi.product_id IS NOT NULL
+    UNION SELECT unnest(p_product_ids)) q WHERE x IS NOT NULL;
+  IF v_ids IS NULL THEN RETURN; END IF;
+
+  RETURN QUERY
+  WITH open_p AS (
+    SELECT DISTINCT oi.product_id FROM public.orders o JOIN public.order_items oi ON oi.order_id = o.id
+     WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL AND coalesce(o.is_reservation, false) = false
+       AND lower(coalesce(o.status, '')) = 'nog te picken' AND oi.product_id = ANY(v_ids)
+  ),
+  p AS (
+    SELECT pr.id, pr.product, pr.plants_per_crate, pr.crates_per_layer, pr.layers_per_cart, pr.floriday_packing_source,
+           mt.fust_type_id, mt.fust_name, mt.fust_bron, mt.fust_length_mm AS length_mm, mt.fust_width_mm AS width_mm, mt.fust_height_mm AS height_mm,
+           mt.lengte_bron, mt.breedte_bron, mt.hoogte_bron, mt.plant_height_cm, mt.height_source, mt.weight_kg,
+           (op.product_id IS NOT NULL) AS in_open
+      FROM public.products pr
+      JOIN public.logistics_product_maten(v_ids) mt ON mt.product_id = pr.id
+      LEFT JOIN open_p op ON op.product_id = pr.id
+  ),
+  m AS (
+    SELECT p.*,
+      array_remove(ARRAY[
+        CASE WHEN coalesce(p.plants_per_crate, 0) <= 0 THEN 'plants_per_crate' END,
+        CASE WHEN v_methode = 'belading' AND coalesce(p.crates_per_layer, 0) <= 0 THEN 'crates_per_layer' END,
+        CASE WHEN v_methode = 'belading' AND coalesce(p.layers_per_cart, 0) <= 0 THEN 'layers_per_cart' END,
+        CASE WHEN v_methode = 'afmetingen' AND p.fust_type_id IS NULL THEN 'fust_type_id' END,
+        CASE WHEN v_methode = 'afmetingen' AND p.fust_type_id IS NOT NULL AND (p.length_mm IS NULL OR p.width_mm IS NULL OR p.height_mm IS NULL) THEN 'fust_maten' END,
+        CASE WHEN v_methode = 'afmetingen' AND p.plant_height_cm IS NULL THEN 'plant_height_cm' END,
+        CASE WHEN coalesce(c.max_weight_kg, 0) > 0 AND p.weight_kg IS NULL THEN 'weight' END
+      ], NULL) AS mist,
+      CASE WHEN p.length_mm > 0 AND p.width_mm > 0 AND c.layer_length_cm > 0 AND c.layer_width_cm > 0 THEN
+        greatest(floor(c.layer_length_cm * 10 / p.length_mm) * floor(c.layer_width_cm * 10 / p.width_mm),
+                 floor(c.layer_length_cm * 10 / p.width_mm) * floor(c.layer_width_cm * 10 / p.length_mm))::int END AS calc_cpl,
+      CASE WHEN p.plant_height_cm > 0 AND c.max_height_cm > 0 THEN
+        floor(c.max_height_cm / greatest(p.plant_height_cm, coalesce(p.height_mm, 0) / 10.0))::int END AS calc_lpc
+    FROM p
+  )
+  SELECT m.id, m.product, c.code, v_methode, m.in_open, m.mist,
+    jsonb_build_object(
+      'plants_per_crate', jsonb_build_object('waarde', m.plants_per_crate, 'bron', CASE WHEN m.plants_per_crate > 0 THEN coalesce(m.floriday_packing_source, 'product') END),
+      'crates_per_layer', jsonb_build_object('waarde', m.crates_per_layer, 'bron', CASE WHEN m.crates_per_layer > 0 THEN coalesce(m.floriday_packing_source, 'product') END),
+      'layers_per_cart', jsonb_build_object('waarde', m.layers_per_cart, 'bron', CASE WHEN m.layers_per_cart > 0 THEN coalesce(m.floriday_packing_source, 'product') END),
+      'weight', jsonb_build_object('waarde', m.weight_kg, 'bron', CASE WHEN m.weight_kg IS NOT NULL THEN 'product' END,
+                                   'nodig', coalesce(c.max_weight_kg, 0) > 0, 'grens_kg', c.max_weight_kg),
+      'plant_height_cm', jsonb_build_object('waarde', m.plant_height_cm, 'bron', m.height_source, 'inclusief_pot', true),
+      'fust_type_id', jsonb_build_object('waarde', m.fust_type_id, 'bron', m.fust_bron, 'naam', m.fust_name),
+      'fust_length_mm', jsonb_build_object('waarde', m.length_mm, 'bron', m.lengte_bron),
+      'fust_width_mm', jsonb_build_object('waarde', m.width_mm, 'bron', m.breedte_bron),
+      'fust_height_mm', jsonb_build_object('waarde', m.height_mm, 'bron', m.hoogte_bron)),
+    jsonb_strip_nulls(jsonb_build_object(
+      'crates_per_layer', CASE WHEN m.calc_cpl > 0 THEN jsonb_build_object('waarde', m.calc_cpl, 'bron', 'berekend',
+          'berekening', format('fust %s×%s mm op laag %s×%s cm (%s)', m.length_mm, m.width_mm, c.layer_length_cm, c.layer_width_cm, c.name)) END,
+      'layers_per_cart', CASE WHEN m.calc_lpc > 0 THEN jsonb_build_object('waarde', m.calc_lpc, 'bron', 'berekend',
+          'berekening', format('hoogte %s cm / grootste van (plant incl. pot %s cm, fust %s cm)', c.max_height_cm, m.plant_height_cm, round(coalesce(m.height_mm, 0) / 10.0, 1))) END)),
+    CASE WHEN cardinality(m.mist) = 0 THEN 'Compleet.'
+         ELSE format('Bij "%s" ontbreekt: %s. Vul dit in bij het product (Voorraad) of hier met "Invullen".', m.product,
+           array_to_string(ARRAY(SELECT CASE f WHEN 'plants_per_crate' THEN 'planten per fust' WHEN 'crates_per_layer' THEN 'fusten per laag'
+             WHEN 'layers_per_cart' THEN 'lagen per kar' WHEN 'fust_type_id' THEN 'fustsoort' WHEN 'fust_maten' THEN 'fustmaten'
+             WHEN 'plant_height_cm' THEN 'planthoogte inclusief pot'
+             WHEN 'weight' THEN format('gewicht per fust (%s heeft een grens van %s kg)', c.name, c.max_weight_kg) ELSE f END FROM unnest(m.mist) f), ', ')) END
+  FROM m
+  ORDER BY cardinality(m.mist) DESC, m.in_open DESC, m.product
+  LIMIT 2000;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_data_gereedheid(uuid[]) TO authenticated, service_role;
+
+-- 5: "Alles overnemen uit Floricode/Floriday": alleen lege velden, bron vastgelegd.
+-- p_uitvoeren = false geeft alleen de voorvertoning.
+CREATE OR REPLACE FUNCTION public.logistics_data_overnemen(p_uitvoeren boolean)
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+#variable_conflict use_column
+DECLARE v_lijst jsonb := '[]'::jsonb; r record; v_n int := 0; v_ids uuid[];
+BEGIN
+  PERFORM public.logistics_acc_guard(CASE WHEN p_uitvoeren THEN 'beheer' ELSE 'ingelogd' END, 'logistics_data_overnemen');
+  SELECT array_agg(DISTINCT oi.product_id) INTO v_ids FROM public.orders o JOIN public.order_items oi ON oi.order_id = o.id
+   WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL AND coalesce(o.is_reservation, false) = false
+     AND lower(coalesce(o.status, '')) = 'nog te picken' AND oi.product_id IS NOT NULL;
+  IF v_ids IS NULL THEN RETURN jsonb_build_object('uitgevoerd', false, 'velden', v_lijst, 'aantal', 0); END IF;
+  FOR r IN
+    SELECT m.*, p.fust_type_id AS hand_fid, p.plant_height_cm AS hand_h, f.length_mm AS f_l, f.width_mm AS f_w, f.height_mm AS f_h
+      FROM public.logistics_product_maten(v_ids) m
+      JOIN public.products p ON p.id = m.product_id
+      LEFT JOIN public.fust_types f ON f.id = m.fust_type_id
+  LOOP
+    IF r.hand_h IS NULL AND r.height_source IN ('floricode_s15', 'floricode_s02') THEN
+      v_lijst := v_lijst || jsonb_build_object('onderwerp', 'product', 'sleutel', r.product_id, 'naam', r.product_name, 'veld', 'plant_height_cm', 'waarde', r.plant_height_cm, 'bron', r.height_source);
+      IF p_uitvoeren THEN
+        UPDATE public.products SET plant_height_cm = r.plant_height_cm, updated_at = now() WHERE id = r.product_id AND plant_height_cm IS NULL;
+      END IF;
+    END IF;
+    IF r.hand_fid IS NULL AND r.fust_type_id IS NOT NULL THEN
+      v_lijst := v_lijst || jsonb_build_object('onderwerp', 'product', 'sleutel', r.product_id, 'naam', r.product_name, 'veld', 'fust_type_id', 'waarde', r.fust_type_id,
+                                               'bron', CASE r.fust_bron WHEN 'vbn' THEN 'floriday_vbn' ELSE r.fust_bron END);
+      IF p_uitvoeren THEN
+        UPDATE public.products SET fust_type_id = r.fust_type_id, updated_at = now() WHERE id = r.product_id AND fust_type_id IS NULL;
+      END IF;
+    END IF;
+    IF r.fust_type_id IS NOT NULL AND r.f_l IS NULL AND r.fust_length_mm IS NOT NULL AND r.lengte_bron IN ('floricode', 'floriday') THEN
+      v_lijst := v_lijst || jsonb_build_object('onderwerp', 'fust', 'sleutel', r.fust_type_id, 'naam', r.fust_name, 'veld', 'length_mm', 'waarde', r.fust_length_mm, 'bron', r.lengte_bron);
+      IF p_uitvoeren THEN UPDATE public.fust_types SET length_mm = round(r.fust_length_mm)::int, updated_at = now() WHERE id = r.fust_type_id AND length_mm IS NULL; END IF;
+    END IF;
+    IF r.fust_type_id IS NOT NULL AND r.f_w IS NULL AND r.fust_width_mm IS NOT NULL AND r.breedte_bron IN ('floricode', 'floriday') THEN
+      v_lijst := v_lijst || jsonb_build_object('onderwerp', 'fust', 'sleutel', r.fust_type_id, 'naam', r.fust_name, 'veld', 'width_mm', 'waarde', r.fust_width_mm, 'bron', r.breedte_bron);
+      IF p_uitvoeren THEN UPDATE public.fust_types SET width_mm = round(r.fust_width_mm)::int, updated_at = now() WHERE id = r.fust_type_id AND width_mm IS NULL; END IF;
+    END IF;
+    IF r.fust_type_id IS NOT NULL AND r.f_h IS NULL AND r.fust_height_mm IS NOT NULL AND r.hoogte_bron IN ('floricode', 'floriday') THEN
+      v_lijst := v_lijst || jsonb_build_object('onderwerp', 'fust', 'sleutel', r.fust_type_id, 'naam', r.fust_name, 'veld', 'height_mm', 'waarde', r.fust_height_mm, 'bron', r.hoogte_bron);
+      IF p_uitvoeren THEN UPDATE public.fust_types SET height_mm = round(r.fust_height_mm)::int, updated_at = now() WHERE id = r.fust_type_id AND height_mm IS NULL; END IF;
+    END IF;
+  END LOOP;
+  -- Ontdubbelen (meerdere producten met hetzelfde fust).
+  SELECT coalesce(jsonb_agg(DISTINCT e), '[]'::jsonb) INTO v_lijst FROM jsonb_array_elements(v_lijst) e;
+  IF p_uitvoeren THEN
+    INSERT INTO public.logistics_gegevens_bron(onderwerp, sleutel, veld, waarde, bron, toelichting, vastgelegd_door)
+    SELECT e->>'onderwerp', e->>'sleutel', e->>'veld', e->>'waarde', e->>'bron', 'Overgenomen via de startlijst', auth.uid()
+      FROM jsonb_array_elements(v_lijst) e
+    ON CONFLICT (onderwerp, sleutel, veld) DO UPDATE SET waarde = EXCLUDED.waarde, bron = EXCLUDED.bron, toelichting = EXCLUDED.toelichting,
+      vastgelegd_door = EXCLUDED.vastgelegd_door, vastgelegd_op = now();
+  END IF;
+  v_n := jsonb_array_length(v_lijst);
+  RETURN jsonb_build_object('uitgevoerd', p_uitvoeren, 'aantal', v_n, 'velden', v_lijst,
+    'per_bron', (SELECT coalesce(jsonb_object_agg(b, n), '{}'::jsonb) FROM (SELECT e->>'bron' b, count(*) n FROM jsonb_array_elements(v_lijst) e GROUP BY 1) q));
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_data_overnemen(boolean) TO authenticated, service_role;
+
+-- 4: algemene standaard-laagmaten per Floriday-ladingdragertype (vaste, klant-onafhankelijke referentie).
+-- Alleen lengte en breedte; hoogte en gewichtsgrens hebben geen algemene standaard en vult de beheerder zelf in.
+CREATE OR REPLACE FUNCTION public.logistics_ladingdrager_referentie()
+RETURNS TABLE(floriday_code text, lengte_cm integer, breedte_cm integer, bron text)
+LANGUAGE sql IMMUTABLE SET search_path TO 'public' AS $$
+  VALUES ('DANISH_TROLLEY', 135, 56, 'Standaard Deense container (CC), 1350×565 mm'),
+         ('DANISH_TROLLEY_NON_CC_RFID', 135, 56, 'Standaard Deense container, 1350×565 mm'),
+         ('DANISH_TROLLEY_WATER_TRAY', 135, 56, 'Standaard Deense container met waterbak, 1350×565 mm'),
+         ('AUCTION_TROLLEY', 135, 56, 'Standaard veilingstapelwagen, 1350×565 mm'),
+         ('EURO_PALLET', 120, 80, 'Europallet (EPAL), 1200×800 mm'),
+         ('HT_EURO_PALLET', 120, 80, 'Europallet (EPAL, HT), 1200×800 mm'),
+         ('BLOCK_PALLET', 120, 100, 'Blokpallet, 1200×1000 mm')
+$$;
+GRANT EXECUTE ON FUNCTION public.logistics_ladingdrager_referentie() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_ladingdrager_voorstellen()
+RETURNS TABLE(code text, naam text, floriday_code text, veld text, huidig numeric, voorstel numeric, bron text, actie text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+#variable_conflict use_column
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_ladingdrager_voorstellen');
+  RETURN QUERY
+  WITH k AS (
+    SELECT DISTINCT ON (t.code) t.code, t.name, m.floriday_code, t.layer_length_cm, t.layer_width_cm, r.lengte_cm, r.breedte_cm, r.bron
+      FROM public.load_carrier_types t
+      JOIN public.logistics_floriday_carrier_map m ON m.carrier_code = t.code
+      JOIN public.logistics_ladingdrager_referentie() r ON r.floriday_code = m.floriday_code
+     WHERE t.is_active
+     ORDER BY t.code, m.floriday_code
+  )
+  SELECT k.code, k.name, k.floriday_code, v.veld, v.huidig, v.voorstel, k.bron,
+         CASE WHEN coalesce(v.huidig, 0) <= 0 THEN 'invullen' WHEN v.huidig = v.voorstel THEN 'gelijk' ELSE 'afwijkend' END
+    FROM k CROSS JOIN LATERAL (VALUES ('layer_length_cm', k.layer_length_cm::numeric, k.lengte_cm::numeric),
+                                      ('layer_width_cm', k.layer_width_cm::numeric, k.breedte_cm::numeric)) v(veld, huidig, voorstel)
+   ORDER BY k.code, v.veld;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_ladingdrager_voorstellen() TO authenticated, service_role;
+
+-- Bevestigen per ladingdrager: schrijft alleen lege velden en legt de bron vast. Overschrijft nooit.
+CREATE OR REPLACE FUNCTION public.logistics_ladingdrager_voorstel_bevestigen(p_code text)
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+#variable_conflict use_column
+DECLARE r record; v_n int := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('beheer', 'logistics_ladingdrager_voorstel_bevestigen');
+  FOR r IN SELECT * FROM public.logistics_ladingdrager_voorstellen() v WHERE v.code = p_code AND v.actie = 'invullen' LOOP
+    IF r.veld = 'layer_length_cm' THEN
+      UPDATE public.load_carrier_types SET layer_length_cm = r.voorstel::int, updated_at = now() WHERE code = p_code AND coalesce(layer_length_cm, 0) <= 0;
+    ELSIF r.veld = 'layer_width_cm' THEN
+      UPDATE public.load_carrier_types SET layer_width_cm = r.voorstel::int, updated_at = now() WHERE code = p_code AND coalesce(layer_width_cm, 0) <= 0;
+    END IF;
+    IF FOUND THEN
+      v_n := v_n + 1;
+      INSERT INTO public.logistics_gegevens_bron(onderwerp, sleutel, veld, waarde, bron, toelichting, vastgelegd_door)
+      VALUES ('ladingdrager', p_code, r.veld, r.voorstel::text, 'standaard:' || r.floriday_code, r.bron, auth.uid())
+      ON CONFLICT (onderwerp, sleutel, veld) DO UPDATE SET waarde = EXCLUDED.waarde, bron = EXCLUDED.bron, toelichting = EXCLUDED.toelichting,
+        vastgelegd_door = EXCLUDED.vastgelegd_door, vastgelegd_op = now();
+    END IF;
+  END LOOP;
+  RETURN jsonb_build_object('ok', true, 'code', p_code, 'ingevuld', v_n);
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_ladingdrager_voorstel_bevestigen(text) TO authenticated, service_role;
+
+-- 5: startlijst voor een nieuwe shell.
+CREATE OR REPLACE FUNCTION public.logistics_startlijst()
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_drag int; v_drag_mist int; v_werk boolean; v_prod int; v_prod_mist int;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_startlijst');
+  SELECT count(*), count(*) FILTER (WHERE coalesce(t.layer_length_cm, 0) <= 0 OR coalesce(t.layer_width_cm, 0) <= 0 OR coalesce(t.max_height_cm, 0) <= 0)
+    INTO v_drag, v_drag_mist
+    FROM public.load_carrier_types t
+   WHERE t.is_active AND NOT EXISTS (SELECT 1 FROM public.logistics_floriday_carrier_map m WHERE m.carrier_code = t.code AND m.floriday_code = 'NONE');
+  SELECT EXISTS (SELECT 1 FROM public.logistics_rule_configs s WHERE s.is_active AND s.settings ? 'karrenindeling') INTO v_werk;
+  SELECT count(*), count(*) FILTER (WHERE cardinality(g.ontbrekend) > 0) INTO v_prod, v_prod_mist FROM public.logistics_data_gereedheid(NULL) g;
+  RETURN jsonb_build_object(
+    'ladingdragers', jsonb_build_object('klaar', v_drag > 0 AND v_drag_mist = 0, 'aantal', v_drag, 'onvolledig', v_drag_mist),
+    'werkwijze', jsonb_build_object('klaar', v_werk),
+    'gereedheid', jsonb_build_object('klaar', v_prod_mist = 0, 'producten', v_prod, 'onvolledig', v_prod_mist));
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_startlijst() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_198()
+RETURNS TABLE(controle text, ok boolean, toelichting text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_install_check_198');
+  RETURN QUERY SELECT 'Engine: fustmaten uit één bron'::text,
+    to_regprocedure('public.logistics_fust_maten()') IS NOT NULL,
+    CASE WHEN to_regprocedure('public.voorraad_fust_dimensions()') IS NOT NULL THEN 'via Voorraad (voorraad_fust_dimensions)'
+         ELSE 'eigen terugval: Floricode → Floriday → handmatig' END;
+  RETURN QUERY SELECT 'Engine: artikelkenmerken (S15/S02, fust)',
+    to_regprocedure('public.logistics_artikel_vbn(uuid)') IS NOT NULL,
+    CASE WHEN to_regprocedure('public.voorraad_article_vbn(uuid)') IS NOT NULL THEN 'via Voorraad (voorraad_article_vbn)'
+         ELSE 'eigen terugval: Floriday-handelsitem' END;
+  RETURN QUERY SELECT 'Engine: view logistics_product_dimensions gebruikt logistics_product_maten',
+    coalesce(pg_get_viewdef('public.logistics_product_dimensions'::regclass) LIKE '%logistics_product_maten%', false), 'view';
+  RETURN QUERY SELECT 'Engine: gereedheid vraagt gewicht alleen bij kg-grens',
+    coalesce(pg_get_functiondef('public.logistics_data_gereedheid(uuid[])'::regprocedure) LIKE '%max_weight_kg%', false), 'logistics_data_gereedheid';
+  RETURN QUERY SELECT 'Engine: startlijst en standaardmaten ladingdragers',
+    to_regprocedure('public.logistics_startlijst()') IS NOT NULL AND to_regprocedure('public.logistics_ladingdrager_voorstel_bevestigen(text)') IS NOT NULL,
+    'logistics_startlijst + logistics_ladingdrager_voorstel_bevestigen';
+  RETURN QUERY SELECT 'Engine: bronregistratie', to_regclass('public.logistics_gegevens_bron') IS NOT NULL, 'logistics_gegevens_bron';
+EXCEPTION WHEN undefined_table OR undefined_function THEN
+  RETURN QUERY SELECT 'Engine: maten 1.0.198'::text, false, SQLERRM;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_198() TO authenticated, service_role;
+
+DO $do$ DECLARE d text;
+BEGIN
+  d := pg_get_functiondef('public.logistics_install_check()'::regprocedure);
+  IF position('logistics_install_check_198' in d) = 0 THEN
+    d := replace(d, $r$  RETURN QUERY SELECT * FROM public.logistics_access_check();$r$,
+                    $r$  RETURN QUERY SELECT * FROM public.logistics_install_check_198();
+  RETURN QUERY SELECT * FROM public.logistics_access_check();$r$);
+    EXECUTE d;
+  END IF;
+EXCEPTION WHEN undefined_function THEN NULL;
+END $do$;