@flowselections/logistiek-engine 1.0.191 → 1.0.195

package/db/schema/logistiek-engine.sql

@@ -31636,4 +31636,1939 @@ BEGIN
   SELECT b.d, b.print_plek_id, b.breedte_mm, b.hoogte_mm, sum(greatest(coalesce(b.kopieen, 1), 1))::integer
     FROM b WHERE b.d BETWEEN p_van AND p_tot
    GROUP BY 1, 2, 3, 4 ORDER BY 1, 2, 3, 4;
-END $function$;
+END $function$;
+-- ===== 1.0.192: inplannen in porties (db/migrations/20261023190000) =====
+-- Logistiek Engine 1.0.192: taken opnieuw inplannen in porties met vingerafdruk per order.
+-- Herhaalbaar. Geen datacorrecties, geen deletes. Bestaande functies (o.a. logistics_schedule_tasks)
+-- blijven ongewijzigd, zodat gepubliceerde 1.0.190 blijft werken.
+
+CREATE TABLE IF NOT EXISTS public.logistics_schedule_fp (
+  order_ref text PRIMARY KEY,
+  fp text NOT NULL,
+  ingepland_at timestamptz NOT NULL DEFAULT now()
+);
+GRANT SELECT ON public.logistics_schedule_fp TO authenticated;
+GRANT ALL ON public.logistics_schedule_fp TO service_role;
+ALTER TABLE public.logistics_schedule_fp ENABLE ROW LEVEL SECURITY;
+DROP POLICY IF EXISTS "Ingelogd mag inplan-vingerafdruk lezen" ON public.logistics_schedule_fp;
+CREATE POLICY "Ingelogd mag inplan-vingerafdruk lezen" ON public.logistics_schedule_fp
+  FOR SELECT TO authenticated USING (true);
+
+CREATE TABLE IF NOT EXISTS public.logistics_schedule_werklijst (
+  run_id uuid NOT NULL,
+  order_ref text NOT NULL,
+  verwerkt_at timestamptz,
+  uitkomst text,
+  PRIMARY KEY (run_id, order_ref)
+);
+GRANT SELECT ON public.logistics_schedule_werklijst TO authenticated;
+GRANT ALL ON public.logistics_schedule_werklijst TO service_role;
+ALTER TABLE public.logistics_schedule_werklijst ENABLE ROW LEVEL SECURITY;
+DROP POLICY IF EXISTS "Ingelogd mag inplan-werklijst lezen" ON public.logistics_schedule_werklijst;
+CREATE POLICY "Ingelogd mag inplan-werklijst lezen" ON public.logistics_schedule_werklijst
+  FOR SELECT TO authenticated USING (true);
+
+CREATE TABLE IF NOT EXISTS public.logistics_schedule_voortgang (
+  id boolean PRIMARY KEY DEFAULT true CHECK (id),
+  run_id uuid,
+  gestart_at timestamptz,
+  bijgewerkt_at timestamptz,
+  totaal integer NOT NULL DEFAULT 0,
+  verwerkt integer NOT NULL DEFAULT 0,
+  ingepland integer NOT NULL DEFAULT 0,
+  overgeslagen integer NOT NULL DEFAULT 0,
+  fouten integer NOT NULL DEFAULT 0,
+  laatste_fout text,
+  klaar boolean NOT NULL DEFAULT true,
+  duur_ms integer
+);
+GRANT SELECT ON public.logistics_schedule_voortgang TO authenticated;
+GRANT ALL ON public.logistics_schedule_voortgang TO service_role;
+ALTER TABLE public.logistics_schedule_voortgang ENABLE ROW LEVEL SECURITY;
+DROP POLICY IF EXISTS "Ingelogd mag inplan-voortgang lezen" ON public.logistics_schedule_voortgang;
+CREATE POLICY "Ingelogd mag inplan-voortgang lezen" ON public.logistics_schedule_voortgang
+  FOR SELECT TO authenticated USING (true);
+
+CREATE TABLE IF NOT EXISTS public.logistics_index_log (
+  index_naam text PRIMARY KEY,
+  tabel text NOT NULL,
+  rijen bigint,
+  duur_ms integer,
+  aangemaakt_at timestamptz NOT NULL DEFAULT now()
+);
+GRANT SELECT ON public.logistics_index_log TO authenticated;
+GRANT ALL ON public.logistics_index_log TO service_role;
+ALTER TABLE public.logistics_index_log ENABLE ROW LEVEL SECURITY;
+DROP POLICY IF EXISTS "Ingelogd mag indexlog lezen" ON public.logistics_index_log;
+CREATE POLICY "Ingelogd mag indexlog lezen" ON public.logistics_index_log
+  FOR SELECT TO authenticated USING (true);
+
+-- Index voor "open taken per order", met gemeten duur (schrijfblokkade op logistics_tasks zolang hij loopt).
+DO $idx$
+DECLARE t0 timestamptz; n bigint;
+BEGIN
+  IF to_regclass('public.idx_logistics_tasks_open_order') IS NULL THEN
+    SELECT count(*) INTO n FROM public.logistics_tasks;
+    t0 := clock_timestamp();
+    CREATE INDEX idx_logistics_tasks_open_order ON public.logistics_tasks (order_ref)
+      WHERE status IN ('planned', 'ready') AND order_ref IS NOT NULL;
+    INSERT INTO public.logistics_index_log (index_naam, tabel, rijen, duur_ms)
+    VALUES ('idx_logistics_tasks_open_order', 'logistics_tasks', n,
+            (extract(epoch FROM clock_timestamp() - t0) * 1000)::int)
+    ON CONFLICT (index_naam) DO NOTHING;
+  END IF;
+END $idx$;
+
+-- Algemene invoer van het inplannen: werkwijze, werktijden, afwijkende dagen, capaciteit,
+-- ladingdragers, ophaalmomenten (vervoerders) en het lopende uur (taken mogen niet in het verleden starten).
+CREATE OR REPLACE FUNCTION public.logistics_schedule_global_fp()
+RETURNS text LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE
+  v_tab text; v_h text; v_all text := '';
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_schedule_global_fp');
+  FOREACH v_tab IN ARRAY ARRAY['logistics_time_settings','logistics_opening_hours','logistics_opening_exceptions',
+    'logistics_rule_configs','cart_planning_settings','cart_planning_pick_times','cart_types','carriers'] LOOP
+    IF to_regclass('public.' || v_tab) IS NOT NULL THEN
+      EXECUTE format('SELECT md5(coalesce(string_agg(x, ''|'' ORDER BY x), '''')) FROM (SELECT to_jsonb(t)::text AS x FROM public.%I t) s', v_tab)
+        INTO v_h;
+      v_all := v_all || v_tab || ':' || coalesce(v_h, '') || ';';
+    END IF;
+  END LOOP;
+  v_all := v_all || 'uur:' || to_char(now() AT TIME ZONE coalesce(public.logistics_tz(), 'UTC'), 'YYYY-MM-DD HH24');
+  RETURN md5(v_all);
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_schedule_global_fp() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_schedule_global_fp() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_schedule_order_fp(p_order_ref text, p_global text)
+RETURNS text LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_o text; v_t text; v_c text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_schedule_order_fp');
+  SELECT (to_jsonb(o) - 'updated_at')::text, array_to_string(public.logistics_order_cart_ids(o.id), ',')
+    INTO v_o, v_c FROM public.orders o WHERE o.order_number = p_order_ref;
+  SELECT string_agg(t.id::text || t.task_type || t.status, ',' ORDER BY t.id) INTO v_t
+    FROM public.logistics_tasks t WHERE t.order_ref = p_order_ref AND t.status IN ('planned', 'ready');
+  RETURN md5(coalesce(p_global, '') || '#' || coalesce(v_o, '') || '#' || coalesce(v_t, '') || '#' || coalesce(v_c, ''));
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_schedule_order_fp(text, text) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_schedule_order_fp(text, text) TO authenticated, service_role;
+
+-- Portie-inplanner. Opties (jsonb): start (bool), run_id (uuid), max_orders (int, 25), budget_ms (int, 20000), force (bool).
+-- Per order een eigen subtransactie: lukt het niet, dan blijft de oude planning staan.
+CREATE OR REPLACE FUNCTION public.logistics_schedule_tasks_batch(p_opties jsonb)
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE
+  v_start timestamptz := clock_timestamp();
+  v_run uuid := nullif(p_opties->>'run_id', '')::uuid;
+  v_max int := greatest(1, least(coalesce((p_opties->>'max_orders')::int, 25), 500));
+  v_budget int := greatest(1000, least(coalesce((p_opties->>'budget_ms')::int, 20000), 120000));
+  v_force boolean := coalesce((p_opties->>'force')::boolean, false);
+  v_since timestamptz; v_160 timestamptz;
+  v_global text; v_fp text; v_old text; r record;
+  v_done int := 0; v_plan int := 0; v_skip int := 0; v_err int := 0; v_fouten jsonb := '[]'::jsonb;
+  v_totaal int; v_rest int;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_schedule_tasks_batch');
+  IF v_run IS NULL OR coalesce((p_opties->>'start')::boolean, false) THEN
+    v_run := gen_random_uuid();
+    SELECT departure_rule_since, rule_160_since INTO v_since, v_160
+      FROM public.logistics_time_settings ORDER BY updated_at DESC NULLS LAST LIMIT 1;
+    INSERT INTO public.logistics_schedule_werklijst (run_id, order_ref)
+    SELECT v_run, o.order_number FROM public.orders o
+     WHERE o.deleted_at IS NULL AND o.order_number IS NOT NULL
+       AND EXISTS (SELECT 1 FROM public.logistics_tasks t WHERE t.order_ref = o.order_number AND t.status IN ('planned','ready'))
+       AND NOT (v_since IS NOT NULL AND v_160 IS NOT NULL AND o.created_at >= v_since AND o.created_at < v_160)
+    ON CONFLICT DO NOTHING;
+    GET DIAGNOSTICS v_totaal = ROW_COUNT;
+    INSERT INTO public.logistics_schedule_voortgang (id, run_id, gestart_at, bijgewerkt_at, totaal, verwerkt, ingepland, overgeslagen, fouten, laatste_fout, klaar, duur_ms)
+    VALUES (true, v_run, now(), now(), v_totaal, 0, 0, 0, 0, NULL, v_totaal = 0, NULL)
+    ON CONFLICT (id) DO UPDATE SET run_id = EXCLUDED.run_id, gestart_at = EXCLUDED.gestart_at, bijgewerkt_at = EXCLUDED.bijgewerkt_at,
+      totaal = EXCLUDED.totaal, verwerkt = 0, ingepland = 0, overgeslagen = 0, fouten = 0, laatste_fout = NULL,
+      klaar = EXCLUDED.klaar, duur_ms = NULL;
+  END IF;
+
+  v_global := public.logistics_schedule_global_fp();
+  FOR r IN SELECT w.order_ref FROM public.logistics_schedule_werklijst w
+            WHERE w.run_id = v_run AND w.verwerkt_at IS NULL ORDER BY w.order_ref LIMIT v_max LOOP
+    EXIT WHEN (extract(epoch FROM clock_timestamp() - v_start) * 1000) > v_budget;
+    v_fp := public.logistics_schedule_order_fp(r.order_ref, v_global);
+    SELECT f.fp INTO v_old FROM public.logistics_schedule_fp f WHERE f.order_ref = r.order_ref;
+    IF NOT v_force AND v_old IS NOT DISTINCT FROM v_fp THEN
+      v_skip := v_skip + 1;
+      UPDATE public.logistics_schedule_werklijst SET verwerkt_at = now(), uitkomst = 'ongewijzigd'
+       WHERE run_id = v_run AND order_ref = r.order_ref;
+    ELSE
+      BEGIN
+        PERFORM public.logistics_schedule_tasks(p_order_ref => r.order_ref);
+        INSERT INTO public.logistics_schedule_fp (order_ref, fp, ingepland_at) VALUES (r.order_ref, v_fp, now())
+        ON CONFLICT (order_ref) DO UPDATE SET fp = EXCLUDED.fp, ingepland_at = EXCLUDED.ingepland_at;
+        v_plan := v_plan + 1;
+        UPDATE public.logistics_schedule_werklijst SET verwerkt_at = now(), uitkomst = 'ingepland'
+         WHERE run_id = v_run AND order_ref = r.order_ref;
+      EXCEPTION WHEN OTHERS THEN
+        v_err := v_err + 1;
+        v_fouten := v_fouten || jsonb_build_object('order', r.order_ref, 'fout', left(SQLERRM, 300));
+        UPDATE public.logistics_schedule_werklijst SET verwerkt_at = now(), uitkomst = 'fout: ' || left(SQLERRM, 300)
+         WHERE run_id = v_run AND order_ref = r.order_ref;
+      END;
+    END IF;
+    v_done := v_done + 1;
+  END LOOP;
+
+  SELECT count(*) FILTER (WHERE verwerkt_at IS NULL), count(*) INTO v_rest, v_totaal
+    FROM public.logistics_schedule_werklijst WHERE run_id = v_run;
+  UPDATE public.logistics_schedule_voortgang
+     SET bijgewerkt_at = now(), verwerkt = v_totaal - v_rest, ingepland = ingepland + v_plan,
+         overgeslagen = overgeslagen + v_skip, fouten = fouten + v_err,
+         laatste_fout = CASE WHEN v_err > 0 THEN (v_fouten->0->>'order') || ': ' || (v_fouten->0->>'fout') ELSE laatste_fout END,
+         klaar = (v_rest = 0),
+         duur_ms = CASE WHEN v_rest = 0 THEN (extract(epoch FROM now() - gestart_at) * 1000)::int ELSE duur_ms END
+   WHERE id AND run_id = v_run;
+  RETURN jsonb_build_object('runId', v_run, 'totaal', v_totaal, 'verwerkt', v_totaal - v_rest, 'resterend', v_rest,
+    'ingepland', v_plan, 'overgeslagen', v_skip, 'fouten', v_fouten,
+    'durationMs', (extract(epoch FROM clock_timestamp() - v_start) * 1000)::int);
+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;
+  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 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 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_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);
+
+  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_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;