@flowselections/logistiek-engine 1.0.240 → 1.0.242

package/db/schema/logistiek-engine.sql

@@ -43510,3 +43510,1635 @@ BEGIN
         FROM (SELECT categorie, count(*) n FROM public.logistics_merge_herstel_log GROUP BY 1) h));
 END $$;
 
+-- ===== 2026-11-10c: ophaalmoment, samenvoegen volgens buffergroep =====
+-- 1.0.239 (schema 2026-11-10c): ophaalmoment per order uit de werkwijze, samenvoegen volgens de buffergroep.
+
+ALTER TABLE public.logistics_pickup_moments ADD COLUMN IF NOT EXISTS carrier_id uuid;
+ALTER TABLE public.logistics_pickup_moments ADD COLUMN IF NOT EXISTS pickup_days integer;
+ALTER TABLE public.logistics_pickup_moments ADD COLUMN IF NOT EXISTS signup_days integer;
+ALTER TABLE public.logistics_pickup_moments ADD COLUMN IF NOT EXISTS signup_time time without time zone;
+CREATE INDEX IF NOT EXISTS logistics_pickup_moments_carrier_dag_idx ON public.logistics_pickup_moments (carrier_id, moment_date);
+
+CREATE OR REPLACE FUNCTION public.logistics_pickup_carrier_uit_naam(p_naam text)
+RETURNS uuid LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+  SELECT CASE WHEN count(*) = 1 THEN (array_agg(c.id))[1] END
+    FROM public.carriers c
+   WHERE c.archived_at IS NULL
+     AND nullif(btrim(p_naam), '') IS NOT NULL
+     AND lower(btrim(c.name)) = lower(btrim(p_naam));
+$$;
+REVOKE ALL ON FUNCTION public.logistics_pickup_carrier_uit_naam(text) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_pickup_carrier_uit_naam(text) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_pickup_moments_koppel_trg()
+RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  IF NEW.carrier_id IS NULL AND NEW.carrier_ref IS NOT NULL THEN
+    NEW.carrier_id := public.logistics_pickup_carrier_uit_naam(NEW.carrier_ref);
+  END IF;
+  RETURN NEW;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_pickup_moments_koppel_trg() FROM PUBLIC, anon, authenticated;
+DROP TRIGGER IF EXISTS trg_logistics_pickup_moments_koppel ON public.logistics_pickup_moments;
+CREATE TRIGGER trg_logistics_pickup_moments_koppel
+  BEFORE INSERT OR UPDATE OF carrier_ref, carrier_id ON public.logistics_pickup_moments
+  FOR EACH ROW EXECUTE FUNCTION public.logistics_pickup_moments_koppel_trg();
+
+CREATE OR REPLACE FUNCTION public.logistics_pickup_moments_koppel()
+RETURNS integer LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE n int;
+BEGIN
+  UPDATE public.logistics_pickup_moments p
+     SET carrier_id = public.logistics_pickup_carrier_uit_naam(p.carrier_ref)
+   WHERE p.carrier_id IS NULL AND p.carrier_ref IS NOT NULL
+     AND public.logistics_pickup_carrier_uit_naam(p.carrier_ref) IS NOT NULL;
+  GET DIAGNOSTICS n = ROW_COUNT;
+  RETURN n;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_pickup_moments_koppel() FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_pickup_moments_koppel() TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_pickup_regel()
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE s jsonb; v_regel text; v_marge numeric;
+BEGIN
+  SELECT c.settings INTO s FROM public.logistics_rule_configs c WHERE c.is_active ORDER BY c.updated_at DESC LIMIT 1;
+  v_regel := public.logistics_rule_text(COALESCE(s, '{}'::jsonb), 'order_verwerking', 'pickup_moment_rule', 'eerste');
+  v_marge := public.logistics_rule_num(COALESCE(s, '{}'::jsonb), 'order_verwerking', 'pickup_moment_marge_uren', 2);
+  IF v_regel NOT IN ('eerste', 'laatste_voor_levertijd') THEN v_regel := 'eerste'; END IF;
+  RETURN jsonb_build_object('regel', v_regel, 'margeUren', COALESCE(v_marge, 2), 'werkwijzeGevonden', s IS NOT NULL);
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_pickup_regel() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_pickup_regel() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_pickup_moment_kies(
+  p_carrier_id uuid, p_leverdag date, p_levertijd timestamptz, p_regel text, p_marge_uren numeric)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_tz text; r record; n int;
+BEGIN
+  IF p_carrier_id IS NULL THEN
+    RETURN jsonb_build_object('ok', false, 'redenCode', 'geen_vervoerder', 'reden', 'De order heeft geen vervoerder.');
+  END IF;
+  IF p_leverdag IS NULL THEN
+    RETURN jsonb_build_object('ok', false, 'redenCode', 'geen_leverdag', 'reden', 'De order heeft geen leverdag.');
+  END IF;
+  v_tz := public.logistics_tz();
+  IF v_tz IS NULL THEN
+    RETURN jsonb_build_object('ok', false, 'redenCode', 'geen_tijdzone', 'reden', 'De tijdzone van de vestiging ontbreekt. Stel die in bij Werktijden.');
+  END IF;
+
+  SELECT count(*) INTO n
+    FROM public.logistics_pickup_moments p
+   WHERE p.carrier_id = p_carrier_id AND p.moment_date = p_leverdag AND p.pickup_time IS NOT NULL
+     AND public.logistics_subtract_pick_workdays(p_leverdag, COALESCE(p.pickup_days, 0)) IS NOT NULL;
+  IF n = 0 THEN
+    RETURN jsonb_build_object('ok', false, 'redenCode', 'geen_moment_op_dag',
+      'reden', 'De vervoerder heeft geen ophaalmoment op ' || to_char(p_leverdag, 'DD-MM-YYYY') || '.');
+  END IF;
+
+  IF p_regel = 'laatste_voor_levertijd' AND p_levertijd IS NOT NULL THEN
+    SELECT k2.* INTO r FROM (
+      SELECT p.pickup_time, COALESCE(p.pickup_days, 0) AS pd, p.signup_days AS sd, p.signup_time AS st,
+             public.logistics_subtract_pick_workdays(p_leverdag, COALESCE(p.pickup_days, 0)) AS pdag,
+             ((public.logistics_subtract_pick_workdays(p_leverdag, COALESCE(p.pickup_days, 0))::timestamp + p.pickup_time) AT TIME ZONE v_tz) AS pickup_at
+        FROM public.logistics_pickup_moments p
+       WHERE p.carrier_id = p_carrier_id AND p.moment_date = p_leverdag AND p.pickup_time IS NOT NULL) k2
+     WHERE k2.pdag IS NOT NULL
+       AND k2.pickup_at <= p_levertijd - make_interval(secs => (COALESCE(p_marge_uren, 2) * 3600)::double precision)
+     ORDER BY k2.pickup_at DESC LIMIT 1;
+    IF NOT FOUND THEN
+      RETURN jsonb_build_object('ok', false, 'redenCode', 'geen_moment_voor_levertijd',
+        'reden', 'Er is geen ophaalmoment minstens ' || COALESCE(p_marge_uren, 2) || ' uur vóór de levertijd van de klant ('
+                 || to_char(p_levertijd AT TIME ZONE v_tz, 'DD-MM-YYYY HH24:MI') || ').');
+    END IF;
+  ELSE
+    SELECT k2.* INTO r FROM (
+      SELECT p.pickup_time, COALESCE(p.pickup_days, 0) AS pd, p.signup_days AS sd, p.signup_time AS st,
+             public.logistics_subtract_pick_workdays(p_leverdag, COALESCE(p.pickup_days, 0)) AS pdag,
+             ((public.logistics_subtract_pick_workdays(p_leverdag, COALESCE(p.pickup_days, 0))::timestamp + p.pickup_time) AT TIME ZONE v_tz) AS pickup_at
+        FROM public.logistics_pickup_moments p
+       WHERE p.carrier_id = p_carrier_id AND p.moment_date = p_leverdag AND p.pickup_time IS NOT NULL) k2
+     WHERE k2.pdag IS NOT NULL
+     ORDER BY k2.pickup_at ASC LIMIT 1;
+  END IF;
+
+  RETURN jsonb_build_object('ok', true,
+    'pickupMoment', to_char(r.pdag, 'YYYY-MM-DD') || '|' || to_char(r.pickup_time, 'HH24:MI'),
+    'momentKey', CASE WHEN r.st IS NOT NULL
+                      THEN r.pd::text || '@' || to_char(r.pickup_time, 'HH24:MI') || '|' || COALESCE(r.sd, 0)::text || '@' || to_char(r.st, 'HH24:MI') END,
+    'pickupAt', r.pickup_at,
+    'regel', CASE WHEN p_regel = 'laatste_voor_levertijd' AND p_levertijd IS NOT NULL THEN 'laatste_voor_levertijd' ELSE 'eerste' END);
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_pickup_moment_kies(uuid, date, timestamptz, text, numeric) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_pickup_moment_kies(uuid, date, timestamptz, text, numeric) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_pickup_cf_nieuw(
+  p_cf jsonb, p_carrier_id uuid, p_delivery_date text, p_deleted_at timestamptz, p_cancelled_at timestamptz,
+  p_plan_locked_at timestamptz, p_regel jsonb DEFAULT NULL)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE cf jsonb := COALESCE(p_cf, '{}'::jsonb); v_dag date; v_lt timestamptz; v_regel jsonb; k jsonb; n jsonb;
+BEGIN
+  IF jsonb_typeof(cf) <> 'object' THEN RETURN NULL; END IF;
+  IF p_deleted_at IS NOT NULL OR p_cancelled_at IS NOT NULL OR p_plan_locked_at IS NOT NULL THEN RETURN NULL; END IF;
+  IF (cf->'backfill') IS NOT NULL AND jsonb_typeof(cf->'backfill') <> 'null'
+     AND (CASE WHEN jsonb_typeof(cf->'backfill') = 'boolean' THEN (cf->>'backfill')::boolean
+              ELSE lower(btrim(cf->>'backfill')) NOT IN ('', 'false', '0', 'nee', 'no') END) THEN
+    RETURN NULL;
+  END IF;
+  IF nullif(btrim(COALESCE(cf->>'pickup_moment', '')), '') IS NOT NULL
+     AND COALESCE(cf->>'pickup_moment_bron', '') <> 'auto' THEN
+    RETURN NULL;
+  END IF;
+  BEGIN v_dag := public.logistics_order_date(p_delivery_date); EXCEPTION WHEN OTHERS THEN v_dag := NULL; END;
+  IF v_dag IS NOT NULL AND v_dag < (now() AT TIME ZONE 'Europe/Amsterdam')::date THEN RETURN NULL; END IF;
+  BEGIN v_lt := nullif(btrim(COALESCE(cf->>'floriday_latest_delivery_at', '')), '')::timestamptz;
+  EXCEPTION WHEN OTHERS THEN v_lt := NULL; END;
+  v_regel := COALESCE(p_regel, public.logistics_pickup_regel());
+  k := public.logistics_pickup_moment_kies(p_carrier_id, v_dag, v_lt, v_regel->>'regel', (v_regel->>'margeUren')::numeric);
+  IF COALESCE((k->>'ok')::boolean, false) THEN
+    n := (cf - 'pickup_moment_reden') || jsonb_build_object('pickup_moment', k->>'pickupMoment', 'pickup_moment_bron', 'auto');
+    n := CASE WHEN k->>'momentKey' IS NOT NULL THEN n || jsonb_build_object('pickup_moment_key', k->>'momentKey')
+              ELSE n - 'pickup_moment_key' END;
+  ELSE
+    n := (cf - 'pickup_moment' - 'pickup_moment_key')
+         || jsonb_build_object('pickup_moment_bron', 'auto', 'pickup_moment_reden', k->>'reden');
+  END IF;
+  IF n = cf THEN RETURN NULL; END IF;
+  RETURN n;
+END;
+$$;
+REVOKE ALL ON FUNCTION public.logistics_pickup_cf_nieuw(jsonb, uuid, text, timestamptz, timestamptz, timestamptz, jsonb) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_pickup_cf_nieuw(jsonb, uuid, text, timestamptz, timestamptz, timestamptz, jsonb) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_orders_pickup_moment()
+RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE n jsonb;
+BEGIN
+  IF COALESCE(current_setting('logistics.pickup_writer', true), '') = 'engine' THEN RETURN NEW; END IF;
+  IF TG_OP = 'UPDATE'
+     AND NEW.carrier_id IS NOT DISTINCT FROM OLD.carrier_id
+     AND NEW.delivery_date IS NOT DISTINCT FROM OLD.delivery_date
+     AND (NEW.custom_fields->>'floriday_latest_delivery_at') IS NOT DISTINCT FROM (OLD.custom_fields->>'floriday_latest_delivery_at')
+     AND NEW.deleted_at IS NOT DISTINCT FROM OLD.deleted_at
+     AND (nullif(btrim(COALESCE(NEW.custom_fields->>'pickup_moment', '')), '') IS NOT NULL
+          OR (NEW.custom_fields->'pickup_moment_reden') IS NOT NULL) THEN
+    RETURN NEW;
+  END IF;
+  BEGIN
+    n := public.logistics_pickup_cf_nieuw(NEW.custom_fields, NEW.carrier_id, NEW.delivery_date::text,
+           NEW.deleted_at, NEW.cancelled_at, NEW.plan_locked_at, NULL);
+    IF n IS NOT NULL THEN NEW.custom_fields := n; END IF;
+  EXCEPTION WHEN OTHERS THEN
+    RAISE WARNING 'logistiek-engine: ophaalmoment bepalen mislukt voor order %: %', NEW.id, SQLERRM;
+    BEGIN
+      PERFORM public._logistics_merge_melding('ophaalmoment_fout', NEW.id, NULL, NULL, 'ophaalmoment bepalen: ' || SQLERRM);
+    EXCEPTION WHEN OTHERS THEN RAISE WARNING 'logistiek-engine: melding ophaalmoment mislukt: %', SQLERRM; END;
+  END;
+  RETURN NEW;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_orders_pickup_moment() FROM PUBLIC, anon, authenticated;
+DROP TRIGGER IF EXISTS trg_logistics_orders_zpickup_moment ON public.orders;
+CREATE TRIGGER trg_logistics_orders_zpickup_moment
+  BEFORE INSERT OR UPDATE ON public.orders
+  FOR EACH ROW EXECUTE FUNCTION public.logistics_orders_pickup_moment();
+
+CREATE OR REPLACE FUNCTION public.logistics_pickup_herwijs(p_carrier_ids uuid[], p_max integer DEFAULT 5000)
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE r record; n jsonb; v_regel jsonb; v_gewijzigd int := 0; v_fouten jsonb := '[]'::jsonb; v_vorig text;
+BEGIN
+  IF p_carrier_ids IS NULL OR cardinality(p_carrier_ids) = 0 THEN RETURN jsonb_build_object('gewijzigd', 0); END IF;
+  v_regel := public.logistics_pickup_regel();
+  v_vorig := current_setting('logistics.pickup_writer', true);
+  FOR r IN
+    SELECT o.id, o.order_number, o.custom_fields, o.carrier_id, o.delivery_date::text AS dd, o.deleted_at, o.cancelled_at, o.plan_locked_at
+      FROM public.orders o
+     WHERE o.carrier_id = ANY (p_carrier_ids) AND o.deleted_at IS NULL AND o.cancelled_at IS NULL
+       AND public.logistics_order_date(o.delivery_date::text) >= (now() AT TIME ZONE 'Europe/Amsterdam')::date
+       AND (nullif(btrim(COALESCE(o.custom_fields->>'pickup_moment', '')), '') IS NULL
+            OR COALESCE(o.custom_fields->>'pickup_moment_bron', '') = 'auto')
+     ORDER BY o.delivery_date LIMIT greatest(COALESCE(p_max, 5000), 1)
+  LOOP
+    BEGIN
+      n := public.logistics_pickup_cf_nieuw(r.custom_fields, r.carrier_id, r.dd, r.deleted_at, r.cancelled_at, r.plan_locked_at, v_regel);
+      IF n IS NOT NULL THEN
+        PERFORM set_config('logistics.pickup_writer', 'engine', true);
+        UPDATE public.orders SET custom_fields = n, updated_at = now() WHERE id = r.id;
+        PERFORM set_config('logistics.pickup_writer', COALESCE(v_vorig, ''), true);
+        v_gewijzigd := v_gewijzigd + 1;
+      END IF;
+    EXCEPTION WHEN OTHERS THEN
+      PERFORM set_config('logistics.pickup_writer', COALESCE(v_vorig, ''), true);
+      v_fouten := v_fouten || jsonb_build_array(jsonb_build_object('order', r.order_number, 'fout', SQLERRM));
+      PERFORM public._logistics_merge_melding('ophaalmoment_fout', r.id, NULL, NULL, 'ophaalmoment herzien: ' || SQLERRM);
+    END;
+  END LOOP;
+  RETURN jsonb_build_object('gewijzigd', v_gewijzigd, 'fouten', v_fouten);
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_pickup_herwijs(uuid[], integer) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_pickup_herwijs(uuid[], integer) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_pickup_moments_gewijzigd_trg()
+RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_ids uuid[];
+BEGIN
+  IF TG_OP = 'DELETE' THEN
+    SELECT array_agg(DISTINCT carrier_id) INTO v_ids FROM oud WHERE carrier_id IS NOT NULL;
+  ELSIF TG_OP = 'INSERT' THEN
+    SELECT array_agg(DISTINCT carrier_id) INTO v_ids FROM nieuw WHERE carrier_id IS NOT NULL;
+  ELSE
+    SELECT array_agg(DISTINCT x) INTO v_ids FROM (
+      SELECT carrier_id x FROM nieuw UNION SELECT carrier_id FROM oud) t WHERE x IS NOT NULL;
+  END IF;
+  BEGIN
+    PERFORM public.logistics_pickup_herwijs(v_ids, 5000);
+  EXCEPTION WHEN OTHERS THEN
+    RAISE WARNING 'logistiek-engine: ophaalmomenten herzien mislukt: %', SQLERRM;
+    PERFORM public._logistics_merge_melding('ophaalmoment_fout', NULL, NULL, NULL, 'ophaalmomenten herzien: ' || SQLERRM);
+  END;
+  RETURN NULL;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_pickup_moments_gewijzigd_trg() FROM PUBLIC, anon, authenticated;
+DROP TRIGGER IF EXISTS trg_logistics_pickup_moments_ins ON public.logistics_pickup_moments;
+DROP TRIGGER IF EXISTS trg_logistics_pickup_moments_upd ON public.logistics_pickup_moments;
+DROP TRIGGER IF EXISTS trg_logistics_pickup_moments_del ON public.logistics_pickup_moments;
+CREATE TRIGGER trg_logistics_pickup_moments_ins AFTER INSERT ON public.logistics_pickup_moments
+  REFERENCING NEW TABLE AS nieuw FOR EACH STATEMENT EXECUTE FUNCTION public.logistics_pickup_moments_gewijzigd_trg();
+CREATE TRIGGER trg_logistics_pickup_moments_upd AFTER UPDATE ON public.logistics_pickup_moments
+  REFERENCING NEW TABLE AS nieuw OLD TABLE AS oud FOR EACH STATEMENT EXECUTE FUNCTION public.logistics_pickup_moments_gewijzigd_trg();
+CREATE TRIGGER trg_logistics_pickup_moments_del AFTER DELETE ON public.logistics_pickup_moments
+  REFERENCING OLD TABLE AS oud FOR EACH STATEMENT EXECUTE FUNCTION public.logistics_pickup_moments_gewijzigd_trg();
+
+CREATE OR REPLACE FUNCTION public.logistics_pickup_vul_voorbeeld()
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_regel jsonb := public.logistics_pickup_regel(); v jsonb;
+BEGIN
+  WITH o AS (
+    SELECT o.id, o.order_number, o.carrier_id, public.logistics_order_date(o.delivery_date::text) AS dag,
+           public.logistics_pickup_cf_nieuw(o.custom_fields, o.carrier_id, o.delivery_date::text, o.deleted_at, o.cancelled_at, o.plan_locked_at, v_regel) AS n
+      FROM public.orders o
+     WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL
+       AND public.logistics_order_date(o.delivery_date::text) >= (now() AT TIME ZONE 'Europe/Amsterdam')::date
+       AND NOT public.logistics_order_is_backfill(o.id)
+       AND (nullif(btrim(COALESCE(o.custom_fields->>'pickup_moment', '')), '') IS NULL
+            OR COALESCE(o.custom_fields->>'pickup_moment_bron', '') = 'auto')
+  ), u AS (
+    SELECT o.*, COALESCE(c.name, '(geen vervoerder)') AS vervoerder,
+           CASE WHEN o.n IS NULL THEN 'ongewijzigd'
+                WHEN (o.n->'pickup_moment') IS NOT NULL THEN 'krijgt moment'
+                ELSE 'geen moment: ' || COALESCE(o.n->>'pickup_moment_reden', '?') END AS uitkomst
+      FROM o LEFT JOIN public.carriers c ON c.id = o.carrier_id
+  )
+  SELECT jsonb_build_object('regel', v_regel,
+    'totaal', (SELECT count(*) FROM u),
+    'krijgtMoment', (SELECT count(*) FROM u WHERE uitkomst = 'krijgt moment'),
+    'ongewijzigd', (SELECT count(*) FROM u WHERE uitkomst = 'ongewijzigd'),
+    'zonderMoment', (SELECT count(*) FROM u WHERE uitkomst LIKE 'geen moment%'),
+    'perVervoerderEnDag', COALESCE((SELECT jsonb_agg(jsonb_build_object('vervoerder', vervoerder, 'leverdag', dag,
+                              'uitkomst', regexp_replace(uitkomst, ' op \d{2}-\d{2}-\d{4}\.$', ''), 'aantal', n, 'voorbeelden', vb)
+                              ORDER BY dag, vervoerder)
+        FROM (SELECT vervoerder, dag, uitkomst, count(*) n, (array_agg(order_number ORDER BY order_number))[1:3] vb
+                FROM u WHERE uitkomst <> 'ongewijzigd' GROUP BY 1, 2, 3) g), '[]'::jsonb))
+    INTO v;
+  RETURN v;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_pickup_vul_voorbeeld() FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_pickup_vul_voorbeeld() TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_pickup_vul_uitvoeren(p_max integer DEFAULT 500)
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE r record; n jsonb; v_regel jsonb; v_gevuld int := 0; v_zonder int := 0; v_bekeken int := 0;
+        v_fouten jsonb := '[]'::jsonb; v_vorig text; v_rest int;
+BEGIN
+  PERFORM public.logistics_pickup_moments_koppel();
+  v_regel := public.logistics_pickup_regel();
+  v_vorig := current_setting('logistics.pickup_writer', true);
+  FOR r IN
+    SELECT o.id, o.order_number, o.custom_fields, o.carrier_id, o.delivery_date::text AS dd, o.deleted_at, o.cancelled_at, o.plan_locked_at
+      FROM public.orders o
+     WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL
+       AND public.logistics_order_date(o.delivery_date::text) >= (now() AT TIME ZONE 'Europe/Amsterdam')::date
+       AND NOT public.logistics_order_is_backfill(o.id)
+       AND (nullif(btrim(COALESCE(o.custom_fields->>'pickup_moment', '')), '') IS NULL
+            OR COALESCE(o.custom_fields->>'pickup_moment_bron', '') = 'auto')
+     ORDER BY o.delivery_date, o.order_number
+  LOOP
+    EXIT WHEN v_gevuld + v_zonder >= greatest(COALESCE(p_max, 500), 1);
+    v_bekeken := v_bekeken + 1;
+    BEGIN
+      n := public.logistics_pickup_cf_nieuw(r.custom_fields, r.carrier_id, r.dd, r.deleted_at, r.cancelled_at, r.plan_locked_at, v_regel);
+      IF n IS NOT NULL THEN
+        PERFORM set_config('logistics.pickup_writer', 'engine', true);
+        UPDATE public.orders SET custom_fields = n, updated_at = now() WHERE id = r.id;
+        PERFORM set_config('logistics.pickup_writer', COALESCE(v_vorig, ''), true);
+        IF (n->'pickup_moment') IS NOT NULL THEN v_gevuld := v_gevuld + 1; ELSE v_zonder := v_zonder + 1; END IF;
+      END IF;
+    EXCEPTION WHEN OTHERS THEN
+      PERFORM set_config('logistics.pickup_writer', COALESCE(v_vorig, ''), true);
+      v_fouten := v_fouten || jsonb_build_array(jsonb_build_object('order', r.order_number, 'fout', SQLERRM));
+    END;
+  END LOOP;
+  v_rest := COALESCE((public.logistics_pickup_vul_voorbeeld()->>'krijgtMoment')::int, 0);
+  RETURN jsonb_build_object('gevuld', v_gevuld, 'zonderMomentGemarkeerd', v_zonder, 'bekeken', v_bekeken,
+                            'fouten', v_fouten, 'nogTeDoen', v_rest);
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_pickup_vul_uitvoeren(integer) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_pickup_vul_uitvoeren(integer) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_pickup_status()
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_vandaag date := (now() AT TIME ZONE 'Europe/Amsterdam')::date; v_tot date; v_heeft boolean; v jsonb; v_regel jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_pickup_status');
+  v_regel := public.logistics_pickup_regel();
+  SELECT max(moment_date) INTO v_tot FROM public.logistics_pickup_moments;
+  SELECT EXISTS (SELECT 1 FROM public.carriers c WHERE c.archived_at IS NULL
+                   AND jsonb_typeof(c.pickup_moments) = 'array' AND jsonb_array_length(c.pickup_moments) > 0) INTO v_heeft;
+  WITH o AS (
+    SELECT o.order_number, o.carrier_id, public.logistics_order_date(o.delivery_date::text) AS dag, o.custom_fields cf
+      FROM public.orders o
+     WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL
+       AND public.logistics_order_date(o.delivery_date::text) BETWEEN v_vandaag AND v_vandaag + 6
+       AND NOT public.logistics_order_is_backfill(o.id)
+       AND lower(btrim(COALESCE(o.status, ''))) NOT IN ('verzonden', 'afgehandeld', 'geannuleerd', 'cancelled', 'canceled')
+       AND nullif(btrim(COALESCE(o.custom_fields->>'pickup_moment', '')), '') IS NULL
+  ), r AS (
+    SELECT o.*, public.logistics_pickup_moment_kies(o.carrier_id, o.dag,
+             CASE WHEN o.cf->>'floriday_latest_delivery_at' ~ '^\d{4}-' THEN (o.cf->>'floriday_latest_delivery_at')::timestamptz END,
+             v_regel->>'regel', (v_regel->>'margeUren')::numeric) AS k
+      FROM o
+  )
+  SELECT jsonb_build_object(
+    'zonderMoment', (SELECT count(*) FROM r),
+    'redenen', COALESCE((SELECT jsonb_object_agg(code, n) FROM (
+        SELECT COALESCE(CASE WHEN (k->>'ok')::boolean THEN 'nog_niet_gevuld' END, k->>'redenCode', 'onbekend') code, count(*) n
+          FROM r GROUP BY 1) g), '{}'::jsonb),
+    'voorbeelden', COALESCE((SELECT jsonb_agg(order_number) FROM (SELECT order_number FROM r ORDER BY dag, order_number LIMIT 5) x), '[]'::jsonb),
+    'momentenTot', v_tot,
+    'momentenTeKort', v_heeft AND (v_tot IS NULL OR v_tot < v_vandaag + 14),
+    'ongekoppeld', (SELECT count(*) FROM public.logistics_pickup_moments p WHERE p.moment_date >= v_vandaag AND p.carrier_id IS NULL),
+    'regel', v_regel)
+  INTO v;
+  RETURN v;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_pickup_status() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_pickup_status() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_refresh_pickup_moments(p_weeks integer DEFAULT 4)
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+declare
+  v_weeks integer := greatest(1, least(coalesce(p_weeks, 4), 26));
+  v_from date := current_date;
+  v_to date := current_date + (v_weeks * 7);
+  v_inserted integer := 0;
+  v_updated integer := 0;
+  v_removed integer := 0;
+begin
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_refresh_pickup_moments');
+  create temp table _wanted on commit drop as
+  with dagen as (
+    select d::date as moment_date from generate_series(v_from, v_to, interval '1 day') d
+  ),
+  momenten as (
+    select c.user_id, c.id as carrier_id, c.name as carrier_ref, c.pickup_weekdays,
+           nullif(m->>'pickup_time','')::time as pickup_time,
+           greatest(coalesce(nullif(m->>'pickup_days','')::int, 0), 0) as pickup_days,
+           greatest(coalesce(nullif(m->>'signup_days','')::int, 0), 0) as signup_days,
+           nullif(m->>'signup_time','')::time as signup_time,
+           nullif(m->>'label','') as label
+    from public.carriers c
+    cross join lateral jsonb_array_elements(
+      case when jsonb_typeof(c.pickup_moments) = 'array' then c.pickup_moments else '[]'::jsonb end) m
+    where c.archived_at is null
+  ),
+  geldig as (
+    select d.moment_date, mo.user_id, mo.carrier_id, mo.carrier_ref, mo.pickup_time, mo.pickup_days,
+           mo.signup_days, mo.signup_time, mo.label
+    from dagen d
+    join momenten mo
+      on mo.pickup_time is not null
+     and (mo.pickup_weekdays is null or array_length(mo.pickup_weekdays, 1) is null
+          or extract(isodow from d.moment_date)::int = any(mo.pickup_weekdays))
+  ),
+  uniek as (
+    select distinct on (user_id, moment_date, carrier_id, pickup_time)
+           user_id, moment_date, carrier_id, carrier_ref, pickup_time, pickup_days, signup_days, signup_time, label
+    from geldig
+    order by user_id, moment_date, carrier_id, pickup_time, pickup_days, signup_time
+  )
+  select u.*,
+         row_number() over (partition by user_id, moment_date order by pickup_time, carrier_ref, carrier_id)::int as sequence
+  from uniek u;
+
+  if not exists (select 1 from _wanted) then
+    return jsonb_build_object('ok', true, 'reason', 'geen_ophaalmomenten_ingesteld', 'inserted', 0, 'updated', 0, 'removed', 0);
+  end if;
+
+  with weg as (
+    delete from public.logistics_pickup_moments p
+    where p.moment_date between v_from and v_to
+      and not exists (select 1 from _wanted w
+                      where w.user_id = p.user_id and w.moment_date = p.moment_date and w.sequence = p.sequence)
+    returning 1
+  )
+  select count(*) into v_removed from weg;
+
+  with upd as (
+    update public.logistics_pickup_moments p
+    set pickup_time = w.pickup_time, carrier_ref = w.carrier_ref, carrier_id = w.carrier_id,
+        pickup_days = w.pickup_days, signup_days = w.signup_days, signup_time = w.signup_time,
+        label = w.label, updated_at = now()
+    from _wanted w
+    where p.user_id = w.user_id and p.moment_date = w.moment_date and p.sequence = w.sequence
+      and (p.pickup_time is distinct from w.pickup_time or p.carrier_ref is distinct from w.carrier_ref
+        or p.carrier_id is distinct from w.carrier_id or p.pickup_days is distinct from w.pickup_days
+        or p.signup_days is distinct from w.signup_days or p.signup_time is distinct from w.signup_time
+        or p.label is distinct from w.label)
+    returning 1
+  )
+  select count(*) into v_updated from upd;
+
+  with ins as (
+    insert into public.logistics_pickup_moments
+      (user_id, moment_date, sequence, pickup_time, carrier_ref, carrier_id, pickup_days, signup_days, signup_time, label)
+    select w.user_id, w.moment_date, w.sequence, w.pickup_time, w.carrier_ref, w.carrier_id, w.pickup_days, w.signup_days, w.signup_time, w.label
+    from _wanted w
+    where not exists (select 1 from public.logistics_pickup_moments p
+                      where p.user_id = w.user_id and p.moment_date = w.moment_date and p.sequence = w.sequence)
+    returning 1
+  )
+  select count(*) into v_inserted from ins;
+
+  return jsonb_build_object('ok', true, 'inserted', v_inserted, 'updated', v_updated, 'removed', v_removed,
+                            'from', v_from, 'to', v_to);
+end $$;
+
+CREATE OR REPLACE FUNCTION public.logistics_order_buffer_ref(p_order_id uuid)
+RETURNS text LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE d jsonb;
+BEGIN
+  d := public.logistics_buffer_decision(public.logistics_buffer_payload(p_order_id), NULL);
+  IF COALESCE((d->>'buffer')::boolean, false) IS NOT TRUE OR NOT COALESCE((d->>'complete')::boolean, false) THEN RETURN NULL; END IF;
+  RETURN nullif(d->>'bufferRef', '');
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_order_buffer_ref(uuid) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_order_buffer_ref(uuid) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_merge_floriday_lines(p_order_id uuid)
+RETURNS uuid LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE
+  v_ref text; v_key text; v_keep uuid; v_keepnr text; v_cust uuid; v_dag date; r record; v_ids uuid[];
+  v_moved int; v_logged int; v_total int := 0; v_count int := 0; v_groep int; s jsonb;
+  v_lines text[] := ARRAY[]::text[];
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_merge_floriday_lines');
+  IF p_order_id IS NULL THEN RETURN p_order_id; END IF;
+  IF COALESCE(current_setting('logistics.merge_uit', true), '') = '1' THEN RETURN p_order_id; END IF;
+  IF NOT public.logistics_merge_lines_enabled() THEN RETURN p_order_id; END IF;
+  SELECT c.settings INTO s FROM public.logistics_rule_configs c WHERE c.is_active ORDER BY c.updated_at DESC LIMIT 1;
+  IF NOT public.logistics_rule_bool(COALESCE(s, '{}'::jsonb), 'order_verwerking', 'buffer_enabled', true) THEN RETURN p_order_id; END IF;
+  IF NOT public.logistics_order_mergeable(p_order_id) THEN RETURN p_order_id; END IF;
+  IF NOT EXISTS (SELECT 1 FROM logistics_active.order_items i WHERE i.order_id = p_order_id) THEN RETURN p_order_id; END IF;
+
+  v_ref := public.logistics_order_buffer_ref(p_order_id);
+  IF v_ref IS NULL THEN RETURN p_order_id; END IF;
+  SELECT customer_id, public.logistics_order_date(delivery_date::text) INTO v_cust, v_dag FROM public.orders WHERE id = p_order_id;
+  IF v_cust IS NULL OR v_dag IS NULL THEN RETURN p_order_id; END IF;
+  v_key := 'buf|' || v_ref || '|' || v_cust::text || '|' || v_dag::text;
+  IF NOT pg_try_advisory_xact_lock(hashtext('logistics_merge:' || v_key)) THEN RETURN p_order_id; END IF;
+
+  SELECT array_agg(o.id ORDER BY o.order_number ASC NULLS LAST, o.created_at ASC) INTO v_ids
+    FROM public.orders o
+   WHERE o.customer_id = v_cust AND o.deleted_at IS NULL AND o.order_source = 'floriday'
+     AND public.logistics_order_date(o.delivery_date::text) = v_dag
+     AND EXISTS (SELECT 1 FROM logistics_active.order_items i WHERE i.order_id = o.id)
+     AND public.logistics_order_mergeable(o.id)
+     AND public.logistics_order_buffer_ref(o.id) = v_ref;
+  v_groep := COALESCE(cardinality(v_ids), 0);
+  IF v_groep < 2 THEN RETURN p_order_id; END IF;
+  v_keep := v_ids[1];
+  v_groep := v_groep + (SELECT count(*) FROM public.logistics_order_merges m WHERE m.kept_order_id = v_keep AND m.group_key = v_key);
+  IF v_groep > 20 THEN
+    IF NOT EXISTS (SELECT 1 FROM public.logistics_merge_meldingen m
+                    WHERE m.soort = 'groep_te_groot' AND m.group_key = v_key AND m.created_at > now() - interval '1 day') THEN
+      PERFORM public._logistics_merge_melding('groep_te_groot', p_order_id, v_key, v_groep,
+        v_groep || ' orders in dezelfde buffergroep; niet samengevoegd.');
+    END IF;
+    RETURN p_order_id;
+  END IF;
+
+  SELECT order_number INTO v_keepnr FROM public.orders WHERE id = v_keep;
+  PERFORM set_config('logistics.merge_uit', '1', true);
+
+  FOR r IN SELECT o.id, o.order_number, o.floriday_sales_order_id AS sales, o.created_at
+             FROM public.orders o WHERE o.id = ANY (v_ids) AND o.id <> v_keep
+            ORDER BY o.order_number ASC NULLS LAST LOOP
+    BEGIN
+      INSERT INTO public.logistics_order_merge_lines(
+        group_key, from_order_id, from_order_number, to_order_id, to_order_number,
+        order_item_id, product_id, product_name, quantity, source_line_key,
+        sales_order_id, ordered_at, reason)
+      SELECT v_key, r.id, r.order_number, v_keep, v_keepnr,
+             i.id, i.product_id, i.product_name, i.quantity, i.source_line_key,
+             r.sales, r.created_at, 'Zelfde buffergroep volgens de werkwijze'
+        FROM logistics_active.order_items i WHERE i.order_id = r.id;
+      GET DIAGNOSTICS v_logged = ROW_COUNT;
+      UPDATE public.order_items SET order_id = v_keep WHERE order_id = r.id AND quarantined_at IS NULL;
+      GET DIAGNOSTICS v_moved = ROW_COUNT;
+      IF v_moved <> v_logged THEN RAISE EXCEPTION 'aantal verplaatste regels (%) wijkt af van het logboek (%)', v_moved, v_logged; END IF;
+      IF v_moved = 0 THEN RAISE EXCEPTION 'geen regels verplaatst; order blijft staan'; END IF;
+      INSERT INTO public.logistics_order_merges(group_key, kept_order_id, kept_order_number,
+        merged_order_id, merged_order_number, sales_order_id, items_moved)
+      VALUES (v_key, v_keep, v_keepnr, r.id, r.order_number, r.sales, v_moved)
+      ON CONFLICT (merged_order_id) DO NOTHING;
+      UPDATE public.orders SET deleted_at = now(),
+             notes = COALESCE(NULLIF(notes, ''), '')
+                     || CASE WHEN COALESCE(notes, '') = '' THEN '' ELSE E'\n' END
+                     || 'Samengevoegd met ' || COALESCE(v_keepnr, '') || '.',
+             updated_at = now()
+       WHERE id = r.id;
+      v_total := v_total + v_moved; v_count := v_count + 1;
+      v_lines := v_lines || (COALESCE(r.order_number, '') || ': ' || v_moved::text || ' regel(s)');
+    EXCEPTION WHEN OTHERS THEN
+      PERFORM public._logistics_merge_melding('fout', r.id, v_key, NULL,
+        'samenvoegen ' || COALESCE(r.order_number, '?') || ' met ' || COALESCE(v_keepnr, '?') || ': ' || SQLERRM);
+    END;
+  END LOOP;
+  PERFORM set_config('logistics.merge_uit', '0', true);
+
+  IF v_count > 0 THEN
+    UPDATE public.orders o SET total = to_char(COALESCE((
+             SELECT SUM(COALESCE(i.quantity, 0) * COALESCE(i.unit_price, 0))
+               FROM logistics_active.order_items i WHERE i.order_id = o.id), 0), 'FM9999999990.00'),
+           updated_at = now()
+     WHERE o.id = v_keep;
+    PERFORM public.logistics_trace_order_step(
+      v_keep, 'stap:bestelregels_samenvoegen', 'bestelregels samenvoegen', 'geslaagd',
+      'samengevoegd tot ' || COALESCE(v_keepnr, 'één bestelling'),
+      v_count::text || ' order(s), ' || v_total::text || ' regel(s) verplaatst: ' || array_to_string(v_lines, '; '),
+      'Orders combineren');
+  END IF;
+  IF EXISTS (SELECT 1 FROM public.orders WHERE id = p_order_id AND deleted_at IS NOT NULL) THEN RETURN v_keep; END IF;
+  RETURN p_order_id;
+EXCEPTION WHEN OTHERS THEN
+  PERFORM set_config('logistics.merge_uit', '0', true);
+  PERFORM public._logistics_merge_melding('fout', p_order_id, v_key, NULL, 'samenvoegen: ' || SQLERRM);
+  RETURN p_order_id;
+END $$;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_samenvoegen()
+ RETURNS TABLE(onderdeel text, ok boolean, toelichting text)
+ LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE f text;
+BEGIN
+  FOREACH f IN ARRAY ARRAY['logistics_order_is_backfill(uuid)', 'logistics_order_merge_key_v2(uuid)',
+      'logistics_order_mergeable(uuid)', 'logistics_merge_floriday_lines(uuid)', 'logistics_order_buffer_ref(uuid)',
+      'logistics_merge_herstel_voorbeeld()', 'logistics_merge_herstel_uitvoeren(text,integer)',
+      'logistics_merge_status()', 'logistics_trace_event(uuid,text,text,text)', 'logistics_schema_versie()',
+      'logistics_pickup_regel()', 'logistics_pickup_moment_kies(uuid,date,timestamp with time zone,text,numeric)',
+      'logistics_pickup_vul_voorbeeld()', 'logistics_pickup_vul_uitvoeren(integer)', 'logistics_pickup_status()',
+      'logistics_pickup_herwijs(uuid[],integer)', 'logistics_refresh_pickup_moments(integer)'] LOOP
+    onderdeel := 'functie ' || f;
+    ok := to_regprocedure('public.' || f) IS NOT NULL;
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: werk de Engine bij via Supabase bijwerken' END;
+    RETURN NEXT;
+  END LOOP;
+  onderdeel := 'tabel logistics_merge_herstel_log';
+  ok := to_regclass('public.logistics_merge_herstel_log') IS NOT NULL;
+  toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: werk de Engine bij via Supabase bijwerken' END;
+  RETURN NEXT;
+  onderdeel := 'kolom logistics_pickup_moments.carrier_id';
+  ok := EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema = 'public'
+                  AND table_name = 'logistics_pickup_moments' AND column_name = 'carrier_id');
+  toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: werk de Engine bij via Supabase bijwerken' END;
+  RETURN NEXT;
+  onderdeel := 'trigger ophaalmoment op orders';
+  ok := EXISTS (SELECT 1 FROM pg_trigger WHERE tgname = 'trg_logistics_orders_zpickup_moment');
+  toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: werk de Engine bij via Supabase bijwerken' END;
+  RETURN NEXT;
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_schema_versie()
+ RETURNS text LANGUAGE sql IMMUTABLE SET search_path TO 'public'
+AS $function$ SELECT '2026-11-10c'::text $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_buffer_decision_for_settings(p_order jsonb, p_settings jsonb, p_user_id uuid DEFAULT NULL::uuid)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ STABLE
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_user uuid := p_user_id;
+  v_settings jsonb := COALESCE(p_settings, '{}'::jsonb);
+  v_enabled boolean; v_include_res boolean; v_is_res boolean;
+  v_minutes int; v_reference text; v_release text; v_criteria text[];
+  v_checkin timestamptz; v_pick_start timestamptz; v_close timestamptz;
+  v_key text; v_parts text[] := ARRAY[]::text[]; v_trace jsonb := '[]'::jsonb;
+  v_missing boolean := false; v_missing_list text[] := ARRAY[]::text[];
+  v_day text; v_ref text; c text; eff text; val text;
+  v_is_fd boolean; v_skip text[]; v_skip_raw jsonb;
+BEGIN
+  p_order := COALESCE(p_order, '{}'::jsonb);
+  v_enabled := public.logistics_rule_bool(v_settings, 'order_verwerking', 'buffer_enabled', true);
+  v_include_res := public.logistics_rule_bool(v_settings, 'order_verwerking', 'buffer_include_reservations', false);
+  v_minutes := public.logistics_rule_num(v_settings, 'order_verwerking', 'buffer_close_before_minutes', 60)::int;
+  v_reference := public.logistics_rule_text(v_settings, 'order_verwerking', 'buffer_close_reference', 'checkin');
+  v_release := public.logistics_rule_text(v_settings, 'order_verwerking', 'buffer_release', 'auto');
+  v_criteria := public.logistics_buffer_criteria(v_settings);
+
+  v_skip_raw := public.logistics_rule_value(v_settings, 'order_verwerking', 'buffer_skip_for_floriday');
+  IF v_skip_raw IS NOT NULL AND jsonb_typeof(v_skip_raw) = 'array' THEN
+    v_skip := ARRAY(SELECT jsonb_array_elements_text(v_skip_raw));
+  ELSE
+    -- 1.0.239: geen verborgen standaard meer; alleen overslaan wat de werkwijze zelf aangeeft.
+    v_skip := ARRAY[]::text[];
+  END IF;
+
+  v_is_fd := NULLIF(TRIM(COALESCE(p_order ->> 'floridaySalesOrderRef', p_order ->> 'floriday_sales_order_id', '')), '') IS NOT NULL;
+  v_is_res := COALESCE((p_order ->> 'isReservation')::boolean, (p_order ->> 'is_reservation')::boolean, false);
+  v_ref := COALESCE(NULLIF(p_order ->> 'orderRef', ''), NULLIF(p_order ->> 'order_ref', ''), md5(p_order::text));
+
+  IF NOT v_enabled THEN
+    RETURN jsonb_build_object('buffer', false, 'reason', 'buffering_disabled', 'bufferRef', NULL, 'bufferKey', NULL,
+      'matchCriteria', to_jsonb(v_criteria), 'parts', '[]'::jsonb, 'complete', true, 'missingCriteria', '[]'::jsonb,
+      'isReservation', v_is_res, 'isFloriday', v_is_fd, 'closeBeforeMinutes', NULL, 'closeReference', v_reference,
+      'bufferCloseAt', NULL, 'release', 'none',
+      'trace', jsonb_build_array(jsonb_build_object('rule', 'buffer_enabled', 'result', false,
+        'message', 'Orderbuffer staat uit in de Rule Engine; elke order wordt los verwerkt.')));
+  END IF;
+
+  IF v_is_res AND NOT v_include_res THEN
+    RETURN jsonb_build_object('buffer', false, 'reason', 'reservation_excluded', 'bufferRef', NULL, 'bufferKey', NULL,
+      'matchCriteria', to_jsonb(v_criteria), 'parts', '[]'::jsonb, 'complete', true, 'missingCriteria', '[]'::jsonb,
+      'isReservation', true, 'isFloriday', v_is_fd, 'closeBeforeMinutes', NULL, 'closeReference', v_reference,
+      'bufferCloseAt', NULL, 'release', 'none',
+      'trace', jsonb_build_array(jsonb_build_object('rule', 'buffer_include_reservations', 'result', false,
+        'message', 'Gereserveerde bestellingen worden volgens de instelling buiten de buffers gehouden.')));
+  END IF;
+
+  BEGIN v_checkin := (p_order ->> 'checkinAt')::timestamptz; EXCEPTION WHEN others THEN v_checkin := NULL; END;
+
+  IF v_reference = 'pick_start' THEN
+    v_pick_start := public.logistics_pick_start_estimate(v_settings, p_order);
+    IF v_pick_start IS NOT NULL THEN
+      v_close := v_pick_start - make_interval(mins => v_minutes);
+      v_trace := v_trace || jsonb_build_array(jsonb_build_object('rule', 'buffer_close_reference', 'value', 'pick_start', 'result', true,
+        'message', 'De buffer sluit ' || v_minutes || ' minuten vóór de start van het picken.'));
+    ELSIF v_checkin IS NOT NULL THEN
+      v_close := v_checkin - make_interval(mins => v_minutes);
+      v_trace := v_trace || jsonb_build_array(jsonb_build_object('rule', 'buffer_close_reference', 'value', 'checkin_fallback', 'result', true,
+        'message', 'De pickstart is nog niet te berekenen; er wordt teruggerekend vanaf de aanmeldtijd.'));
+    END IF;
+  ELSIF v_checkin IS NOT NULL THEN
+    v_close := v_checkin - make_interval(mins => v_minutes);
+  END IF;
+
+  v_day := LEFT(COALESCE(p_order ->> 'deliveryDate', p_order ->> 'delivery_date', p_order ->> 'checkinAt', ''), 10);
+  IF v_day <> '' THEN
+    v_parts := v_parts || ('day=' || v_day);
+    v_trace := v_trace || jsonb_build_array(jsonb_build_object('rule', 'day_bucket', 'value', v_day, 'result', true,
+      'message', 'Orders worden alleen binnen dezelfde dag gecombineerd.'));
+  END IF;
+
+  IF array_length(v_criteria, 1) IS NULL THEN
+    val := NULLIF(TRIM(COALESCE(p_order ->> 'customerRef', '')), '');
+    IF val IS NULL THEN
+      v_missing := true; v_missing_list := v_missing_list || 'customer'::text;
+      v_parts := v_parts || ('missing=customer:' || v_ref);
+      v_trace := v_trace || jsonb_build_array(jsonb_build_object('rule', 'no_criteria_selected', 'value', NULL, 'result', false,
+        'message', 'Geen combineercriteria aangevinkt en de klant ontbreekt; deze order wordt niet gecombineerd.'));
+    ELSE
+      v_parts := v_parts || ('customer=' || val);
+      v_trace := v_trace || jsonb_build_array(jsonb_build_object('rule', 'no_criteria_selected', 'result', false,
+        'message', 'Er zijn geen combineercriteria aangevinkt; er wordt teruggevallen op dezelfde klant.'));
+    END IF;
+  ELSE
+    FOREACH c IN ARRAY v_criteria LOOP
+      eff := c;
+      IF v_is_fd AND c = ANY(v_skip) THEN
+        v_trace := v_trace || jsonb_build_array(jsonb_build_object('rule', c, 'value', NULL, 'result', true,
+          'message', 'Niet van toepassing bij Floriday-orders; Floriday levert deze waarde niet.'));
+        CONTINUE;
+      END IF;
+      IF v_is_fd AND c = 'customer_bvo' THEN
+        eff := 'customer_floriday';
+        v_trace := v_trace || jsonb_build_array(jsonb_build_object('rule', c, 'value', NULL, 'result', true,
+          'message', 'Bij Floriday-orders wordt de Floriday-koper gebruikt in plaats van de BVO-klant.'));
+      END IF;
+      val := public.logistics_buffer_value(p_order, eff);
+      IF val IS NULL THEN
+        v_missing := true; v_missing_list := v_missing_list || eff;
+        v_parts := v_parts || ('missing=' || eff || ':' || v_ref);
+        v_trace := v_trace || jsonb_build_array(jsonb_build_object('rule', eff, 'value', NULL, 'result', false,
+          'message', 'Waarde ontbreekt; deze order wordt niet gecombineerd.'));
+      ELSE
+        v_parts := v_parts || (eff || '=' || lower(val));
+        v_trace := v_trace || jsonb_build_array(jsonb_build_object('rule', eff, 'value', val, 'result', true,
+          'message', 'Criterium meegenomen in de buffersleutel.'));
+      END IF;
+    END LOOP;
+  END IF;
+
+  IF coalesce(p_order ->> 'transportGroup', 'extern') IN ('eigen_vervoer', 'klant_haalt_op') THEN
+    v_parts := v_parts || ('vervoer=' || (p_order ->> 'transportGroup'));
+    v_trace := v_trace || jsonb_build_array(jsonb_build_object('rule', 'transport_group', 'value', p_order ->> 'transportGroup', 'result', true,
+      'message', CASE p_order ->> 'transportGroup' WHEN 'eigen_vervoer' THEN 'Eigen vervoer wordt alleen samen gebufferd met andere orders met eigen vervoer.'
+                 ELSE 'Klant haalt op wordt alleen samen gebufferd met andere orders die de klant ophaalt.' END));
+  END IF;
+  v_parts := ARRAY(SELECT DISTINCT ON (p) p FROM unnest(v_parts) WITH ORDINALITY AS t(p, n) ORDER BY p, n);
+  v_key := array_to_string(v_parts, '|');
+
+  RETURN jsonb_build_object(
+    'buffer', true,
+    'reason', CASE WHEN v_missing THEN 'buffering_enabled_missing_data' ELSE 'buffering_enabled' END,
+    'bufferRef', md5(COALESCE(v_user::text, 'anon') || '|' || v_key),
+    'bufferKey', v_key, 'parts', to_jsonb(v_parts), 'complete', NOT v_missing,
+    'missingCriteria', to_jsonb(v_missing_list), 'isReservation', v_is_res, 'isFloriday', v_is_fd,
+    'skippedForFloriday', CASE WHEN v_is_fd THEN to_jsonb(v_skip) ELSE '[]'::jsonb END,
+    'matchCriteria', to_jsonb(v_criteria), 'closeBeforeMinutes', v_minutes, 'closeReference', v_reference,
+    'bufferCloseAt', v_close, 'release', v_release, 'trace', v_trace);
+END;
+$function$;
+
+SELECT public.logistics_pickup_moments_koppel();
+
+-- ===== 2026-11-10c: rechten hulponderdelen ophaalmoment =====
+REVOKE EXECUTE ON FUNCTION public.logistics_pickup_regel() FROM authenticated;
+REVOKE EXECUTE ON FUNCTION public.logistics_pickup_moment_kies(uuid, date, timestamptz, text, numeric) FROM authenticated;
+
+-- ===== 2026-11-10d: karindeling snel en betrouwbaar bij productievolume =====
+-- Karindeling snel en betrouwbaar bij productievolume (schema 2026-11-10d)
+CREATE OR REPLACE FUNCTION public.logistics_product_maten(p_product_ids uuid[])
+RETURNS TABLE(product_id uuid, product_name text, plants_per_crate integer, fust_type_id uuid, fust_name text, fust_bron text,
+              fust_length_mm numeric, fust_width_mm numeric, fust_height_mm numeric,
+              lengte_bron text, breedte_bron text, hoogte_bron text,
+              plant_height_cm numeric, height_source text, weight_kg numeric,
+              pad_fust text, pad_artikel text, missing_reason text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+#variable_conflict use_column
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_product_maten');
+  IF p_product_ids IS NOT NULL AND cardinality(p_product_ids) > 2000 THEN
+    RAISE EXCEPTION 'Maximaal 2000 producten per aanvraag.' USING ERRCODE = '22023';
+  END IF;
+  RETURN QUERY
+  WITH fm AS MATERIALIZED (SELECT * FROM public.logistics_fust_maten()),
+  pr AS MATERIALIZED (
+    SELECT p.id, p.product, p.plants_per_crate, p.fust_type_id AS hand_fid, p.plant_height_cm AS hand_h, p.weight,
+           public.logistics_artikel_vbn(p.id) AS a
+      FROM public.products p
+     WHERE p_product_ids IS NULL OR p.id = ANY(p_product_ids)
+  ),
+  keuze AS (
+    SELECT pr.*,
+      (SELECT m.fust_type_id FROM fm m
+        WHERE (pr.a->>'vbn_package_code') ~ '^[0-9]+$'
+          AND (m.vbn_code = (pr.a->>'vbn_package_code')::int OR m.fust_key = 'vbn:' || (pr.a->>'vbn_package_code'))
+        ORDER BY ((m.length_mm IS NOT NULL)::int + (m.width_mm IS NOT NULL)::int + (m.height_mm IS NOT NULL)::int) DESC, m.fust_type_id
+        LIMIT 1) AS vbn_fid,
+      (SELECT f.id FROM public.fust_types f
+        WHERE nullif(pr.a->>'custom_package_id', '') IS NOT NULL AND f.custom_package_id = pr.a->>'custom_package_id'
+        ORDER BY f.created_at, f.id LIMIT 1) AS cp_fid
+      FROM pr
+  ),
+  k2 AS (
+    SELECT k.*, coalesce(k.hand_fid, k.vbn_fid, k.cp_fid) AS fid,
+      CASE WHEN k.hand_fid IS NOT NULL THEN 'handmatig' WHEN k.vbn_fid IS NOT NULL THEN 'vbn' WHEN k.cp_fid IS NOT NULL THEN 'floriday' END AS fbron
+      FROM keuze k
+  ),
+  maat AS (
+    SELECT k.*, m.name AS mname, m.pad AS mpad,
+      coalesce(m.length_mm, lx.length_mm) AS l, CASE WHEN m.length_mm IS NOT NULL THEN m.lengte_bron ELSE coalesce(lx.lengte_bron, 'onbekend') END AS lb,
+      coalesce(m.width_mm, wx.width_mm) AS w, CASE WHEN m.width_mm IS NOT NULL THEN m.breedte_bron ELSE coalesce(wx.breedte_bron, 'onbekend') END AS wb,
+      coalesce(m.height_mm, hx.height_mm) AS h, CASE WHEN m.height_mm IS NOT NULL THEN m.hoogte_bron ELSE coalesce(hx.hoogte_bron, 'onbekend') END AS hb
+      FROM k2 k
+      LEFT JOIN fm m ON m.fust_type_id = k.fid
+      LEFT JOIN LATERAL (SELECT m2.length_mm, m2.lengte_bron FROM fm m2 WHERE m.fust_key IS NOT NULL AND m2.fust_key = m.fust_key AND m2.length_mm IS NOT NULL ORDER BY m2.fust_type_id LIMIT 1) lx ON true
+      LEFT JOIN LATERAL (SELECT m2.width_mm, m2.breedte_bron FROM fm m2 WHERE m.fust_key IS NOT NULL AND m2.fust_key = m.fust_key AND m2.width_mm IS NOT NULL ORDER BY m2.fust_type_id LIMIT 1) wx ON true
+      LEFT JOIN LATERAL (SELECT m2.height_mm, m2.hoogte_bron FROM fm m2 WHERE m.fust_key IS NOT NULL AND m2.fust_key = m.fust_key AND m2.height_mm IS NOT NULL ORDER BY m2.fust_type_id LIMIT 1) hx ON true
+  ),
+  hoogte AS (
+    SELECT x.*,
+      public.logistics_pos_num(x.hand_h::text) AS hh,
+      public.logistics_pos_num(x.a->>'s15_cm') AS s15,
+      public.logistics_pos_num(x.a->>'s02_cm') AS s02,
+      (SELECT b.bron FROM public.logistics_gegevens_bron b
+        WHERE b.onderwerp = 'product' AND b.sleutel = x.id::text AND b.veld = 'plant_height_cm'
+          AND public.logistics_pos_num(b.waarde) = public.logistics_pos_num(x.hand_h::text) LIMIT 1) AS hand_bron
+      FROM maat x
+  )
+  SELECT h.id, h.product, h.plants_per_crate::int, h.fid, h.mname, h.fbron,
+    h.l, h.w, h.h, h.lb, h.wb, h.hb,
+    coalesce(h.hh, h.s15, h.s02),
+    CASE WHEN h.hh IS NOT NULL THEN coalesce(h.hand_bron, 'handmatig')
+         WHEN h.s15 IS NOT NULL THEN 'floricode_s15'
+         WHEN h.s02 IS NOT NULL THEN 'floricode_s02' END,
+    public.logistics_pos_num(regexp_replace(coalesce(h.weight::text, ''), '[^0-9.,]', '', 'g')),
+    coalesce(h.mpad, (SELECT fm.pad FROM fm LIMIT 1)), h.a->>'pad',
+    CASE
+      WHEN h.fid IS NULL AND h.a->>'vbn_package_code' IS NULL AND h.a->>'custom_package_id' IS NULL
+        THEN format('Bij "%s" is geen fustsoort bekend: kies de fustsoort bij het product in Voorraad.', h.product)
+      WHEN h.fid IS NULL
+        THEN format('Bij "%s" bestaat de fustsoort (VBN %s) niet in Voorraad → Fusten.', h.product, coalesce(h.a->>'vbn_package_code', h.a->>'custom_package_id'))
+      WHEN h.l IS NULL OR h.w IS NULL OR h.h IS NULL
+        THEN format('Fust %s heeft geen volledige maten in Floricode, Floriday of Voorraad → Fusten (ontbreekt: %s).', coalesce(h.mname, 'onbekend'),
+               array_to_string(array_remove(ARRAY[CASE WHEN h.l IS NULL THEN 'lengte' END, CASE WHEN h.w IS NULL THEN 'breedte' END, CASE WHEN h.h IS NULL THEN 'hoogte' END], NULL), ', '))
+      WHEN coalesce(h.hh, h.s15, h.s02) IS NULL
+        THEN format('Bij "%s" is de planthoogte inclusief pot onbekend (geen S15/S02 in Floricode of Floriday, niet handmatig ingevuld).', h.product)
+    END
+  FROM hoogte h;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_product_maten(uuid[]) TO authenticated, service_role;
+
+-- ===== Karindeling: tijdelijke fouten opnieuw proberen =====
+CREATE OR REPLACE FUNCTION public.logistics_plan_is_tijdelijk(p_text text)
+ RETURNS boolean LANGUAGE sql IMMUTABLE SET search_path TO 'public'
+AS $function$
+  SELECT coalesce(p_text, '') ~* '(statement timeout|canceling statement|niet afgesloten|claim niet afgerond|lock timeout|could not obtain lock|deadlock detected)'
+$function$;
+REVOKE EXECUTE ON FUNCTION public.logistics_plan_is_tijdelijk(text) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_plan_is_tijdelijk(text) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_plan_tijdelijk_wacht(p_attempts integer)
+ RETURNS interval LANGUAGE sql IMMUTABLE SET search_path TO 'public'
+AS $function$
+  SELECT make_interval(mins => (2 ^ (LEAST(5, GREATEST(1, coalesce(p_attempts, 1))) - 1))::int)
+$function$;
+REVOKE EXECUTE ON FUNCTION public.logistics_plan_tijdelijk_wacht(integer) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_plan_tijdelijk_wacht(integer) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_plan_tijdelijk_opnieuw(p_order_ids uuid[], p_reason text)
+ RETURNS uuid[] LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+-- Zet wachtrijregels met een tijdelijke fout terug met oplopende wachttijd.
+-- Geeft de orders terug die al het maximum aantal pogingen hadden (die worden echt geblokkeerd).
+DECLARE
+  v_max int := GREATEST(1, public.logistics_plan_setting('max_attempts', 5)::int);
+  v_op uuid[];
+  r record;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_plan_tijdelijk_opnieuw');
+  FOR r IN
+    UPDATE public.logistics_plan_queue q
+       SET status = 'pending', reason_code = 'tijdelijk', error = left(p_reason, 500),
+           claimed_at = NULL, next_attempt_at = now() + public.logistics_plan_tijdelijk_wacht(q.attempts),
+           updated_at = now()
+     WHERE q.order_id = ANY(p_order_ids) AND q.status IN ('pending', 'running') AND q.attempts < v_max
+    RETURNING q.order_id, q.attempts, q.next_attempt_at
+  LOOP
+    BEGIN
+      PERFORM public.logistics_trace_order_step(
+        r.order_id, 'stap:beladingindeling', 'karrenindeling opnieuw proberen', 'wachtend',
+        'tijdelijke fout, poging ' || r.attempts || ' van ' || v_max,
+        'De indeling liep tegen een tijdslimiet aan. Bestaande karren blijven staan. Volgende poging om '
+          || to_char(r.next_attempt_at AT TIME ZONE public.logistics_tz(), 'HH24:MI') || ' uur.',
+        'Karrenindeling', left(p_reason, 500), 'tijdelijk');
+    EXCEPTION WHEN OTHERS THEN
+      RAISE WARNING 'logistiek-engine: verloop niet vastgelegd voor order %: %', r.order_id, SQLERRM;
+    END;
+  END LOOP;
+  SELECT array_agg(q.order_id) INTO v_op FROM public.logistics_plan_queue q
+   WHERE q.order_id = ANY(p_order_ids) AND q.status IN ('pending', 'running') AND q.attempts >= v_max;
+  RETURN coalesce(v_op, ARRAY[]::uuid[]);
+END $function$;
+REVOKE EXECUTE ON FUNCTION public.logistics_plan_tijdelijk_opnieuw(uuid[], text) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_plan_tijdelijk_opnieuw(uuid[], text) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_plan_block(p_order_ids uuid[], p_reason text, p_details jsonb DEFAULT '{}'::jsonb)
+ RETURNS integer
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_user uuid;
+  o record;
+  v_count integer := 0;
+  v_code text;
+  v_details jsonb := COALESCE(p_details, '{}'::jsonb);
+  v_reason text := left(COALESCE(p_reason, 'belading onbekend'), 500);
+  v_buffer text;
+  v_subject_type text;
+  v_subject_id text;
+  v_result jsonb;
+  v_last jsonb;
+  v_members text[];
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_plan_block');
+  IF p_order_ids IS NULL OR array_length(p_order_ids, 1) IS NULL THEN
+    RETURN 0;
+  END IF;
+
+  -- Tijdelijke fout (time-out): eerst opnieuw proberen, pas na het maximum blokkeren.
+  IF public.logistics_plan_is_tijdelijk(p_reason) THEN
+    v_count := cardinality(p_order_ids);
+    p_order_ids := public.logistics_plan_tijdelijk_opnieuw(p_order_ids, v_reason);
+    IF cardinality(p_order_ids) = 0 THEN
+      RETURN v_count;
+    END IF;
+    v_reason := left(v_reason || ' (na ' || public.logistics_plan_setting('max_attempts', 5)::int || ' pogingen)', 500);
+    v_count := 0;
+  END IF;
+
+  v_user := COALESCE(
+    auth.uid(),
+    (SELECT user_id FROM public.logistics_strategies WHERE is_active ORDER BY updated_at DESC LIMIT 1),
+    (SELECT user_id FROM public.logistics_strategies ORDER BY updated_at DESC LIMIT 1)
+  );
+
+  v_code := public.logistics_block_reason_code(p_reason, v_details);
+  v_buffer := NULLIF(v_details ->> 'bufferId', '');
+
+  UPDATE public.logistics_plan_queue
+     SET status = 'geblokkeerd',
+         reason = v_reason,
+         reason_code = v_code,
+         error = v_reason,
+         claimed_at = NULL,
+         updated_at = now()
+   WHERE order_id = ANY(p_order_ids)
+     AND status IN ('pending', 'running');
+
+  FOR o IN
+    SELECT id, order_number FROM public.orders
+     WHERE id = ANY(p_order_ids) AND deleted_at IS NULL
+  LOOP
+    v_count := v_count + 1;
+
+    IF v_user IS NOT NULL AND o.order_number IS NOT NULL THEN
+      INSERT INTO public.logistics_events (
+        user_id, source_module, event_type, order_ref, payload, shadow,
+        status, processed_at, idempotency_key
+      ) VALUES (
+        v_user, 'logistiek-engine', 'plan.blocked', o.order_number,
+        jsonb_build_object('reason', p_reason, 'reasonCode', v_code, 'orderId', o.id) || v_details,
+        false, 'processed', now(),
+        'plan.blocked|' || o.id::text || '|' || v_code
+      )
+      ON CONFLICT DO NOTHING;
+    END IF;
+  END LOOP;
+
+  IF v_user IS NOT NULL THEN
+    SELECT array_agg(COALESCE(ord.order_number, ord.id::text) ORDER BY COALESCE(ord.order_number, ord.id::text))
+      INTO v_members
+      FROM public.orders ord
+     WHERE ord.id = ANY(p_order_ids) AND ord.deleted_at IS NULL;
+
+    IF v_buffer IS NOT NULL THEN
+      v_subject_type := 'buffer';
+      v_subject_id := v_buffer;
+    ELSE
+      v_subject_type := 'order';
+      v_subject_id := p_order_ids[1]::text;
+    END IF;
+
+    v_result := jsonb_build_object(
+      'blocked', true,
+      'reason_code', v_code,
+      'path', COALESCE(v_details ->> 'path', 'onbekend')
+    );
+
+    SELECT d.result INTO v_last
+      FROM public.logistics_decisions d
+     WHERE d.user_id = v_user
+       AND d.subject_type = v_subject_type
+       AND d.subject_id = v_subject_id
+       AND d.slot = 'beladingindeling'
+     ORDER BY d.created_at DESC
+     LIMIT 1;
+
+    IF v_last IS DISTINCT FROM v_result THEN
+      INSERT INTO public.logistics_decisions (
+        user_id, subject_type, subject_id, slot, result, explanation, input_snapshot
+      ) VALUES (
+        v_user, v_subject_type, v_subject_id, 'beladingindeling',
+        v_result,
+        left(COALESCE(p_reason, 'Belading onbekend'), 2000),
+        v_details || jsonb_build_object(
+          'members', to_jsonb(COALESCE(v_members, ARRAY[]::text[])),
+          'memberCount', COALESCE(array_length(v_members, 1), 0)
+        )
+      );
+    END IF;
+  END IF;
+
+  RETURN v_count;
+END;
+$function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_plan_close_claim(p_id uuid, p_reason text, p_reason_code text DEFAULT NULL::text)
+ RETURNS boolean
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE v_n int; v_order uuid;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_plan_close_claim');
+  IF public.logistics_plan_is_tijdelijk(p_reason) THEN
+    SELECT q.order_id INTO v_order FROM public.logistics_plan_queue q WHERE q.id = p_id AND q.status = 'running';
+    IF v_order IS NOT NULL AND cardinality(public.logistics_plan_tijdelijk_opnieuw(ARRAY[v_order], p_reason)) = 0 THEN
+      RETURN true;
+    END IF;
+  END IF;
+  UPDATE public.logistics_plan_queue q
+     SET status='geblokkeerd', reason=COALESCE(p_reason, q.reason), error=p_reason,
+         reason_code=COALESCE(p_reason_code, public.logistics_block_reason_code(p_reason, '{}'::jsonb)),
+         claimed_at=NULL, updated_at=now()
+   WHERE q.id = p_id AND q.status = 'running';
+  GET DIAGNOSTICS v_n = ROW_COUNT;
+  RETURN v_n > 0;
+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', 5)::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 THEN 'geblokkeerd' ELSE 'pending' END,
+           error = v_txt,
+           reason = CASE WHEN q.attempts >= v_max
+                         THEN v_txt || '; ' || q.attempts || ' keer achter elkaar, daarom geblokkeerd' ELSE q.reason END,
+           reason_code = 'claim_niet_afgerond',
+           claimed_at = NULL,
+           next_attempt_at = now() + public.logistics_plan_tijdelijk_wacht(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 ' || r.attempts || ' 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. Er volgt automatisch een nieuwe poging (' || r.attempts || ' van ' || v_max || ').'
+        END,
+        'Karrenindeling', v_txt, 'regel');
+    EXCEPTION WHEN OTHERS THEN
+      RAISE WARNING 'logistiek-engine: verloop niet vastgelegd voor order %: %', r.order_id, SQLERRM;
+    END;
+  END LOOP;
+  RETURN v_n;
+END $function$;
+
+-- ===== Gegevensblokkades automatisch opnieuw =====
+CREATE OR REPLACE FUNCTION public.logistics_plan_gegevens_codes()
+ RETURNS text[] LANGUAGE sql IMMUTABLE SET search_path TO 'public'
+AS $function$
+  SELECT ARRAY['belading_onbekend','belading_onvolledig','beladingsprofiel_ontbreekt','afmetingen_onbekend',
+               'afmetingen_plan_ongeldig','ladingdrager_onbekend','artikel_ontbreekt','belading_onwaarschijnlijk',
+               'karindeling_geblokkeerd']
+$function$;
+REVOKE EXECUTE ON FUNCTION public.logistics_plan_gegevens_codes() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_plan_gegevens_codes() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_plan_gegevens_opnieuw(p_order_ids uuid[], p_reden text)
+ RETURNS integer LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+-- Biedt alleen de geblokkeerde orders met een gegevensblokkade opnieuw aan. Per order een eigen poging.
+DECLARE v_id uuid; v_n int := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_plan_gegevens_opnieuw');
+  FOR v_id IN
+    SELECT DISTINCT q.order_id FROM public.logistics_plan_queue q
+     WHERE q.order_id = ANY(p_order_ids) AND q.status = 'geblokkeerd'
+       AND q.reason_code = ANY(public.logistics_plan_gegevens_codes())
+  LOOP
+    BEGIN
+      PERFORM public.logistics_plan_enqueue(v_id, p_reden);
+      v_n := v_n + 1;
+    EXCEPTION WHEN OTHERS THEN
+      PERFORM public.logistics_plan_fail_log('logistics_plan_gegevens_opnieuw', v_id, SQLSTATE, SQLERRM);
+    END;
+  END LOOP;
+  RETURN v_n;
+END $function$;
+REVOKE EXECUTE ON FUNCTION public.logistics_plan_gegevens_opnieuw(uuid[], text) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_plan_gegevens_opnieuw(uuid[], text) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_fust_maten_gewijzigd_trg()
+ RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE v_orders uuid[];
+BEGIN
+  BEGIN
+    IF NEW.length_mm IS NOT DISTINCT FROM OLD.length_mm AND NEW.width_mm IS NOT DISTINCT FROM OLD.width_mm
+       AND NEW.height_mm IS NOT DISTINCT FROM OLD.height_mm AND NEW.vbn_code IS NOT DISTINCT FROM OLD.vbn_code
+       AND NEW.custom_package_id IS NOT DISTINCT FROM OLD.custom_package_id AND NEW.fust_key IS NOT DISTINCT FROM OLD.fust_key THEN
+      RETURN NEW;
+    END IF;
+    WITH geblokkeerd AS MATERIALIZED (
+      SELECT DISTINCT q.order_id FROM public.logistics_plan_queue q
+       WHERE q.status = 'geblokkeerd' AND q.reason_code = ANY(public.logistics_plan_gegevens_codes())
+    ), prod AS MATERIALIZED (
+      SELECT DISTINCT oi.order_id, oi.product_id FROM public.order_items oi JOIN geblokkeerd g ON g.order_id = oi.order_id
+       WHERE oi.product_id IS NOT NULL
+    ), maten AS MATERIALIZED (
+      SELECT m.product_id, m.fust_type_id FROM public.logistics_product_maten((SELECT array_agg(DISTINCT product_id) FROM prod)) m
+       WHERE EXISTS (SELECT 1 FROM prod)
+    )
+    SELECT array_agg(DISTINCT p.order_id) INTO v_orders
+      FROM prod p LEFT JOIN maten m ON m.product_id = p.product_id
+      LEFT JOIN public.products pr ON pr.id = p.product_id
+     WHERE m.fust_type_id = NEW.id OR pr.fust_type_id = NEW.id;
+    IF v_orders IS NOT NULL THEN
+      PERFORM public.logistics_plan_gegevens_opnieuw(v_orders, 'fustmaten aangepast');
+    END IF;
+  EXCEPTION WHEN OTHERS THEN
+    RAISE WARNING 'logistiek-engine: opnieuw aanbieden na fustwijziging mislukt: %', SQLERRM;
+    BEGIN
+      PERFORM public.logistics_plan_fail_log('trg_logistics_fust_maten_gewijzigd', NULL, SQLSTATE, SQLERRM);
+    EXCEPTION WHEN OTHERS THEN
+      RAISE WARNING 'logistiek-engine: fout niet vastgelegd: %', SQLERRM;
+    END;
+  END;
+  RETURN NEW;
+END $function$;
+REVOKE EXECUTE ON FUNCTION public.logistics_fust_maten_gewijzigd_trg() FROM PUBLIC, anon, authenticated;
+DO $fs$ BEGIN
+  IF to_regclass('public.fust_types') IS NOT NULL THEN
+    EXECUTE 'DROP TRIGGER IF EXISTS trg_logistics_fust_maten_gewijzigd ON public.fust_types';
+    EXECUTE 'CREATE TRIGGER trg_logistics_fust_maten_gewijzigd AFTER UPDATE OF length_mm, width_mm, height_mm, vbn_code, custom_package_id, fust_key ON public.fust_types FOR EACH ROW EXECUTE FUNCTION public.logistics_fust_maten_gewijzigd_trg()';
+  ELSE
+    RAISE NOTICE 'logistiek-engine: trigger fustmaten overgeslagen (tabel fust_types van Voorraad ontbreekt)';
+  END IF;
+EXCEPTION WHEN undefined_column THEN
+  RAISE NOTICE 'logistiek-engine: trigger fustmaten overgeslagen: %', SQLERRM;
+END $fs$;
+
+CREATE OR REPLACE FUNCTION public.logistics_plan_products_trg()
+ RETURNS trigger
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE r record;
+BEGIN
+  IF NEW.plant_height_cm IS NOT DISTINCT FROM OLD.plant_height_cm
+     AND NEW.fust_type_id IS NOT DISTINCT FROM OLD.fust_type_id
+     AND NEW.plants_per_crate IS NOT DISTINCT FROM OLD.plants_per_crate
+     AND NEW.crates_per_layer IS NOT DISTINCT FROM OLD.crates_per_layer
+     AND NEW.layers_per_cart IS NOT DISTINCT FROM OLD.layers_per_cart
+     AND NEW.is_layer IS NOT DISTINCT FROM OLD.is_layer THEN
+    RETURN NEW;
+  END IF;
+
+  BEGIN
+    FOR r IN
+      SELECT DISTINCT o.id
+        FROM logistics_active.order_items oi
+        JOIN public.orders o ON o.id = oi.order_id
+       WHERE oi.product_id = NEW.id
+         AND o.deleted_at IS NULL
+         AND COALESCE(o.is_reservation, false) = false
+         AND o.plan_locked_at IS NULL
+         AND (o.delivery_date IS NULL OR public.logistics_order_date(o.delivery_date::text) >= (now() AT TIME ZONE coalesce(public.logistics_tz(), 'Europe/Amsterdam'))::date)
+    LOOP
+      BEGIN
+        PERFORM public.logistics_plan_enqueue(r.id, 'product');
+      EXCEPTION WHEN OTHERS THEN
+        PERFORM public.logistics_plan_fail_log('trg_logistics_plan_products', r.id, SQLSTATE, SQLERRM);
+      END;
+    END LOOP;
+  EXCEPTION WHEN OTHERS THEN
+    RAISE WARNING 'logistiek-engine: opnieuw aanbieden na productwijziging mislukt: %', SQLERRM;
+  END;
+
+  RETURN NEW;
+END;
+$function$;
+
+-- ===== Onderhoud in de minuutronde =====
+CREATE OR REPLACE FUNCTION public.logistics_plan_herstel_tijdelijk()
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+-- Eenmalig: orders die vóór deze versie geblokkeerd raakten door een time-out of een niet afgesloten ronde
+-- worden opnieuw aangeboden. Een tweede keer doet niets.
+DECLARE v_key text := 'herstel_tijdelijk_2026_11_10'; v_val text; v_n int := 0; v_id uuid;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_plan_herstel_tijdelijk');
+  SELECT value INTO v_val FROM public.logistics_plan_settings WHERE key = v_key;
+  IF v_val IS NOT NULL THEN
+    RETURN jsonb_build_object('gedaan', true, 'aantal', coalesce(nullif(v_val, '')::int, 0), 'nu', 0);
+  END IF;
+  FOR v_id IN
+    SELECT DISTINCT q.order_id FROM public.logistics_plan_queue q JOIN public.orders o ON o.id = q.order_id
+     WHERE q.status IN ('geblokkeerd', 'failed')
+       AND o.deleted_at IS NULL AND o.cancelled_at IS NULL
+       AND (q.reason_code = 'claim_niet_afgerond'
+            OR public.logistics_plan_is_tijdelijk(coalesce(q.error, '') || ' ' || coalesce(q.reason, '')))
+  LOOP
+    BEGIN
+      UPDATE public.logistics_plan_queue q
+         SET status = 'pending', attempts = 0, reason = 'automatisch opnieuw aangeboden na een time-out',
+             reason_code = NULL, error = NULL, claimed_at = NULL, next_attempt_at = now(), updated_at = now()
+       WHERE q.order_id = v_id AND q.status IN ('geblokkeerd', 'failed');
+      v_n := v_n + 1;
+    EXCEPTION WHEN OTHERS THEN
+      PERFORM public.logistics_plan_fail_log('logistics_plan_herstel_tijdelijk', v_id, SQLSTATE, SQLERRM);
+    END;
+  END LOOP;
+  INSERT INTO public.logistics_plan_settings(key, value, updated_at) VALUES (v_key, v_n::text, now())
+  ON CONFLICT (key) DO NOTHING;
+  RETURN jsonb_build_object('gedaan', true, 'aantal', v_n, 'nu', v_n);
+END $function$;
+REVOKE EXECUTE ON FUNCTION public.logistics_plan_herstel_tijdelijk() FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_plan_herstel_tijdelijk() TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_plan_gegevens_vangnet(p_force boolean DEFAULT false)
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+-- Hooguit elke 15 minuten: gegevensblokkade waarvan de gegevens na de blokkade zijn aangepast -> opnieuw.
+-- Meet meteen hoe lang het lezen van alle productmaten duurt.
+DECLARE v_last timestamptz; v_orders uuid[]; v_n int := 0; v_t timestamptz; v_ms int; v_cnt int;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_plan_gegevens_vangnet');
+  SELECT nullif(value, '')::timestamptz INTO v_last FROM public.logistics_plan_settings WHERE key = 'gegevens_vangnet_at';
+  IF NOT p_force AND v_last IS NOT NULL AND v_last > now() - interval '15 minutes' THEN
+    RETURN jsonb_build_object('overgeslagen', true, 'laatst', v_last);
+  END IF;
+  INSERT INTO public.logistics_plan_settings(key, value, updated_at) VALUES ('gegevens_vangnet_at', now()::text, now())
+  ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+
+  SELECT array_agg(DISTINCT q.order_id) INTO v_orders
+    FROM public.logistics_plan_queue q
+   WHERE q.status = 'geblokkeerd' AND q.reason_code = ANY(public.logistics_plan_gegevens_codes())
+     AND (EXISTS (SELECT 1 FROM public.order_items oi JOIN public.products p ON p.id = oi.product_id
+                   WHERE oi.order_id = q.order_id AND p.updated_at > q.updated_at)
+       OR EXISTS (SELECT 1 FROM public.order_items oi JOIN public.products p ON p.id = oi.product_id
+                   JOIN public.fust_types f ON f.id = p.fust_type_id
+                   WHERE oi.order_id = q.order_id AND f.updated_at > q.updated_at)
+       OR EXISTS (SELECT 1 FROM public.logistics_belading_bevestigingen b
+                   WHERE b.order_id = q.order_id AND b.created_at > q.updated_at)
+       OR (q.reason_code = 'artikel_ontbreekt'
+           AND NOT EXISTS (SELECT 1 FROM public.order_items oi WHERE oi.order_id = q.order_id AND oi.product_id IS NULL)));
+  IF v_orders IS NOT NULL THEN
+    v_n := public.logistics_plan_gegevens_opnieuw(v_orders, 'gegevens aangepast (controle minuutronde)');
+  END IF;
+
+  v_t := clock_timestamp();
+  BEGIN
+    SELECT count(*) INTO v_cnt FROM public.logistics_product_maten(NULL);
+    v_ms := (extract(epoch FROM clock_timestamp() - v_t) * 1000)::int;
+  EXCEPTION WHEN OTHERS THEN
+    v_ms := (extract(epoch FROM clock_timestamp() - v_t) * 1000)::int;
+    RAISE WARNING 'logistiek-engine: meting productmaten mislukt: %', SQLERRM;
+  END;
+  INSERT INTO public.logistics_plan_settings(key, value, updated_at) VALUES ('productmaten_ms', v_ms::text, now())
+  ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+  RETURN jsonb_build_object('opnieuw', v_n, 'productmatenMs', v_ms);
+END $function$;
+REVOKE EXECUTE ON FUNCTION public.logistics_plan_gegevens_vangnet(boolean) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_plan_gegevens_vangnet(boolean) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_karindeling_bewaking()
+ RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE v jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_karindeling_bewaking');
+  SELECT jsonb_build_object(
+    'achterstand', (SELECT count(DISTINCT q.order_id) FROM public.logistics_plan_queue q JOIN public.orders o ON o.id = q.order_id
+                     WHERE q.status IN ('pending', 'running') AND q.enqueued_at < now() - interval '10 minutes'
+                       AND o.deleted_at IS NULL),
+    'productmatenMs', (SELECT nullif(value, '')::int FROM public.logistics_plan_settings WHERE key = 'productmaten_ms'),
+    'productmatenOp', (SELECT updated_at FROM public.logistics_plan_settings WHERE key = 'productmaten_ms'),
+    'tijdelijkOpnieuw', (SELECT count(*) FROM public.logistics_plan_queue q WHERE q.status = 'pending' AND q.reason_code IN ('tijdelijk', 'claim_niet_afgerond')),
+    'herstelTijdelijk', (SELECT nullif(value, '')::int FROM public.logistics_plan_settings WHERE key = 'herstel_tijdelijk_2026_11_10')
+  ) INTO v;
+  RETURN v;
+END $function$;
+REVOKE EXECUTE ON FUNCTION public.logistics_karindeling_bewaking() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_karindeling_bewaking() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_karindeling_onderhoud()
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE v jsonb := '{}'::jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_karindeling_onderhoud');
+  BEGIN
+    v := v || jsonb_build_object('herstel', public.logistics_plan_herstel_tijdelijk());
+  EXCEPTION WHEN OTHERS THEN
+    v := v || jsonb_build_object('herstel', left(SQLERRM, 200));
+  END;
+  BEGIN
+    v := v || jsonb_build_object('vangnet', public.logistics_plan_gegevens_vangnet(false));
+  EXCEPTION WHEN OTHERS THEN
+    v := v || jsonb_build_object('vangnet', left(SQLERRM, 200));
+  END;
+  RETURN v;
+END $function$;
+REVOKE EXECUTE ON FUNCTION public.logistics_karindeling_onderhoud() FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_karindeling_onderhoud() TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_plan_finish(p_id uuid, p_error text DEFAULT NULL::text)
+ RETURNS void
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_max int := public.logistics_plan_setting('max_attempts', 5)::int;
+  v_attempts int;
+  v_order uuid;
+  v_text text;
+  v_class text;
+  v_next timestamptz;
+  v_min numeric;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_plan_finish');
+  SELECT order_id, attempts INTO v_order, v_attempts
+    FROM public.logistics_plan_queue WHERE id = p_id;
+
+  IF p_error IS NULL THEN
+    UPDATE public.logistics_plan_queue SET status='done', error=NULL, claimed_at=NULL, updated_at=now() WHERE id = p_id;
+    PERFORM public.logistics_trace_order_step(
+      v_order, 'stap:beladingindeling', 'karrenindeling afgerond', 'geslaagd',
+      'indeling klaar', NULL, 'Order picken', NULL, NULL);
+    BEGIN
+      PERFORM public.logistics_trace_progress_order(v_order::text);
+    EXCEPTION WHEN OTHERS THEN
+      NULL;
+    END;
+    RETURN;
+  END IF;
+
+  IF p_error = 'deadline' THEN
+    PERFORM public.logistics_plan_defer(p_id);
+    RETURN;
+  END IF;
+
+  v_text  := public.logistics_plan_error_text(p_error);
+  v_class := public.logistics_plan_error_class(p_error);
+
+  IF COALESCE(v_attempts,0) >= v_max THEN
+    UPDATE public.logistics_plan_queue SET status='failed', error=p_error, claimed_at=NULL, updated_at=now() WHERE id = p_id;
+    PERFORM public.logistics_trace_order_step(
+      v_order, 'stap:beladingindeling', 'karrenindeling mislukt', 'mislukt',
+      'gestopt na ' || COALESCE(v_attempts,0) || ' van ' || v_max || ' pogingen',
+      v_text || ' Dit ging ' || COALESCE(v_attempts,0) || ' keer achter elkaar mis; de engine probeert het niet meer vanzelf. Bestaande karren blijven staan. Los de oorzaak op en start de order opnieuw via de wachtrij.',
+      'Oorzaak oplossen en opnieuw aanmelden in de wachtrij', v_text, v_class);
+  ELSE
+    -- Tijdelijke fout (time-out, ronde niet afgesloten): oplopend 1, 2, 4, 8, 16 minuten.
+    v_min := CASE
+      WHEN public.logistics_plan_is_tijdelijk(p_error) THEN EXTRACT(epoch FROM public.logistics_plan_tijdelijk_wacht(v_attempts)) / 60
+      WHEN COALESCE(v_attempts,1) <= 1 THEN public.logistics_plan_setting('retry_1_min', 5)
+      WHEN v_attempts = 2 THEN public.logistics_plan_setting('retry_2_min', 15)
+      ELSE public.logistics_plan_setting('retry_3_min', 60) END;
+    v_next := now() + make_interval(mins => GREATEST(1, v_min)::int);
+    UPDATE public.logistics_plan_queue
+       SET status='pending', error=p_error, claimed_at=NULL, updated_at=now(),
+           next_attempt_at = v_next
+     WHERE id = p_id;
+    PERFORM public.logistics_trace_order_step(
+      v_order, 'stap:beladingindeling', 'karrenindeling opnieuw proberen', 'wachtend',
+      'nieuwe poging ingepland (poging ' || (COALESCE(v_attempts,0) + 1) || ' van ' || v_max || ')',
+      v_text || ' Bestaande karren blijven staan. Volgende poging om ' || to_char(v_next AT TIME ZONE public.logistics_tz(), 'HH24:MI') || ' uur.',
+      'Karrenindeling', v_text, v_class);
+  END IF;
+END;
+$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);
+
+  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);
+
+  -- Karindeling: eenmalig herstel na time-outs en (hooguit elke 15 min) vangnet voor gegevensblokkades.
+  v_t := clock_timestamp();
+  BEGIN
+    PERFORM set_config('statement_timeout', '10000', true);
+    v_result := v_result || jsonb_build_object('karindeling', public.logistics_karindeling_onderhoud());
+  EXCEPTION WHEN OTHERS THEN
+    v_err := true; v_result := v_result || jsonb_build_object('karindeling', left(SQLERRM, 200));
+  END;
+  v_result := v_result || jsonb_build_object('karindeling_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_samenvoegen()
+ RETURNS TABLE(onderdeel text, ok boolean, toelichting text)
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE f text;
+BEGIN
+  FOREACH f IN ARRAY ARRAY['logistics_order_is_backfill(uuid)', 'logistics_order_merge_key_v2(uuid)',
+      'logistics_order_mergeable(uuid)', 'logistics_merge_floriday_lines(uuid)', 'logistics_order_buffer_ref(uuid)',
+      'logistics_merge_herstel_voorbeeld()', 'logistics_merge_herstel_uitvoeren(text,integer)',
+      'logistics_merge_status()', 'logistics_trace_event(uuid,text,text,text)', 'logistics_schema_versie()',
+      'logistics_pickup_regel()', 'logistics_pickup_moment_kies(uuid,date,timestamp with time zone,text,numeric)',
+      'logistics_pickup_vul_voorbeeld()', 'logistics_pickup_vul_uitvoeren(integer)', 'logistics_pickup_status()',
+      'logistics_pickup_herwijs(uuid[],integer)', 'logistics_refresh_pickup_moments(integer)',
+      'logistics_plan_is_tijdelijk(text)', 'logistics_plan_tijdelijk_wacht(integer)',
+      'logistics_plan_tijdelijk_opnieuw(uuid[],text)', 'logistics_plan_gegevens_codes()',
+      'logistics_plan_gegevens_opnieuw(uuid[],text)', 'logistics_plan_herstel_tijdelijk()',
+      'logistics_plan_gegevens_vangnet(boolean)', 'logistics_karindeling_bewaking()',
+      'logistics_karindeling_onderhoud()', 'logistics_fust_maten_gewijzigd_trg()'] LOOP
+    onderdeel := 'functie ' || f;
+    ok := to_regprocedure('public.' || f) IS NOT NULL;
+    toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: werk de Engine bij via Supabase bijwerken' END;
+    RETURN NEXT;
+  END LOOP;
+  onderdeel := 'tabel logistics_merge_herstel_log';
+  ok := to_regclass('public.logistics_merge_herstel_log') IS NOT NULL;
+  toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: werk de Engine bij via Supabase bijwerken' END;
+  RETURN NEXT;
+  onderdeel := 'kolom logistics_pickup_moments.carrier_id';
+  ok := EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema = 'public'
+                  AND table_name = 'logistics_pickup_moments' AND column_name = 'carrier_id');
+  toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: werk de Engine bij via Supabase bijwerken' END;
+  RETURN NEXT;
+  onderdeel := 'trigger ophaalmoment op orders';
+  ok := EXISTS (SELECT 1 FROM pg_trigger WHERE tgname = 'trg_logistics_orders_zpickup_moment');
+  toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: werk de Engine bij via Supabase bijwerken' END;
+  RETURN NEXT;
+  onderdeel := 'trigger fustmaten gewijzigd';
+  ok := EXISTS (SELECT 1 FROM pg_trigger WHERE tgname = 'trg_logistics_fust_maten_gewijzigd');
+  toelichting := CASE WHEN ok THEN 'aanwezig' ELSE 'ontbreekt: werk de Engine bij via Supabase bijwerken' END;
+  RETURN NEXT;
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_schema_versie()
+ RETURNS text LANGUAGE sql IMMUTABLE SET search_path TO 'public'
+AS $function$ SELECT '2026-11-10d'::text $function$;
+-- ===== 2026-11-10d: tijdbudget planstatus pickscherm =====
+CREATE OR REPLACE FUNCTION public.logistics_refresh_plan_state(p_limit integer DEFAULT 500)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+-- Per pickwachtrijregel wordt de planstatus opnieuw bepaald. Dat kost per regel enkele honderden ms,
+-- daarom geldt een tijdbudget van 2 s per ronde; de volgende ronde gaat verder waar deze stopte.
+declare rec record; v jsonb; v_ref text; v_updated integer := 0; v_checked integer := 0;
+  v_start timestamptz := clock_timestamp(); v_cursor timestamptz; v_last timestamptz; v_klaar boolean := true;
+begin
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_refresh_plan_state');
+  SELECT nullif(value->>'cursor', '')::timestamptz INTO v_cursor FROM public.logistics_tick_state WHERE key = 'refresh_plan_state_cursor';
+  for rec in
+    select q.id, q.payload, q.order_number, q.document_number, q.created_at
+      from public.pick_queue q
+     where q.cancelled_at is null and q.completed_at is null
+       and (v_cursor is null or q.created_at < v_cursor)
+     order by q.created_at desc
+     limit greatest(coalesce(p_limit, 500), 1)
+  loop
+    if clock_timestamp() - v_start > interval '2 seconds' then
+      v_klaar := false;
+      exit;
+    end if;
+    v_last := rec.created_at;
+    v_checked := v_checked + 1;
+    v_ref := coalesce(nullif(rec.payload->>'orderRef', ''), rec.order_number, rec.document_number);
+    if v_ref is null then continue; end if;
+    v := public.logistics_plan_state_for(v_ref);
+    update public.pick_queue q
+       set payload = coalesce(q.payload, '{}'::jsonb) || jsonb_build_object(
+             'planState', v->>'planState',
+             'planProgress', v->'planProgress',
+             'planStateSince', v->>'planStateSince',
+             'cartPlanReady', coalesce((v->>'cartPlanReady')::boolean, false),
+             'cartPlanReleased', coalesce((v->>'cartPlanReleased')::boolean, false),
+             'cartPlanReason', v->>'cartPlanReason')
+     where q.id = rec.id
+       and coalesce(q.payload->>'planState', '') is distinct from coalesce(v->>'planState', '');
+    if found then v_updated := v_updated + 1; end if;
+  end loop;
+  begin
+    INSERT INTO public.logistics_tick_state(key, value, updated_at)
+    VALUES ('refresh_plan_state_cursor', jsonb_build_object('cursor', CASE WHEN v_klaar THEN NULL ELSE v_last END), now())
+    ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+  exception when others then
+    raise warning 'logistiek-engine: voortgang planstatus niet opgeslagen: %', SQLERRM;
+  end;
+  return jsonb_build_object('updated', v_updated, 'gecontroleerd', v_checked, 'klaar', v_klaar);
+end;
+$function$;
+CREATE OR REPLACE FUNCTION public.logistics_refresh_plan_state_als_nodig()
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE v_wm timestamptz; v_prev timestamptz; v_at timestamptz; v_res jsonb; v_bezig boolean;
+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';
+  SELECT (value->>'cursor') IS NOT NULL INTO v_bezig FROM public.logistics_tick_state WHERE key = 'refresh_plan_state_cursor';
+  IF NOT coalesce(v_bezig, false) AND 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 $function$;