@flowselections/logistiek-engine 1.0.206 → 1.0.211

package/db/schema/logistiek-engine.sql

@@ -35824,4 +35824,898 @@ RETURNS TABLE(punt text, ok boolean, uitleg text) LANGUAGE sql STABLE SECURITY D
   UNION ALL SELECT 'quarantaine kar-nummering', position('quarantined_at IS NULL' IN pg_get_functiondef('public.logistics_order_unit_carts_core(uuid[])'::regprocedure)) > 0, 'Karren van een order via actieve regels'
   UNION ALL SELECT 'quarantaine te hoog', position('quarantined_at IS NULL' IN pg_get_functiondef('public.logistics_order_te_hoge_karren(uuid[])'::regprocedure)) > 0, 'Te hoog alleen op actieve regels'
 $$;
-GRANT EXECUTE ON FUNCTION public.logistics_install_check_205() TO authenticated, service_role;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_205() TO authenticated, service_role;
+-- ============================================================================
+-- 1.0.207 productoordeel belading zonder tijdelijke tabel (0A000-herstel)
+-- ============================================================================
+CREATE OR REPLACE FUNCTION public.logistics_product_oordeel_belading(p_regels jsonb)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE e jsonb; gj jsonb; gmap jsonb := '{}'::jsonb; c record; v_code text; v_eigen text; ids uuid[]; uit jsonb := '[]'::jsonb;
+  ls int; fh numeric; ph numeric; cpl numeric; lpc numeric; ppc numeric; laag numeric; naam text; v_prod text;
+  blok text[]; waar text[]; mist text[]; hmist text[]; v_pid uuid; v_oordeel text; v_tekst text; v_heeft_kol boolean;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_product_oordeel_belading');
+  IF p_regels IS NULL OR jsonb_typeof(p_regels) <> 'array' THEN RAISE EXCEPTION 'p_regels moet een lijst zijn.' USING ERRCODE = '22023'; END IF;
+  IF jsonb_array_length(p_regels) > 1000 THEN
+    RAISE EXCEPTION 'Maximaal 1000 regels per aanroep (ontvangen: %).', jsonb_array_length(p_regels) USING ERRCODE = '22023';
+  END IF;
+  SELECT array_agg(DISTINCT (x->>'product_id')::uuid) INTO ids FROM jsonb_array_elements(p_regels) x
+   WHERE nullif(btrim(x->>'product_id'), '') ~* '^[0-9a-f-]{36}$';
+  IF ids IS NOT NULL THEN
+    SELECT coalesce(jsonb_object_agg(g.product_id::text, to_jsonb(g)), '{}'::jsonb) INTO gmap
+      FROM public.logistics_data_gereedheid(ids) g;
+  END IF;
+  -- Eigen ladingdrager van het product, alleen als die kolom in deze Shell bestaat; geen standaard.
+  SELECT EXISTS (SELECT 1 FROM pg_attribute WHERE attrelid = to_regclass('public.products') AND attname = 'load_carrier_type' AND NOT attisdropped) INTO v_heeft_kol;
+
+  FOR e IN SELECT x FROM jsonb_array_elements(p_regels) x LOOP
+    blok := '{}'; waar := '{}'; mist := '{}'; hmist := '{}'; c := NULL; v_eigen := NULL;
+    v_pid := CASE WHEN nullif(btrim(e->>'product_id'), '') ~* '^[0-9a-f-]{36}$' THEN (e->>'product_id')::uuid END;
+    gj := CASE WHEN v_pid IS NULL THEN NULL ELSE gmap->(v_pid::text) END;
+    IF gj IS NULL THEN
+      uit := uit || jsonb_build_array(jsonb_build_object('product_id', v_pid, 'oordeel', 'mist_gegevens', 'tekst', 'product onbekend',
+        'regels', jsonb_build_array('Product onbekend.')));
+      CONTINUE;
+    END IF;
+    v_prod := coalesce(gj->>'product', 'Product');
+    v_code := nullif(btrim(e->>'carrier_code'), '');
+    IF v_code IS NULL AND v_heeft_kol THEN
+      EXECUTE 'SELECT nullif(btrim(load_carrier_type::text), '''') FROM public.products WHERE id = $1' INTO v_eigen USING v_pid;
+      v_code := v_eigen;
+    END IF;
+    IF v_code IS NOT NULL THEN
+      SELECT t.code, t.name, t.layer_length_cm, t.layer_width_cm, t.max_height_cm, t.max_crates_per_layer, t.layers_per_carrier INTO c
+        FROM public.load_carrier_types t WHERE t.is_active AND t.code = v_code LIMIT 1;
+    END IF;
+    naam := coalesce(c.name, c.code, v_code, 'de ladingdrager');
+    ppc := nullif(e->>'plants_per_crate', '')::numeric;
+    cpl := nullif(e->>'crates_per_layer', '')::numeric;
+    lpc := nullif(e->>'layers_per_cart', '')::numeric;
+    IF coalesce(ppc, 0) <= 0 THEN mist := mist || 'planten per fust'::text; END IF;
+    IF coalesce(cpl, 0) <= 0 THEN mist := mist || 'fusten per laag'::text; END IF;
+    IF coalesce(lpc, 0) <= 0 THEN mist := mist || 'lagen per kar'::text; END IF;
+    IF v_code IS NULL THEN
+      mist := mist || 'ladingdrager'::text;
+    ELSIF c.code IS NULL THEN
+      blok := blok || format('ladingdrager %s staat niet in Beheer', v_code);
+    ELSE
+      fh := nullif(gj->'velden'->'fust_height_mm'->>'waarde', '')::numeric / 10.0;
+      ph := nullif(gj->'velden'->'plant_height_cm'->>'waarde', '')::numeric;
+      ls := public.logistics_max_fusten_per_laag(c.layer_length_cm, c.layer_width_cm,
+              nullif(gj->'velden'->'fust_length_mm'->>'waarde', '')::numeric / 10.0, nullif(gj->'velden'->'fust_width_mm'->>'waarde', '')::numeric / 10.0);
+      IF coalesce(lpc,0) > 0 AND coalesce(fh,0) > 0 AND coalesce(ph,0) > 0 AND coalesce(c.max_height_cm,0) > 0 THEN
+        laag := greatest(fh, ph);
+        IF lpc * laag > c.max_height_cm + 1e-9 THEN
+          blok := blok || format('%s lagen × %s cm = %s cm, terwijl %s %s cm hoog is; er passen maximaal %s lagen',
+            lpc, trim_scale(round(laag,1)), trim_scale(round(lpc*laag,1)), naam, trim_scale(round(c.max_height_cm::numeric,1)), floor(c.max_height_cm / laag));
+        END IF;
+      ELSE
+        IF coalesce(fh,0) <= 0 THEN hmist := hmist || 'fusthoogte'::text; END IF;
+        IF coalesce(ph,0) <= 0 THEN hmist := hmist || 'planthoogte'::text; END IF;
+        IF coalesce(c.max_height_cm,0) <= 0 THEN hmist := hmist || ('hoogte van ' || naam); END IF;
+      END IF;
+      IF ls IS NOT NULL AND coalesce(cpl,0) > ls THEN
+        blok := blok || format('%s fust per laag, maar op een laag van %s passen er maximaal %s', cpl, naam, ls);
+      END IF;
+      IF coalesce(c.max_crates_per_layer,0) > 0 AND coalesce(cpl,0) > c.max_crates_per_layer THEN
+        blok := blok || format('%s fust per laag, maar %s staat maximaal %s fust per laag toe', cpl, naam, c.max_crates_per_layer);
+      END IF;
+      IF cardinality(blok) = 0 AND cardinality(hmist) > 0 AND coalesce(c.layers_per_carrier,0) > 0 AND coalesce(lpc,0) > c.layers_per_carrier THEN
+        waar := waar || format('%s lagen opgegeven, standaard %s; niet te controleren omdat de %s ontbreekt', lpc, c.layers_per_carrier, array_to_string(hmist, ', '));
+      END IF;
+    END IF;
+    IF coalesce(gj->'ontbrekend', '[]'::jsonb) ? 'weight' THEN waar := waar || 'gewicht per fust ontbreekt'::text; END IF;
+    IF cardinality(blok) > 0 THEN
+      v_oordeel := 'onmogelijk'; v_tekst := format('%s past niet op %s.', v_prod, naam);
+    ELSIF cardinality(mist) > 0 THEN
+      v_oordeel := 'mist_gegevens'; v_tekst := format('%s: %s ontbreekt.', v_prod, array_to_string(mist, ', '));
+    ELSIF cardinality(waar) > 0 THEN
+      v_oordeel := 'waarschuwing'; v_tekst := format('%s: belading mogelijk, met waarschuwing.', v_prod);
+    ELSE
+      v_oordeel := 'compleet'; v_tekst := format('%s: belading past.', v_prod);
+    END IF;
+    uit := uit || jsonb_build_array(jsonb_build_object('product_id', v_pid, 'oordeel', v_oordeel, 'tekst', v_tekst,
+      'regels', to_jsonb(ARRAY(SELECT upper(left(z,1)) || substr(z,2) || '.' FROM unnest(blok || mist || waar) z))));
+  END LOOP;
+  RETURN uit;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_product_oordeel_belading(jsonb) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_207()
+RETURNS TABLE(punt text, ok boolean, uitleg text) LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_ok boolean := true; v_fout text := 'aanroep zonder fout'; v_cnt int;
+BEGIN
+  SELECT count(*) INTO v_cnt FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace
+   WHERE n.nspname = 'public' AND p.proname LIKE 'logistics%' AND p.provolatile <> 'v' AND p.prosrc ~* 'create\s+temp';
+  punt := 'geen tijdelijke tabel in niet-volatiele functie'; ok := v_cnt = 0; uitleg := format('%s functie(s) met CREATE TEMP', v_cnt); RETURN NEXT;
+  BEGIN
+    PERFORM public.logistics_product_oordeel_belading('[{"product_id":""}]'::jsonb);
+  EXCEPTION WHEN SQLSTATE '0A000' THEN v_ok := false; v_fout := SQLERRM;
+            WHEN OTHERS THEN v_fout := 'aanroep geweigerd door toegangscontrole of andere fout: ' || SQLERRM;
+  END;
+  punt := 'productoordeel belading aanroepbaar'; ok := v_ok; uitleg := v_fout; RETURN NEXT;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_207() TO authenticated, service_role;
+CREATE OR REPLACE FUNCTION public.logistics_product_oordeel_belading(p_regels jsonb)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE e jsonb; gj jsonb; gmap jsonb := '{}'::jsonb; c record; v_code text; v_eigen text; ids uuid[]; uit jsonb := '[]'::jsonb;
+  ls int; fh numeric; ph numeric; cpl numeric; lpc numeric; ppc numeric; laag numeric; naam text; v_prod text;
+  blok text[]; waar text[]; mist text[]; hmist text[]; v_pid uuid; v_oordeel text; v_tekst text; v_heeft_kol boolean;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_product_oordeel_belading');
+  IF p_regels IS NULL OR jsonb_typeof(p_regels) <> 'array' THEN RAISE EXCEPTION 'p_regels moet een lijst zijn.' USING ERRCODE = '22023'; END IF;
+  IF jsonb_array_length(p_regels) > 1000 THEN
+    RAISE EXCEPTION 'Maximaal 1000 regels per aanroep (ontvangen: %).', jsonb_array_length(p_regels) USING ERRCODE = '22023';
+  END IF;
+  SELECT array_agg(DISTINCT (x->>'product_id')::uuid) INTO ids FROM jsonb_array_elements(p_regels) x
+   WHERE nullif(btrim(x->>'product_id'), '') ~* '^[0-9a-f-]{36}$';
+  IF ids IS NOT NULL THEN
+    SELECT coalesce(jsonb_object_agg(g.product_id::text, to_jsonb(g)), '{}'::jsonb) INTO gmap
+      FROM public.logistics_data_gereedheid(ids) g;
+  END IF;
+  SELECT EXISTS (SELECT 1 FROM pg_attribute WHERE attrelid = to_regclass('public.products') AND attname = 'load_carrier_type' AND NOT attisdropped) INTO v_heeft_kol;
+
+  FOR e IN SELECT x FROM jsonb_array_elements(p_regels) x LOOP
+    blok := '{}'; waar := '{}'; mist := '{}'; hmist := '{}'; v_eigen := NULL;
+    v_pid := CASE WHEN nullif(btrim(e->>'product_id'), '') ~* '^[0-9a-f-]{36}$' THEN (e->>'product_id')::uuid END;
+    gj := CASE WHEN v_pid IS NULL THEN NULL ELSE gmap->(v_pid::text) END;
+    IF gj IS NULL THEN
+      uit := uit || jsonb_build_array(jsonb_build_object('product_id', v_pid, 'oordeel', 'mist_gegevens', 'tekst', 'product onbekend',
+        'regels', jsonb_build_array('Product onbekend.')));
+      CONTINUE;
+    END IF;
+    v_prod := coalesce(gj->>'product', 'Product');
+    v_code := nullif(btrim(e->>'carrier_code'), '');
+    IF v_code IS NULL AND v_heeft_kol THEN
+      EXECUTE 'SELECT nullif(btrim(load_carrier_type::text), '''') FROM public.products WHERE id = $1' INTO v_eigen USING v_pid;
+      v_code := v_eigen;
+    END IF;
+    SELECT t.code, t.name, t.layer_length_cm, t.layer_width_cm, t.max_height_cm, t.max_crates_per_layer, t.layers_per_carrier INTO c
+      FROM public.load_carrier_types t WHERE t.is_active AND t.code = v_code LIMIT 1;
+    naam := coalesce(c.name, c.code, v_code, 'de ladingdrager');
+    ppc := nullif(e->>'plants_per_crate', '')::numeric;
+    cpl := nullif(e->>'crates_per_layer', '')::numeric;
+    lpc := nullif(e->>'layers_per_cart', '')::numeric;
+    IF coalesce(ppc, 0) <= 0 THEN mist := mist || 'planten per fust'::text; END IF;
+    IF coalesce(cpl, 0) <= 0 THEN mist := mist || 'fusten per laag'::text; END IF;
+    IF coalesce(lpc, 0) <= 0 THEN mist := mist || 'lagen per kar'::text; END IF;
+    IF v_code IS NULL THEN
+      mist := mist || 'ladingdrager'::text;
+    ELSIF c.code IS NULL THEN
+      blok := blok || format('ladingdrager %s staat niet in Beheer', v_code);
+    ELSE
+      fh := nullif(gj->'velden'->'fust_height_mm'->>'waarde', '')::numeric / 10.0;
+      ph := nullif(gj->'velden'->'plant_height_cm'->>'waarde', '')::numeric;
+      ls := public.logistics_max_fusten_per_laag(c.layer_length_cm, c.layer_width_cm,
+              nullif(gj->'velden'->'fust_length_mm'->>'waarde', '')::numeric / 10.0, nullif(gj->'velden'->'fust_width_mm'->>'waarde', '')::numeric / 10.0);
+      IF coalesce(lpc,0) > 0 AND coalesce(fh,0) > 0 AND coalesce(ph,0) > 0 AND coalesce(c.max_height_cm,0) > 0 THEN
+        laag := greatest(fh, ph);
+        IF lpc * laag > c.max_height_cm + 1e-9 THEN
+          blok := blok || format('%s lagen × %s cm = %s cm, terwijl %s %s cm hoog is; er passen maximaal %s lagen',
+            lpc, trim_scale(round(laag,1)), trim_scale(round(lpc*laag,1)), naam, trim_scale(round(c.max_height_cm::numeric,1)), floor(c.max_height_cm / laag));
+        END IF;
+      ELSE
+        IF coalesce(fh,0) <= 0 THEN hmist := hmist || 'fusthoogte'::text; END IF;
+        IF coalesce(ph,0) <= 0 THEN hmist := hmist || 'planthoogte'::text; END IF;
+        IF coalesce(c.max_height_cm,0) <= 0 THEN hmist := hmist || ('hoogte van ' || naam); END IF;
+      END IF;
+      IF ls IS NOT NULL AND coalesce(cpl,0) > ls THEN
+        blok := blok || format('%s fust per laag, maar op een laag van %s passen er maximaal %s', cpl, naam, ls);
+      END IF;
+      IF coalesce(c.max_crates_per_layer,0) > 0 AND coalesce(cpl,0) > c.max_crates_per_layer THEN
+        blok := blok || format('%s fust per laag, maar %s staat maximaal %s fust per laag toe', cpl, naam, c.max_crates_per_layer);
+      END IF;
+      IF cardinality(blok) = 0 AND cardinality(hmist) > 0 AND coalesce(c.layers_per_carrier,0) > 0 AND coalesce(lpc,0) > c.layers_per_carrier THEN
+        waar := waar || format('%s lagen opgegeven, standaard %s; niet te controleren omdat de %s ontbreekt', lpc, c.layers_per_carrier, array_to_string(hmist, ', '));
+      END IF;
+    END IF;
+    IF coalesce(gj->'ontbrekend', '[]'::jsonb) ? 'weight' THEN waar := waar || 'gewicht per fust ontbreekt'::text; END IF;
+    IF cardinality(blok) > 0 THEN
+      v_oordeel := 'onmogelijk'; v_tekst := format('%s past niet op %s.', v_prod, naam);
+    ELSIF cardinality(mist) > 0 THEN
+      v_oordeel := 'mist_gegevens'; v_tekst := format('%s: %s ontbreekt.', v_prod, array_to_string(mist, ', '));
+    ELSIF cardinality(waar) > 0 THEN
+      v_oordeel := 'waarschuwing'; v_tekst := format('%s: belading mogelijk, met waarschuwing.', v_prod);
+    ELSE
+      v_oordeel := 'compleet'; v_tekst := format('%s: belading past.', v_prod);
+    END IF;
+    uit := uit || jsonb_build_array(jsonb_build_object('product_id', v_pid, 'oordeel', v_oordeel, 'tekst', v_tekst,
+      'regels', to_jsonb(ARRAY(SELECT upper(left(z,1)) || substr(z,2) || '.' FROM unnest(blok || mist || waar) z))));
+  END LOOP;
+  RETURN uit;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_product_oordeel_belading(jsonb) TO authenticated, service_role;
+CREATE OR REPLACE FUNCTION public.logistics_install_check_207()
+RETURNS TABLE(punt text, ok boolean, uitleg text) LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_ok boolean := true; v_fout text := 'aanroep zonder fout'; v_cnt int; v_namen text;
+BEGIN
+  SELECT count(*), string_agg(p.proname, ', ') INTO v_cnt, v_namen FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace
+   WHERE n.nspname = 'public' AND p.proname LIKE 'logistics%' AND p.proname NOT LIKE 'logistics_install_check%'
+     AND p.provolatile <> 'v' AND p.prosrc ~* 'create\s+temp';
+  punt := 'geen tijdelijke tabel in niet-volatiele functie'; ok := v_cnt = 0;
+  uitleg := CASE WHEN v_cnt = 0 THEN 'geen' ELSE v_namen END; RETURN NEXT;
+  BEGIN
+    PERFORM public.logistics_product_oordeel_belading('[{"product_id":""}]'::jsonb);
+  EXCEPTION WHEN SQLSTATE '0A000' THEN v_ok := false; v_fout := SQLERRM;
+            WHEN OTHERS THEN v_fout := 'aanroep geweigerd door toegangscontrole of andere fout: ' || SQLERRM;
+  END;
+  punt := 'productoordeel belading aanroepbaar'; ok := v_ok; uitleg := v_fout; RETURN NEXT;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_207() TO authenticated, service_role;
+
+-- =====================================================================
+-- 1.0.208 — Floriday-vulgraad per kar, karTekst, ladingdrager uit hoofdverpakking,
+-- oordeel fysiek vóór mist_gegevens, snellere pickwachtrij, verouderde karren (quarantaine).
+-- Additief en idempotent; geen REVOKE/DROP.
+-- =====================================================================
+
+DO $do$
+BEGIN
+  IF to_regclass('public.logistics_floriday_carrier_map') IS NULL THEN RETURN; END IF;
+  IF NOT EXISTS (
+    SELECT 1 FROM pg_index i JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+     WHERE i.indrelid = 'public.logistics_floriday_carrier_map'::regclass AND i.indisunique
+       AND i.indnatts = 1 AND a.attname = 'floriday_code') THEN
+    BEGIN
+      CREATE UNIQUE INDEX IF NOT EXISTS logistics_floriday_carrier_map_code_uq ON public.logistics_floriday_carrier_map (floriday_code);
+    EXCEPTION WHEN unique_violation THEN
+      RAISE NOTICE 'logistiek-engine: dubbele Floriday-codes in de vertaaltabel; install_check meldt welke.';
+    END;
+  END IF;
+END $do$;
+
+DO $do$
+BEGIN
+  IF to_regclass('public.logistics_floriday_carrier_map') IS NULL THEN RETURN; END IF;
+  INSERT INTO public.logistics_floriday_carrier_map (floriday_code, carrier_code)
+  SELECT v.f, v.c FROM (VALUES
+    ('DANISH_TROLLEY','danish_container'), ('DANISH_TROLLEY_NON_CC_RFID','danish_container'),
+    ('DANISH_TROLLEY_WATER_TRAY','danish_container'), ('ONE_THIRD_DANISH_TROLLEY','danish_container'),
+    ('AUCTION_TROLLEY','trolley'),
+    ('EURO_TROLLEY','euro_rolcontainer'), ('WATERING_CONTAINER','euro_rolcontainer'),
+    ('EURO_PALLET','euro_pallet'), ('HT_EURO_PALLET','euro_pallet'),
+    ('PALLET','pallet'), ('BLOCK_PALLET','pallet'), ('IFCO_PALLET','pallet'),
+    ('CHEP_PALLET_BLUE','pallet'), ('CHEP_PALLET_RED','pallet'),
+    ('NONE','loose')) v(f, c)
+  WHERE NOT EXISTS (SELECT 1 FROM public.logistics_floriday_carrier_map m WHERE upper(m.floriday_code) = v.f);
+END $do$;
+
+CREATE OR REPLACE FUNCTION public.logistics_ladingdrager_resolve(p_code text)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v text := nullif(btrim(p_code), ''); n int; m text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_ladingdrager_resolve');
+  IF v IS NULL OR upper(v) = 'NONE' THEN
+    RETURN jsonb_build_object('code', NULL, 'invoer', v, 'bron', NULL, 'fout', 'ladingdrager ontbreekt');
+  END IF;
+  IF EXISTS (SELECT 1 FROM public.load_carrier_types t WHERE t.is_active AND t.code = v) THEN
+    RETURN jsonb_build_object('code', v, 'invoer', v, 'bron', 'beheer', 'fout', NULL);
+  END IF;
+  IF to_regclass('public.logistics_floriday_carrier_map') IS NULL THEN
+    RETURN jsonb_build_object('code', NULL, 'invoer', v, 'bron', NULL, 'fout', format('ladingdrager %s onbekend in Beheer', v));
+  END IF;
+  SELECT count(DISTINCT c.carrier_code), min(c.carrier_code) INTO n, m
+    FROM public.logistics_floriday_carrier_map c WHERE upper(c.floriday_code) = upper(v);
+  IF coalesce(n, 0) = 0 THEN
+    RETURN jsonb_build_object('code', NULL, 'invoer', v, 'bron', NULL, 'fout', format('ladingdrager %s onbekend in Beheer', v));
+  ELSIF n > 1 THEN
+    RETURN jsonb_build_object('code', NULL, 'invoer', v, 'bron', 'floriday', 'fout', format('ladingdrager niet eenduidig (%s)', v));
+  ELSIF m = 'loose' THEN
+    RETURN jsonb_build_object('code', NULL, 'invoer', v, 'bron', 'floriday', 'fout', 'ladingdrager ontbreekt');
+  ELSIF NOT EXISTS (SELECT 1 FROM public.load_carrier_types t WHERE t.is_active AND t.code = m) THEN
+    RETURN jsonb_build_object('code', NULL, 'invoer', v, 'bron', 'floriday', 'fout', format('ladingdrager %s onbekend in Beheer', v));
+  END IF;
+  RETURN jsonb_build_object('code', m, 'invoer', v, 'bron', 'floriday', 'fout', NULL);
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_ladingdrager_resolve(text) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_product_hoofdverpakking(p_product_id uuid)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_lc text; v_found boolean := false; v_heeft_lc boolean;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_product_hoofdverpakking');
+  IF to_regclass('public.product_packings') IS NULL THEN RETURN NULL; END IF;
+  SELECT EXISTS (SELECT 1 FROM pg_attribute WHERE attrelid = 'public.product_packings'::regclass AND attname = 'load_carrier' AND NOT attisdropped) INTO v_heeft_lc;
+  IF v_heeft_lc THEN
+    EXECUTE 'SELECT true, nullif(btrim(load_carrier::text), '''') FROM public.product_packings WHERE product_id = $1 AND is_primary
+              ORDER BY sort_order NULLS LAST, created_at LIMIT 1' INTO v_found, v_lc USING p_product_id;
+  ELSE
+    EXECUTE 'SELECT true FROM public.product_packings WHERE product_id = $1 AND is_primary LIMIT 1' INTO v_found USING p_product_id;
+  END IF;
+  RETURN jsonb_build_object('aanwezig', coalesce(v_found, false), 'ladingdrager', v_lc);
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_product_hoofdverpakking(uuid) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_max_fusten_per_laag_alle(p_fust_l numeric, p_fust_b numeric)
+RETURNS integer LANGUAGE sql STABLE SET search_path TO 'public' AS $$
+  SELECT max(public.logistics_max_fusten_per_laag(t.layer_length_cm, t.layer_width_cm, p_fust_l, p_fust_b))
+    FROM public.load_carrier_types t
+   WHERE t.is_active AND coalesce(t.layer_length_cm, 0) > 0 AND coalesce(t.layer_width_cm, 0) > 0
+$$;
+GRANT EXECUTE ON FUNCTION public.logistics_max_fusten_per_laag_alle(numeric, numeric) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_product_oordeel_belading(p_regels jsonb)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE e jsonb; gj jsonb; gmap jsonb := '{}'::jsonb; c record; rc jsonb; hv jsonb; v_code text; v_eigen text; ids uuid[]; uit jsonb := '[]'::jsonb;
+  ls int; fh numeric; ph numeric; cpl numeric; lpc numeric; ppc numeric; laag numeric; naam text; v_prod text; fl numeric; fb numeric;
+  blok text[]; waar text[]; mist text[]; hmist text[]; v_pid uuid; v_oordeel text; v_tekst text; v_heeft_kol boolean; v_cfout text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_product_oordeel_belading');
+  IF p_regels IS NULL OR jsonb_typeof(p_regels) <> 'array' THEN RAISE EXCEPTION 'p_regels moet een lijst zijn.' USING ERRCODE = '22023'; END IF;
+  IF jsonb_array_length(p_regels) > 1000 THEN
+    RAISE EXCEPTION 'Maximaal 1000 regels per aanroep (ontvangen: %).', jsonb_array_length(p_regels) USING ERRCODE = '22023';
+  END IF;
+  SELECT array_agg(DISTINCT (x->>'product_id')::uuid) INTO ids FROM jsonb_array_elements(p_regels) x
+   WHERE nullif(btrim(x->>'product_id'), '') ~* '^[0-9a-f-]{36}$';
+  IF ids IS NOT NULL THEN
+    SELECT coalesce(jsonb_object_agg(g.product_id::text, to_jsonb(g)), '{}'::jsonb) INTO gmap
+      FROM public.logistics_data_gereedheid(ids) g;
+  END IF;
+  SELECT EXISTS (SELECT 1 FROM pg_attribute WHERE attrelid = to_regclass('public.products') AND attname = 'load_carrier_type' AND NOT attisdropped) INTO v_heeft_kol;
+
+  FOR e IN SELECT x FROM jsonb_array_elements(p_regels) x LOOP
+    blok := '{}'; waar := '{}'; mist := '{}'; hmist := '{}'; v_eigen := NULL; c := NULL; v_cfout := NULL;
+    v_pid := CASE WHEN nullif(btrim(e->>'product_id'), '') ~* '^[0-9a-f-]{36}$' THEN (e->>'product_id')::uuid END;
+    gj := CASE WHEN v_pid IS NULL THEN NULL ELSE gmap->(v_pid::text) END;
+    IF gj IS NULL THEN
+      uit := uit || jsonb_build_array(jsonb_build_object('product_id', v_pid, 'oordeel', 'mist_gegevens', 'tekst', 'product onbekend',
+        'regels', jsonb_build_array('Product onbekend.')));
+      CONTINUE;
+    END IF;
+    v_prod := coalesce(gj->>'product', 'Product');
+    hv := public.logistics_product_hoofdverpakking(v_pid);
+    v_code := nullif(btrim(e->>'carrier_code'), '');
+    IF v_code IS NULL THEN v_code := nullif(hv->>'ladingdrager', ''); END IF;
+    IF v_code IS NULL AND v_heeft_kol THEN
+      EXECUTE 'SELECT nullif(btrim(load_carrier_type::text), '''') FROM public.products WHERE id = $1' INTO v_eigen USING v_pid;
+      v_code := v_eigen;
+    END IF;
+    rc := public.logistics_ladingdrager_resolve(v_code);
+    v_cfout := rc->>'fout';
+    IF rc->>'code' IS NOT NULL THEN
+      SELECT t.code, t.name, t.layer_length_cm, t.layer_width_cm, t.max_height_cm, t.max_crates_per_layer, t.layers_per_carrier INTO c
+        FROM public.load_carrier_types t WHERE t.is_active AND t.code = rc->>'code' LIMIT 1;
+    END IF;
+    naam := coalesce(c.name, c.code, 'de ladingdrager');
+    ppc := nullif(e->>'plants_per_crate', '')::numeric;
+    cpl := nullif(e->>'crates_per_layer', '')::numeric;
+    lpc := nullif(e->>'layers_per_cart', '')::numeric;
+    fh := nullif(gj->'velden'->'fust_height_mm'->>'waarde', '')::numeric / 10.0;
+    ph := nullif(gj->'velden'->'plant_height_cm'->>'waarde', '')::numeric;
+    fl := nullif(gj->'velden'->'fust_length_mm'->>'waarde', '')::numeric / 10.0;
+    fb := nullif(gj->'velden'->'fust_width_mm'->>'waarde', '')::numeric / 10.0;
+    IF hv IS NOT NULL AND NOT coalesce((hv->>'aanwezig')::boolean, false) THEN mist := mist || 'belading niet ingesteld'::text; END IF;
+    IF coalesce(ppc, 0) <= 0 THEN mist := mist || 'planten per fust'::text; END IF;
+    IF coalesce(cpl, 0) <= 0 THEN mist := mist || 'fusten per laag'::text; END IF;
+    IF coalesce(lpc, 0) <= 0 THEN mist := mist || 'lagen per kar'::text; END IF;
+
+    IF c.code IS NULL THEN
+      mist := mist || coalesce(v_cfout, 'ladingdrager ontbreekt');
+      ls := public.logistics_max_fusten_per_laag_alle(fl, fb);
+      IF ls IS NOT NULL AND coalesce(cpl,0) > ls THEN
+        blok := blok || format('%s fust per laag, maar op geen enkele ladingdrager in Beheer passen er meer dan %s', cpl, ls);
+      END IF;
+    ELSE
+      ls := public.logistics_max_fusten_per_laag(c.layer_length_cm, c.layer_width_cm, fl, fb);
+      IF coalesce(lpc,0) > 0 AND coalesce(fh,0) > 0 AND coalesce(ph,0) > 0 AND coalesce(c.max_height_cm,0) > 0 THEN
+        laag := greatest(fh, ph);
+        IF lpc * laag > c.max_height_cm + 1e-9 THEN
+          blok := blok || format('%s lagen × %s cm = %s cm, terwijl %s %s cm hoog is; er passen maximaal %s lagen',
+            lpc, trim_scale(round(laag,1)), trim_scale(round(lpc*laag,1)), naam, trim_scale(round(c.max_height_cm::numeric,1)), floor(c.max_height_cm / laag));
+        END IF;
+      ELSE
+        IF coalesce(fh,0) <= 0 THEN hmist := hmist || 'fusthoogte'::text; END IF;
+        IF coalesce(ph,0) <= 0 THEN hmist := hmist || 'planthoogte'::text; END IF;
+        IF coalesce(c.max_height_cm,0) <= 0 THEN hmist := hmist || ('hoogte van ' || naam); END IF;
+      END IF;
+      IF ls IS NOT NULL AND coalesce(cpl,0) > ls THEN
+        blok := blok || format('%s fust per laag, maar op een laag van %s passen er maximaal %s', cpl, naam, ls);
+      END IF;
+      IF coalesce(c.max_crates_per_layer,0) > 0 AND coalesce(cpl,0) > c.max_crates_per_layer THEN
+        blok := blok || format('%s fust per laag, maar %s staat maximaal %s fust per laag toe', cpl, naam, c.max_crates_per_layer);
+      END IF;
+      IF cardinality(blok) = 0 AND cardinality(hmist) > 0 AND coalesce(c.layers_per_carrier,0) > 0 AND coalesce(lpc,0) > c.layers_per_carrier THEN
+        waar := waar || format('%s lagen opgegeven, standaard %s; niet te controleren omdat de %s ontbreekt', lpc, c.layers_per_carrier, array_to_string(hmist, ', '));
+      END IF;
+    END IF;
+    IF coalesce(gj->'ontbrekend', '[]'::jsonb) ? 'weight' THEN waar := waar || 'gewicht per fust ontbreekt'::text; END IF;
+    IF cardinality(blok) > 0 THEN
+      v_oordeel := 'onmogelijk'; v_tekst := format('%s past niet op %s.', v_prod, CASE WHEN c.code IS NULL THEN 'een ladingdrager' ELSE naam END);
+    ELSIF cardinality(mist) > 0 THEN
+      v_oordeel := 'mist_gegevens'; v_tekst := format('%s: %s.', v_prod, array_to_string(mist, ', '));
+    ELSIF cardinality(waar) > 0 THEN
+      v_oordeel := 'waarschuwing'; v_tekst := format('%s: belading mogelijk, met waarschuwing.', v_prod);
+    ELSE
+      v_oordeel := 'compleet'; v_tekst := format('%s: belading past.', v_prod);
+    END IF;
+    uit := uit || jsonb_build_array(jsonb_build_object('product_id', v_pid, 'oordeel', v_oordeel, 'tekst', v_tekst,
+      'ladingdrager', rc->>'code', 'ladingdragerInvoer', rc->>'invoer', 'ladingdragerBron', rc->>'bron',
+      'regels', to_jsonb(ARRAY(SELECT upper(left(z,1)) || substr(z,2) || '.' FROM unnest(blok || mist || waar) z))));
+  END LOOP;
+  RETURN uit;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_product_oordeel_belading(jsonb) TO authenticated, service_role;
+
+DO $do$
+DECLARE d text; n text;
+BEGIN
+  IF to_regprocedure('public.logistics_product_oordeel_many(uuid[])') IS NULL THEN RETURN; END IF;
+  d := pg_get_functiondef('public.logistics_product_oordeel_many(uuid[])'::regprocedure);
+  IF position('belading niet ingesteld' IN d) > 0 THEN RETURN; END IF;
+  n := replace(d,
+    $a$    mist := array_remove(coalesce(r.ontbrekend, '{}'), 'weight');$a$,
+    $a$    mist := array_remove(coalesce(r.ontbrekend, '{}'), 'weight');
+    IF public.logistics_product_hoofdverpakking(r.product_id) IS NOT NULL
+       AND NOT coalesce((public.logistics_product_hoofdverpakking(r.product_id)->>'aanwezig')::boolean, false) THEN
+      mist := mist || 'belading niet ingesteld'::text;
+    END IF;$a$);
+  n := replace(n,
+    $a$      oordeel := 'mist_gegevens'; tekst := r.uitleg;$a$,
+    $a$      oordeel := 'mist_gegevens';
+      tekst := CASE WHEN 'belading niet ingesteld' = ANY(mist) THEN format('%s: belading niet ingesteld.', r.product) ELSE r.uitleg END;$a$);
+  IF n = d THEN RAISE NOTICE 'logistiek-engine: patroon oordeel_many niet gevonden'; RETURN; END IF;
+  EXECUTE n;
+END $do$;
+
+CREATE OR REPLACE FUNCTION public.logistics_cart_vulgraad_core(p_cart_id uuid)
+RETURNS numeric LANGUAGE plpgsql STABLE SET search_path TO 'public' AS $$
+DECLARE m jsonb := public.logistics_laag_menging_core(); v_n int; v_m int; v_tot numeric; v_ontbreekt boolean; v_groepen int;
+BEGIN
+  SELECT bool_or(coalesce(ci.crates_per_layer, 0) <= 0 OR coalesce(ci.layers_per_cart, 0) <= 0) INTO v_ontbreekt
+    FROM logistics_active.order_cart_items ci LEFT JOIN public.order_items oi ON oi.id = ci.order_item_id
+   WHERE ci.cart_id = p_cart_id AND oi.quarantined_at IS NULL;
+  IF v_ontbreekt IS NULL OR v_ontbreekt THEN RETURN NULL; END IF;
+  IF m->>'menging' = 'per_regel' THEN
+    SELECT sum(ceil(ci.crates::numeric / ci.crates_per_layer - 1e-9) / ci.layers_per_cart) INTO v_tot
+      FROM logistics_active.order_cart_items ci LEFT JOIN public.order_items oi ON oi.id = ci.order_item_id
+     WHERE ci.cart_id = p_cart_id AND oi.quarantined_at IS NULL;
+    RETURN v_tot;
+  END IF;
+  v_n := nullif(m->>'klantenPerLaag', '')::int;
+  v_m := nullif(m->>'beladingenPerLaag', '')::int;
+  WITH r AS (
+    SELECT ci.crates::numeric / ci.crates_per_layer f, ci.layers_per_cart::numeric lpc,
+           coalesce(o.customer_id::text, oi.order_id::text, 'regel:' || ci.order_item_id::text) klant, ci.order_item_id::text regel
+      FROM logistics_active.order_cart_items ci
+      LEFT JOIN public.order_items oi ON oi.id = ci.order_item_id
+      LEFT JOIN public.orders o ON o.id = oi.order_id
+     WHERE ci.cart_id = p_cart_id AND oi.quarantined_at IS NULL),
+  g AS (
+    SELECT r.*, CASE
+        WHEN v_n IS NULL AND v_m IS NULL THEN '1'
+        WHEN v_m IS NOT NULL THEN r.klant || ':' || ((row_number() OVER (PARTITION BY r.klant ORDER BY r.regel) - 1) / v_m)
+        ELSE ((dense_rank() OVER (ORDER BY r.klant) - 1) / v_n)::text END grp
+      FROM r),
+  u AS (SELECT grp, sum(f) lagen, sum(f / lpc) vul, min(lpc) minl FROM g GROUP BY grp)
+  SELECT count(*), CASE WHEN count(*) <= 1 THEN sum(vul) ELSE sum(ceil(lagen - 1e-9) / minl) END INTO v_groepen, v_tot FROM u;
+  RETURN v_tot;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_cart_vulgraad_core(uuid) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_kar_blokkade_vul(p_kar text, p_vul numeric)
+RETURNS jsonb LANGUAGE sql IMMUTABLE SET search_path TO 'public' AS $$
+  SELECT CASE WHEN p_vul IS NOT NULL AND p_vul > 1.001
+    THEN jsonb_build_object('teHoog', true, 'blokkade', jsonb_build_object('code', 'kar_te_hoog',
+      'tekst', format('Kar %s is voor %s %% gevuld, meer dan 100 %%. Deel de order opnieuw in of pas de belading aan.',
+        coalesce(nullif(btrim(p_kar), ''), '?'), round(100 * p_vul)::int)))
+    ELSE jsonb_build_object('teHoog', false, 'blokkade', NULL) END
+$$;
+GRANT EXECUTE ON FUNCTION public.logistics_kar_blokkade_vul(text, numeric) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_cart_capaciteit_core(p_cart_id uuid)
+RETURNS jsonb LANGUAGE sql STABLE SET search_path TO 'public' AS $$
+  WITH c AS (SELECT oc.cart_number, oc.total_layers_used, oc.max_layers FROM logistics_active.order_carts oc WHERE oc.id = p_cart_id),
+  i AS (SELECT max(nullif(ci.layers_per_cart, 0)) lpc
+          FROM logistics_active.order_cart_items ci LEFT JOIN public.order_items oi ON oi.id = ci.order_item_id
+         WHERE ci.cart_id = p_cart_id AND oi.quarantined_at IS NULL),
+  v AS (SELECT c.cart_number,
+               coalesce(public.logistics_cart_lagen_core(p_cart_id), c.total_layers_used::numeric) lagen,
+               coalesce(i.lpc::numeric, nullif(c.max_layers, 0)::numeric) cap,
+               public.logistics_cart_vulgraad_core(p_cart_id) vul,
+               CASE WHEN i.lpc IS NOT NULL THEN 'product' WHEN coalesce(c.max_layers, 0) > 0 THEN 'ladingdrager' END bron
+          FROM c, i)
+  SELECT jsonb_build_object('layersUsed', v.lagen, 'maxLayers', v.cap, 'capaciteitBron', v.bron,
+           'laagMenging', public.logistics_laag_menging_core(),
+           'vulgraad', round(v.vul, 4),
+           'vulgraadPct', coalesce(round(100 * v.vul), CASE WHEN coalesce(v.cap, 0) > 0 AND v.lagen IS NOT NULL THEN round(100 * v.lagen / v.cap) END),
+           'layerUtilizationPct', coalesce(round(100 * v.vul), CASE WHEN coalesce(v.cap, 0) > 0 AND v.lagen IS NOT NULL THEN round(100 * v.lagen / v.cap) END))
+         || CASE WHEN v.vul IS NOT NULL THEN public.logistics_kar_blokkade_vul(v.cart_number::text, v.vul)
+                 ELSE public.logistics_kar_blokkade(v.cart_number::text, v.lagen, v.cap) END
+    FROM v
+$$;
+
+CREATE OR REPLACE FUNCTION public.logistics_kar_tekst(p_carrier_code text, p_lagen numeric, p_pct numeric)
+RETURNS text LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+  SELECT CASE WHEN p_lagen IS NULL THEN NULL ELSE
+    replace(trim_scale(round(p_lagen, 1))::text, '.', ',') || ' lagen · '
+    || coalesce((SELECT nullif(btrim(t.name), '') FROM public.load_carrier_types t WHERE t.code = p_carrier_code ORDER BY t.is_active DESC LIMIT 1), 'Ladingdrager')
+    || CASE WHEN coalesce(public.logistics_extra_platen(p_lagen), 0) = 0 THEN ''
+            WHEN public.logistics_extra_platen(p_lagen) = 1 THEN ' + 1 plaat'
+            ELSE ' + ' || public.logistics_extra_platen(p_lagen) || ' platen' END
+    || CASE WHEN p_pct IS NULL THEN '' ELSE ' · ' || round(p_pct)::int || ' %' END END
+$$;
+GRANT EXECUTE ON FUNCTION public.logistics_kar_tekst(text, numeric, numeric) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_cart_platen_verrijk(p_cart jsonb)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_id uuid; k jsonb; c jsonb := p_cart; v_l numeric; v_pct numeric;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_cart_platen_verrijk');
+  BEGIN v_id := nullif(coalesce(p_cart->>'cartId', p_cart->>'cart_id'), '')::uuid; EXCEPTION WHEN invalid_text_representation THEN v_id := NULL; END;
+  IF v_id IS NOT NULL THEN k := public.logistics_cart_capaciteit_core(v_id); END IF;
+  IF k IS NOT NULL THEN
+    c := c || jsonb_build_object('layersUsed', k->'layersUsed', 'maxLayers', k->'maxLayers', 'capaciteitBron', k->'capaciteitBron',
+                                 'vulgraadPct', k->'vulgraadPct', 'layerUtilizationPct', k->'layerUtilizationPct');
+  END IF;
+  v_l := nullif(c->>'layersUsed', '')::numeric;
+  v_pct := coalesce(nullif(c->>'vulgraadPct', '')::numeric, nullif(c->>'layerUtilizationPct', '')::numeric, nullif(c->>'occupancyPct', '')::numeric);
+  RETURN c || jsonb_build_object(
+    'additionalLayers', public.logistics_extra_platen(v_l),
+    'ladingdragerTekst', public.logistics_ladingdrager_tekst(c->>'carrierType', v_l, v_pct),
+    'karTekst', public.logistics_kar_tekst(c->>'carrierType', v_l, v_pct))
+    || CASE WHEN k IS NOT NULL THEN jsonb_build_object('teHoog', coalesce(k->'teHoog', 'false'::jsonb), 'blokkade', k->'blokkade')
+            ELSE public.logistics_kar_blokkade(coalesce(c->>'cartNumber', c->>'cart_number', c->>'seq'), v_l, nullif(c->>'maxLayers', '')::numeric) END;
+END $$;
+
+DO $do$
+DECLARE d text; n text;
+BEGIN
+  d := pg_get_functiondef('public.logistics_product_oordeel_belading(jsonb)'::regprocedure);
+  IF position('c := NULL;' IN d) = 0 THEN RETURN; END IF;
+  n := replace(d, 'v_eigen := NULL; c := NULL; v_cfout := NULL;',
+    'v_eigen := NULL; v_cfout := NULL;
+    SELECT NULL::text AS code, NULL::text AS name, NULL::numeric AS layer_length_cm, NULL::numeric AS layer_width_cm,
+           NULL::numeric AS max_height_cm, NULL::integer AS max_crates_per_layer, NULL::integer AS layers_per_carrier INTO c;');
+  EXECUTE n;
+END $do$;
+
+CREATE OR REPLACE FUNCTION public.logistics_pick_cart_breakdown_fast(_order_id uuid)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $function$
+DECLARE
+  v_orders uuid[]; v_ref text; v_status jsonb;
+  v_ready boolean := false; v_released boolean := false;
+  v_total integer := 0; v_full integer := 0; v_partial integer := 0;
+  v_shared integer := 0; v_crates integer := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_pick_cart_breakdown_fast');
+  v_orders := public.pick_buffer_order_ids(_order_id);
+  IF v_orders IS NULL OR cardinality(v_orders) = 0 THEN v_orders := ARRAY[_order_id]; END IF;
+  SELECT o.order_number INTO v_ref FROM public.orders o WHERE o.id = _order_id;
+  -- 1.0.208: alleen de kern; planState (logistics_plan_state_for) wordt hier niet gebruikt.
+  v_status := public.logistics_cart_plan_status_core(v_ref);
+  v_ready := COALESCE((v_status->>'ready')::boolean, false);
+  v_released := COALESCE((v_status->>'released')::boolean, false);
+  IF v_ready THEN
+    v_total := COALESCE((v_status->>'cartTotal')::integer, (v_status->>'totalCarts')::integer, 0);
+    SELECT
+      count(*) FILTER (WHERE COALESCE((c->>'isFullCart')::boolean, false)),
+      count(*) FILTER (WHERE NOT COALESCE((c->>'isFullCart')::boolean, false)),
+      count(*) FILTER (WHERE COALESCE((c->>'isShared')::boolean, false))
+      INTO v_full, v_partial, v_shared
+      FROM jsonb_array_elements(COALESCE(v_status->'carts', '[]'::jsonb)) c;
+    IF v_total = 0 THEN v_total := v_full + v_partial; END IF;
+    IF v_total > 0 AND v_full + v_partial <> v_total THEN
+      v_partial := GREATEST(v_total - v_full, 0);
+    END IF;
+  END IF;
+  SELECT COALESCE(sum(ci.crates), 0)::integer INTO v_crates
+    FROM public.order_cart_items ci
+    JOIN logistics_active.order_items oi ON oi.id = ci.order_item_id
+   WHERE oi.order_id = ANY(v_orders);
+  RETURN jsonb_build_object(
+    'totalCarts', COALESCE(v_total, 0), 'fullCarts', COALESCE(v_full, 0), 'partialCarts', COALESCE(v_partial, 0),
+    'sharedCarts', COALESCE(v_shared, 0), 'crates', COALESCE(v_crates, 0),
+    'cartPlanReady', v_ready, 'cartPlanReleased', v_released, 'cartPlanReason', v_status->>'reason'
+  ) || public.logistics_pick_mode();
+END; $function$;
+GRANT EXECUTE ON FUNCTION public.logistics_pick_cart_breakdown_fast(uuid) TO authenticated, service_role;
+
+DO $do$
+DECLARE d text; n text;
+BEGIN
+  -- Kern
+  d := pg_get_functiondef('public.logistics_sync_pick_queue_core()'::regprocedure);
+  IF position('v_kand uuid[]' IN d) = 0 THEN
+    n := replace(d, 'v_wait timestamptz; v_reason text; v_ok boolean;',
+                    'v_wait timestamptz; v_reason text; v_ok boolean; v_kand uuid[]; v_rel uuid[];');
+    n := replace(n, E'  SELECT min(d) INTO v_pickday FROM (',
+      E'  -- 1.0.208: controles per order één keer voor alle orders samen.\n'
+      || E'  SELECT coalesce(array_agg(ord.id), ''{}'') INTO v_kand FROM public.orders ord\n'
+      || E'   WHERE ord.order_number IS NOT NULL\n'
+      || E'     AND EXISTS (SELECT 1 FROM public.logistics_tasks lt WHERE lt.order_ref = ord.order_number AND lt.task_type = ''pick.execute''\n'
+      || E'                  AND lt.status NOT IN (''done'',''cancelled'',''superseded'',''skipped''))\n'
+      || E'     AND public.logistics_order_is_topick(ord.id, ord.order_number)\n'
+      || E'     AND NOT public.logistics_order_handled(ord.id);\n'
+      || E'  SELECT coalesce(array_agg(ord.id), ''{}'') INTO v_rel FROM public.orders ord\n'
+      || E'   WHERE ord.id = ANY(v_kand) AND public.logistics_order_released(ord.order_number);\n'
+      || E'  SELECT min(d) INTO v_pickday FROM (');
+    n := regexp_replace(n, 'public\.logistics_order_is_topick\(ord\.id, ord\.order_number\)\s+AND NOT public\.logistics_order_handled\(ord\.id\)\s+AND public\.logistics_order_released\(ord\.order_number\)',
+                        'ord.id = ANY(v_rel)', 'g');
+    n := regexp_replace(n, 'public\.logistics_order_is_topick\(ord\.id, ord\.order_number\)\s+AND NOT public\.logistics_order_handled\(ord\.id\)\s+AND \(v_forced IS NOT NULL OR public\.logistics_order_released\(ord\.order_number\)\)',
+                        'ord.id = ANY(v_kand) AND (v_forced IS NOT NULL OR ord.id = ANY(v_rel))', 'g');
+    -- de eerste vervanging hierboven mag de nieuwe v_kand-berekening niet raken: die heeft geen released-regel erachter.
+    n := replace(n, 'v_breakdown := public.pick_cart_breakdown(r_unit.lead_id);', 'v_breakdown := public.logistics_pick_cart_breakdown_fast(r_unit.lead_id);');
+    EXECUTE n;
+  END IF;
+
+  -- Achterstand
+  d := pg_get_functiondef('public.logistics_sync_pick_queue_backlog()'::regprocedure);
+  IF position('v_bl uuid[]' IN d) = 0 THEN
+    n := replace(d, 'v_ins integer := 0; v_upd integer := 0; v_orders integer := 0;',
+                    'v_ins integer := 0; v_upd integer := 0; v_orders integer := 0; v_bl uuid[];');
+    n := replace(n, E'  FOR r_unit IN\n    WITH k AS (',
+      E'  -- 1.0.208: achterstand in één keer voor alle orders (zelfde regel als logistics_order_is_backlog).\n'
+      || E'  SELECT coalesce(array_agg(b.order_id), ''{}'') INTO v_bl\n'
+      || E'    FROM public.logistics_order_backlog_info_many(ARRAY(SELECT o.id FROM public.orders o WHERE o.order_number IS NOT NULL)) b\n'
+      || E'    JOIN public.orders o ON o.id = b.order_id\n'
+      || E'   WHERE b.info IS NOT NULL AND (b.info->>''dagen'')::int <= v_max AND public.logistics_order_released(o.order_number);\n'
+      || E'  FOR r_unit IN\n    WITH k AS (');
+    n := replace(n, 'public.logistics_order_is_backlog(o.id)', 'o.id = ANY(v_bl)');
+    n := replace(n, 'v_breakdown := public.pick_cart_breakdown(r_unit.lead_id);', 'v_breakdown := public.logistics_pick_cart_breakdown_fast(r_unit.lead_id);');
+    EXECUTE n;
+  END IF;
+END $do$;
+
+DO $do$
+DECLARE d text; n text;
+BEGIN
+  d := pg_get_functiondef('public.logistics_cart_plan_status_core_v152(text)'::regprocedure);
+  n := replace(d, 'public.logistics_cart_plan_status_core_v152(', 'public.logistics_cart_plan_status_slim(');
+  n := replace(n, '''logistics_cart_plan_status_core_v152''', '''logistics_cart_plan_status_slim''');
+  n := replace(n, 'public.logistics_cart_json_fixed(c)',
+    'c || coalesce(public.logistics_cart_fixed_numbering(nullif(c->>''cartId'', '''')::uuid), ''{}''::jsonb)');
+  IF position('logistics_cart_json_fixed' IN n) > 0 THEN RAISE EXCEPTION 'vervanging json_fixed mislukt'; END IF;
+  EXECUTE n;
+
+  d := pg_get_functiondef('public.logistics_pick_cart_breakdown_fast(uuid)'::regprocedure);
+  IF position('logistics_cart_plan_status_slim' IN d) = 0 THEN
+    EXECUTE replace(d, 'v_status := public.logistics_cart_plan_status_core(v_ref);', 'v_status := public.logistics_cart_plan_status_slim(v_ref);');
+  END IF;
+END $do$;
+GRANT EXECUTE ON FUNCTION public.logistics_cart_plan_status_slim(text) TO service_role;
+
+DO $do$
+DECLARE d text; n text; v_extra text := ' || jsonb_build_object(''cartCount'', 1, ''perCart'', true, ''pickMode'', ''cart'', ''cartPlanReady'', true)';
+BEGIN
+  d := pg_get_functiondef('public.logistics_sync_pick_queue_backlog()'::regprocedure);
+  IF position('''cartPlanReady'', true)' IN d) = 0 THEN
+    n := replace(d, E'COALESCE(q.payload, ''{}''::jsonb) || v_payload);', E'COALESCE(q.payload, ''{}''::jsonb) || v_payload' || v_extra || ');');
+    IF n = d THEN RAISE EXCEPTION 'patroon achterstand niet gevonden'; END IF;
+    EXECUTE n;
+  END IF;
+  d := pg_get_functiondef('public.logistics_sync_pick_queue_core()'::regprocedure);
+  IF position('''cartPlanReady'', true)' IN d) = 0 THEN
+    n := replace(d, E'COALESCE(v_wait, v_due, q.due_at), COALESCE(q.payload, ''{}''::jsonb) || v_cart_payload);',
+                    E'COALESCE(v_wait, v_due, q.due_at), COALESCE(q.payload, ''{}''::jsonb) || v_cart_payload' || v_extra || ');');
+    IF n = d THEN RAISE EXCEPTION 'patroon kern niet gevonden'; END IF;
+    EXECUTE n;
+  END IF;
+END $do$;
+
+CREATE OR REPLACE FUNCTION public.logistics_cart_verouderd_core(p_cart_id uuid)
+RETURNS jsonb LANGUAGE plpgsql STABLE SET search_path TO 'public' AS $$
+DECLARE v_nr text; v_n int;
+BEGIN
+  IF p_cart_id IS NULL THEN RETURN NULL; END IF;
+  IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema = 'public' AND table_name = 'order_items' AND column_name = 'quarantined_at') THEN
+    RETURN NULL;
+  END IF;
+  SELECT count(*) INTO v_n FROM public.order_cart_items ci JOIN public.order_items oi ON oi.id = ci.order_item_id
+   WHERE ci.cart_id = p_cart_id AND oi.quarantined_at IS NOT NULL;
+  IF coalesce(v_n, 0) = 0 THEN RETURN NULL; END IF;
+  SELECT cart_number::text INTO v_nr FROM public.order_carts WHERE id = p_cart_id;
+  RETURN jsonb_build_object('verouderd', true, 'regelsInQuarantaine', v_n,
+    'blokkade', jsonb_build_object('code', 'kar_verouderd',
+      'tekst', format('Kar %s heeft %s regel(s) die Verkoop in quarantaine heeft gezet. Deel de niet-geprinte karren opnieuw in.', coalesce(v_nr, '?'), v_n)));
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_cart_verouderd_core(uuid) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_cart_te_hoog(p_cart_id uuid)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE k jsonb; v jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_cart_te_hoog');
+  k := public.logistics_cart_capaciteit_core(p_cart_id);
+  IF k IS NOT NULL AND coalesce((k->>'teHoog')::boolean, false) THEN
+    RETURN jsonb_build_object('teHoog', true, 'blokkade', k->'blokkade');
+  END IF;
+  -- 1.0.208: verouderde kar (regels in quarantaine) krijgt ook geen stickers/verzendbrief/pakbon.
+  v := public.logistics_cart_verouderd_core(p_cart_id);
+  IF v IS NOT NULL THEN
+    RETURN jsonb_build_object('teHoog', false, 'indelingVerouderd', true, 'blokkade', v->'blokkade');
+  END IF;
+  RETURN jsonb_build_object('teHoog', false, 'blokkade', NULL);
+END $$;
+
+DO $do$
+DECLARE d text; n text;
+BEGIN
+  d := pg_get_functiondef('public.logistics_cart_platen_verrijk(jsonb)'::regprocedure);
+  IF position('logistics_cart_verouderd_core' IN d) = 0 THEN
+    n := replace(d,
+      $a$    || CASE WHEN k IS NOT NULL THEN jsonb_build_object('teHoog', coalesce(k->'teHoog', 'false'::jsonb), 'blokkade', k->'blokkade')$a$,
+      $a$    || CASE WHEN v_id IS NOT NULL AND public.logistics_cart_verouderd_core(v_id) IS NOT NULL
+                 AND NOT coalesce((k->>'teHoog')::boolean, false)
+            THEN jsonb_build_object('teHoog', false, 'indelingVerouderd', true, 'blokkade', public.logistics_cart_verouderd_core(v_id)->'blokkade')
+            WHEN k IS NOT NULL THEN jsonb_build_object('teHoog', coalesce(k->'teHoog', 'false'::jsonb), 'blokkade', k->'blokkade')$a$);
+    IF n = d THEN RAISE EXCEPTION 'patroon platen_verrijk niet gevonden'; END IF;
+    EXECUTE n;
+  END IF;
+END $do$;
+
+CREATE OR REPLACE FUNCTION public.logistics_order_indeling_verouderd_core(p_order_id uuid)
+RETURNS jsonb LANGUAGE sql STABLE SET search_path TO 'public' AS $$
+  WITH a AS (
+    SELECT oi.id, coalesce(oi.product_name, 'regel') naam, ci.cart_id,
+           (oi.plants_per_crate IS DISTINCT FROM ci.plants_per_crate
+            OR oi.crates_per_layer IS DISTINCT FROM ci.crates_per_layer
+            OR oi.layers_per_cart IS DISTINCT FROM ci.layers_per_cart) afwijkend
+      FROM public.order_items oi
+      JOIN logistics_active.order_cart_items ci ON ci.order_item_id = oi.id
+     WHERE oi.order_id = p_order_id AND oi.packing_locked_at IS NOT NULL AND oi.quarantined_at IS NULL),
+  q AS (
+    SELECT DISTINCT ci.cart_id, coalesce(oi.product_name, 'regel') naam
+      FROM public.order_items oi
+      JOIN public.order_cart_items ci ON ci.order_item_id = oi.id
+      JOIN logistics_active.order_carts c ON c.id = ci.cart_id
+     WHERE oi.order_id = p_order_id AND oi.quarantined_at IS NOT NULL)
+  SELECT CASE
+    WHEN EXISTS (SELECT 1 FROM q) THEN jsonb_build_object(
+           'verouderd', true, 'blokkeert', true, 'reden', 'quarantaine',
+           'producten', (SELECT to_jsonb(array_agg(DISTINCT naam)) FROM q),
+           'karren', (SELECT to_jsonb(array_agg(DISTINCT cart_id)) FROM q),
+           'vastliggendeKarren', (SELECT count(DISTINCT q2.cart_id) FROM q q2 WHERE public.logistics_cart_vast_core(q2.cart_id)),
+           'tekst', 'Er staan regels op de karren die Verkoop in quarantaine heeft gezet. Deel de niet-geprinte karren opnieuw in.')
+    WHEN (SELECT bool_or(afwijkend) FROM a) THEN jsonb_build_object(
+           'verouderd', true, 'blokkeert', false, 'reden', 'belading',
+           'producten', (SELECT to_jsonb(array_agg(DISTINCT naam) FILTER (WHERE afwijkend)) FROM a),
+           'vastliggendeKarren', (SELECT count(DISTINCT a2.cart_id) FROM a a2 WHERE public.logistics_cart_vast_core(a2.cart_id)),
+           'tekst', 'De belading is gewijzigd, maar de karindeling is nog oud. Deel de niet-geprinte karren opnieuw in.')
+    ELSE NULL END
+$$;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_208()
+RETURNS TABLE(punt text, ok boolean, uitleg text) LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+  SELECT 'vulgraad per kar', to_regprocedure('public.logistics_cart_vulgraad_core(uuid)') IS NOT NULL, 'Vulgraad = som per regel van lagen ÷ lagen per kar (Floriday)'
+  UNION ALL SELECT 'karTekst', to_regprocedure('public.logistics_kar_tekst(text,numeric,numeric)') IS NOT NULL, 'Tekst per kar: lagen · ladingdrager + platen · %'
+  UNION ALL SELECT 'ladingdrager-vertaling', to_regprocedure('public.logistics_ladingdrager_resolve(text)') IS NOT NULL, 'Floriday- en Beheer-codes'
+  UNION ALL SELECT 'vertaling eenduidig', NOT EXISTS (SELECT 1 FROM public.logistics_floriday_carrier_map GROUP BY floriday_code HAVING count(*) > 1), 'Elke Floriday-code naar precies één Beheer-type'
+  UNION ALL SELECT 'hoofdverpakking', to_regprocedure('public.logistics_product_hoofdverpakking(uuid)') IS NOT NULL, 'Ladingdrager uit hoofdverpakking'
+  UNION ALL SELECT 'pickwachtrij set-based', position('v_kand' IN pg_get_functiondef('public.logistics_sync_pick_queue_core()'::regprocedure)) > 0
+             AND position('v_bl' IN pg_get_functiondef('public.logistics_sync_pick_queue_backlog()'::regprocedure)) > 0, 'Controles één keer voor alle orders'
+  UNION ALL SELECT 'verouderde kar', to_regprocedure('public.logistics_cart_verouderd_core(uuid)') IS NOT NULL
+             AND position('logistics_cart_verouderd_core' IN pg_get_functiondef('public.logistics_cart_te_hoog(uuid)'::regprocedure)) > 0, 'Kar met quarantaineregels krijgt geen documenten'
+  UNION ALL SELECT 'guards 1.0.208', position('logistics_acc_guard' IN pg_get_functiondef('public.logistics_ladingdrager_resolve(text)'::regprocedure)) > 0
+             AND position('logistics_acc_guard' IN pg_get_functiondef('public.logistics_product_hoofdverpakking(uuid)'::regprocedure)) > 0, 'Nieuwe functies controleren de aanroeper'
+$$;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_208() TO authenticated, service_role;
+-- ============================================================================
+-- 1.0.210 — tolerantie 1 % bij "maximaal per laag", hoogte uit Floricode = waarschuwing,
+-- karregel van een verouderde kar.
+-- ============================================================================
+
+-- Eén benoemde regel; TS-tegenhanger: LAAG_TOLERANTIE in src/lib/dimensionPlanner.ts.
+CREATE OR REPLACE FUNCTION public.logistics_laag_tolerantie()
+RETURNS numeric LANGUAGE sql IMMUTABLE SET search_path TO 'public' AS $$ SELECT 0.01::numeric $$;
+GRANT EXECUTE ON FUNCTION public.logistics_laag_tolerantie() TO authenticated, service_role;
+
+-- Strikte LayerSpace (zonder tolerantie): kopie van het oorspronkelijke algoritme.
+DO $do$
+DECLARE d text;
+BEGIN
+  IF to_regprocedure('public.logistics_max_fusten_per_laag_strikt(numeric,numeric,numeric,numeric)') IS NOT NULL THEN RETURN; END IF;
+  d := pg_get_functiondef('public.logistics_max_fusten_per_laag(numeric,numeric,numeric,numeric)'::regprocedure);
+  IF position('logistics_laag_tolerantie' IN d) > 0 THEN RAISE EXCEPTION 'max_fusten_per_laag heeft al tolerantie maar strikt ontbreekt'; END IF;
+  EXECUTE replace(d, 'public.logistics_max_fusten_per_laag(', 'public.logistics_max_fusten_per_laag_strikt(');
+END $do$;
+GRANT EXECUTE ON FUNCTION public.logistics_max_fusten_per_laag_strikt(numeric, numeric, numeric, numeric) TO authenticated, service_role;
+
+-- Bestaande naam = met tolerantie; alle bestaande aanroepers krijgen daarmee dezelfde regel.
+CREATE OR REPLACE FUNCTION public.logistics_max_fusten_per_laag(p_ll numeric, p_lw numeric, p_fl numeric, p_fw numeric)
+RETURNS integer LANGUAGE sql IMMUTABLE SET search_path TO 'public' AS $$
+  SELECT public.logistics_max_fusten_per_laag_strikt(p_ll * (1 + public.logistics_laag_tolerantie()),
+                                                     p_lw * (1 + public.logistics_laag_tolerantie()), p_fl, p_fw)
+$$;
+
+-- Tekst als de tolerantie nodig was, anders NULL.
+CREATE OR REPLACE FUNCTION public.logistics_laag_tolerantie_tekst(p_ll numeric, p_lw numeric, p_fl numeric, p_fw numeric, p_n numeric)
+RETURNS text LANGUAGE plpgsql IMMUTABLE SET search_path TO 'public' AS $$
+DECLARE lo numeric := 0; hi numeric := public.logistics_laag_tolerantie(); mid numeric; k int;
+BEGIN
+  IF coalesce(p_n,0) <= 0 OR coalesce(p_ll,0) <= 0 OR coalesce(p_lw,0) <= 0 OR coalesce(p_fl,0) <= 0 OR coalesce(p_fw,0) <= 0 THEN RETURN NULL; END IF;
+  IF coalesce(public.logistics_max_fusten_per_laag_strikt(p_ll, p_lw, p_fl, p_fw), 0) >= p_n THEN RETURN NULL; END IF;
+  IF coalesce(public.logistics_max_fusten_per_laag(p_ll, p_lw, p_fl, p_fw), 0) < p_n THEN RETURN NULL; END IF;
+  FOR k IN 1..25 LOOP
+    mid := (lo + hi) / 2;
+    IF coalesce(public.logistics_max_fusten_per_laag_strikt(p_ll * (1 + mid), p_lw * (1 + mid), p_fl, p_fw), 0) >= p_n THEN hi := mid; ELSE lo := mid; END IF;
+  END LOOP;
+  RETURN format('%s per laag past met %s mm overstek (binnen %s %% tolerantie)', trim_scale(p_n),
+    greatest(1, ceil(hi * p_lw * 10 - 1e-6))::int, trim_scale(round(public.logistics_laag_tolerantie() * 100, 2)));
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_laag_tolerantie_tekst(numeric, numeric, numeric, numeric, numeric) TO authenticated, service_role;
+
+-- Oordeel per regel: tolerantietekst en hoogte uit Floricode = waarschuwing.
+DO $do$
+DECLARE d text; n text;
+BEGIN
+  d := pg_get_functiondef('public.logistics_product_oordeel_belading(jsonb)'::regprocedure);
+  IF position('logistics_laag_tolerantie_tekst' IN d) > 0 THEN RETURN; END IF;
+  n := replace(d,
+$a$      ls := public.logistics_max_fusten_per_laag(c.layer_length_cm, c.layer_width_cm, fl, fb);$a$,
+$a$      ls := public.logistics_max_fusten_per_laag(c.layer_length_cm, c.layer_width_cm, fl, fb);
+      IF public.logistics_laag_tolerantie_tekst(c.layer_length_cm, c.layer_width_cm, fl, fb, cpl) IS NOT NULL THEN
+        waar := waar || public.logistics_laag_tolerantie_tekst(c.layer_length_cm, c.layer_width_cm, fl, fb, cpl);
+      END IF;$a$);
+  n := replace(n,
+$a$        IF lpc * laag > c.max_height_cm + 1e-9 THEN
+          blok := blok || format($a$,
+$a$        IF lpc * laag > c.max_height_cm + 1e-9 AND ph >= fh AND coalesce(gj->'velden'->'plant_height_cm'->>'bron', '') ILIKE 'floricode%' THEN
+          waar := waar || format('planthoogte volgens Floricode; controleer: %s lagen × %s cm = %s cm, hoger dan %s (%s cm)',
+            lpc, trim_scale(round(laag,1)), trim_scale(round(lpc*laag,1)), naam, trim_scale(round(c.max_height_cm::numeric,1)));
+        ELSIF lpc * laag > c.max_height_cm + 1e-9 THEN
+          blok := blok || format($a$);
+  IF n = d OR position('logistics_laag_tolerantie_tekst' IN n) = 0 OR position('volgens Floricode' IN n) = 0 THEN
+    RAISE EXCEPTION 'patroon oordeel_belading niet gevonden';
+  END IF;
+  EXECUTE n;
+END $do$;
+
+DO $do$
+DECLARE d text; n text;
+BEGIN
+  d := pg_get_functiondef('public.logistics_product_oordeel_many(uuid[])'::regprocedure);
+  IF position('logistics_laag_tolerantie_tekst' IN d) > 0 THEN RETURN; END IF;
+  n := replace(d,
+$a$    IF ls IS NOT NULL AND cpl > ls THEN$a$,
+$a$    IF public.logistics_laag_tolerantie_tekst(c.layer_length_cm, c.layer_width_cm,
+         nullif(r.velden->'fust_length_mm'->>'waarde', '')::numeric / 10.0, nullif(r.velden->'fust_width_mm'->>'waarde', '')::numeric / 10.0, cpl) IS NOT NULL THEN
+      waar := waar || public.logistics_laag_tolerantie_tekst(c.layer_length_cm, c.layer_width_cm,
+         nullif(r.velden->'fust_length_mm'->>'waarde', '')::numeric / 10.0, nullif(r.velden->'fust_width_mm'->>'waarde', '')::numeric / 10.0, cpl);
+    END IF;
+    IF ls IS NOT NULL AND cpl > ls THEN$a$);
+  n := replace(n,
+$a$      IF lpc * laag > c.max_height_cm + 1e-9 THEN
+        blok := blok || format($a$,
+$a$      IF lpc * laag > c.max_height_cm + 1e-9 AND ph >= fh AND coalesce(r.velden->'plant_height_cm'->>'bron', '') ILIKE 'floricode%' THEN
+        waar := waar || format('planthoogte volgens Floricode; controleer: %s lagen × %s cm = %s cm, hoger dan %s (%s cm)',
+          lpc, trim_scale(round(laag,1)), trim_scale(round(lpc*laag,1)), naam, trim_scale(round(c.max_height_cm::numeric,1)));
+      ELSIF lpc * laag > c.max_height_cm + 1e-9 THEN
+        blok := blok || format($a$);
+  IF n = d OR position('logistics_laag_tolerantie_tekst' IN n) = 0 OR position('volgens Floricode' IN n) = 0 THEN
+    RAISE EXCEPTION 'patroon oordeel_many niet gevonden';
+  END IF;
+  EXECUTE n;
+END $do$;
+
+-- Karregel: verouderde kar (regels in quarantaine) → "verouderd: opnieuw indelen", zonder lagen en %.
+DO $do$
+DECLARE d text; n text;
+BEGIN
+  d := pg_get_functiondef('public.logistics_cart_platen_verrijk(jsonb)'::regprocedure);
+  IF position('verouderd: opnieuw indelen' IN d) > 0 THEN RETURN; END IF;
+  n := replace(d,
+$a$    'karTekst', public.logistics_kar_tekst(c->>'carrierType', v_l, v_pct))$a$,
+$a$    'karTekst', CASE WHEN v_id IS NOT NULL AND public.logistics_cart_verouderd_core(v_id) IS NOT NULL
+                     THEN 'verouderd: opnieuw indelen' ELSE public.logistics_kar_tekst(c->>'carrierType', v_l, v_pct) END)$a$);
+  IF n = d THEN RAISE EXCEPTION 'patroon karTekst niet gevonden'; END IF;
+  EXECUTE n;
+END $do$;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_210()
+RETURNS TABLE(punt text, ok boolean, uitleg text) LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+  SELECT 'laagtolerantie', public.logistics_laag_tolerantie() = 0.01
+         AND position('logistics_laag_tolerantie' IN pg_get_functiondef('public.logistics_max_fusten_per_laag(numeric,numeric,numeric,numeric)'::regprocedure)) > 0,
+         'Maximaal per laag met 1 % tolerantie op de laagmaten'
+  UNION ALL SELECT '412 op DC', public.logistics_max_fusten_per_laag(135, 56, 56.2, 25.3) >= 5, '412 Normtray: 5 per laag op Deense container'
+  UNION ALL SELECT 'tolerantietekst in oordeel',
+         position('logistics_laag_tolerantie_tekst' IN pg_get_functiondef('public.logistics_product_oordeel_belading(jsonb)'::regprocedure)) > 0
+     AND position('logistics_laag_tolerantie_tekst' IN pg_get_functiondef('public.logistics_product_oordeel_many(uuid[])'::regprocedure)) > 0,
+         'Oordeel meldt wanneer de tolerantie nodig was'
+  UNION ALL SELECT 'hoogte Floricode = waarschuwing',
+         position('volgens Floricode' IN pg_get_functiondef('public.logistics_product_oordeel_belading(jsonb)'::regprocedure)) > 0
+     AND position('volgens Floricode' IN pg_get_functiondef('public.logistics_product_oordeel_many(uuid[])'::regprocedure)) > 0,
+         'Planthoogte alleen uit Floricode blokkeert niet'
+  UNION ALL SELECT 'karregel verouderd', position('verouderd: opnieuw indelen' IN pg_get_functiondef('public.logistics_cart_platen_verrijk(jsonb)'::regprocedure)) > 0,
+         'Verouderde kar toont geen lagen en %'
+$$;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_210() TO authenticated, service_role;