@flowselections/logistiek-engine 1.0.243 → 1.0.244

package/db/schema/logistiek-engine.sql

@@ -53027,3 +53027,1780 @@ BEGIN
   END IF;
   RETURN v_res;
 END $function$;
+
+
+-- ===== Correctie Golf 1 (E1-C) (20261111081722) =====
+-- ===== Correctie Golf 1 (E1-C) =====
+
+-- 4. Uitgang naar buiten per transactie uit te zetten (proefstand).
+CREATE OR REPLACE FUNCTION public.logistics_uitgang_uit()
+ RETURNS boolean LANGUAGE sql STABLE SET search_path TO 'public'
+AS $function$ SELECT COALESCE(current_setting('logistics.uitgang_uit', true), '') = 'aan' $function$;
+REVOKE ALL ON FUNCTION public.logistics_uitgang_uit() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_uitgang_uit() TO authenticated, service_role;
+
+-- 4/7/8/2. Bestaande functies gericht aanpassen (zelfde naam en parameters).
+DO $e1c$
+DECLARE
+  r record; d text; v_ret text; v_terug text;
+BEGIN
+  -- Uitgang-uit-bewaking in alles wat mail, http of print naar buiten zet.
+  FOR r IN SELECT p.oid::regprocedure AS sig, p.proname, format_type(p.prorettype, NULL) AS ret
+             FROM pg_proc p
+            WHERE p.pronamespace = 'public'::regnamespace
+              AND p.proname IN ('logistics_queue_stock_email','logistics_queue_capacity_email','logistics_print_via_layout',
+                                'logistics_plan_kick','logistics_recalc_tick_kick')
+  LOOP
+    d := pg_get_functiondef(r.sig);
+    CONTINUE WHEN position('logistics_uitgang_uit()' IN d) > 0;
+    v_terug := CASE WHEN r.ret = 'void' THEN 'RETURN;'
+                    WHEN r.ret = 'jsonb' THEN 'RETURN jsonb_build_object(''ok'', false, ''error'', ''Proefstand: er gaat niets naar buiten.'');'
+                    WHEN r.ret = 'boolean' THEN 'RETURN false;'
+                    ELSE 'RETURN NULL;' END;
+    d := regexp_replace(d, E'\\nBEGIN\\n', E'\nBEGIN\n  IF public.logistics_uitgang_uit() THEN ' || v_terug || E' END IF;\n');
+    EXECUTE d;
+  END LOOP;
+
+  -- 7. Verzendbrief-trace: alleen geldige statuswaarden.
+  IF to_regprocedure('public.logistics_shipping_note_job_for_slip(uuid)') IS NOT NULL THEN
+    d := pg_get_functiondef('public.logistics_shipping_note_job_for_slip(uuid)'::regprocedure);
+    IF position('''geblokkeerd'',' IN d) > 0 THEN
+      d := replace(d, '''geblokkeerd'',', '''wachtend'',');
+      EXECUTE d;
+    END IF;
+  END IF;
+
+  -- 8. Vooruit gekozen pickdag: deelkar direct printbaar, met vraag; blijft printbaar in latere rondes.
+  IF to_regprocedure('public.logistics_cart_release_reason(uuid)') IS NOT NULL THEN
+    d := pg_get_functiondef('public.logistics_cart_release_reason(uuid)'::regprocedure);
+    IF position('vooruitGekozen' IN d) = 0 THEN
+      d := replace(d, 'PERFORM public.logistics_acc_guard(''ingelogd'', ''logistics_cart_release_reason'');',
+        'PERFORM public.logistics_acc_guard(''ingelogd'', ''logistics_cart_release_reason'');
+  -- E1-C/8: bewust vooruit gekozen pickdag = de teamleider beslist; geen wachttijd voor aanvulling.
+  IF NULLIF(current_setting(''logistics.forced_pick_day'', true), '''') IS NOT NULL
+     OR EXISTS (SELECT 1 FROM public.pick_queue q WHERE q.reference = p_cart_id::text AND q.cancelled_at IS NULL
+                   AND nullif(q.payload->>''vooruitGekozen'', '''') IS NOT NULL) THEN
+    RETURN NULL;
+  END IF;');
+      EXECUTE d;
+    END IF;
+  END IF;
+
+  IF to_regprocedure('public.logistics_sync_pick_queue_core()') IS NOT NULL THEN
+    d := pg_get_functiondef('public.logistics_sync_pick_queue_core()'::regprocedure);
+    IF position('vooruitGekozen' IN d) = 0 THEN
+      d := replace(d, 'v_ok := v_forced IS NOT NULL OR public.logistics_cart_released(r_cart.cart_id);',
+        'v_ok := v_forced IS NOT NULL OR public.logistics_cart_released(r_cart.cart_id)
+                OR EXISTS (SELECT 1 FROM public.pick_queue q0 WHERE q0.reference = r_cart.cart_id::text AND q0.cancelled_at IS NULL
+                             AND nullif(q0.payload->>''vooruitGekozen'', '''') IS NOT NULL);');
+      d := replace(d, '''printbaar'', v_ok, ''wachtTot'', v_wait, ''wachtReden'', v_reason)',
+        '''printbaar'', v_ok, ''wachtTot'', v_wait, ''wachtReden'', v_reason,
+          ''vooruitGekozen'', COALESCE(v_forced::text, (SELECT nullif(q0.payload->>''vooruitGekozen'', '''') FROM public.pick_queue q0
+                                 WHERE q0.reference = r_cart.cart_id::text AND q0.cancelled_at IS NULL
+                                   AND nullif(q0.payload->>''vooruitGekozen'', '''') IS NOT NULL LIMIT 1)),
+          ''bevestigVraag'', CASE WHEN v_ok AND NOT public.logistics_cart_is_full(r_cart.cart_id)
+                                  AND NOT public.logistics_cart_released(r_cart.cart_id)
+                                THEN ''Deze kar is nog niet vol. Toch nu printen?'' END)');
+    END IF;
+    -- 2. Snelle uitweg als er sinds de vorige ronde niets is veranderd.
+    IF position('logistics_pickwachtrij_overslaan' IN d) = 0 THEN
+      d := replace(d, 'PERFORM public.logistics_acc_guard(''ingelogd'', ''logistics_sync_pick_queue_core'');',
+        'PERFORM public.logistics_acc_guard(''ingelogd'', ''logistics_sync_pick_queue_core'');
+  -- E1-C/2: niets veranderd sinds de vorige ronde = direct klaar.
+  IF NULLIF(current_setting(''logistics.forced_pick_day'', true), '''') IS NULL AND public.logistics_pickwachtrij_overslaan() THEN
+    RETURN jsonb_build_object(''toegevoegd'', 0, ''afgesloten'', 0, ''kandidaten'', 0, ''guard'', ''niets veranderd sinds de vorige ronde'');
+  END IF;');
+    END IF;
+    EXECUTE d;
+  END IF;
+END $e1c$;
+
+-- 2. Goedkope vingerafdruk van alles wat de pickwachtrij laat veranderen (ook tijd: venster open, wachttijd voorbij).
+CREATE OR REPLACE FUNCTION public.logistics_pickwachtrij_sig()
+ RETURNS text LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+  SELECT concat_ws('|',
+    public.logistics_local_today()::text,
+    (SELECT count(*) || ':' || count(*) FILTER (WHERE lt.planned_start <= now()) || ':' || COALESCE(max(lt.updated_at)::text, '')
+       FROM public.logistics_tasks lt
+      WHERE lt.task_type = 'pick.execute' AND lt.status NOT IN ('done','cancelled','superseded','skipped')),
+    (SELECT count(*) || ':' || COALESCE(max(q.updated_at)::text, '') || ':'
+            || count(*) FILTER (WHERE (q.payload->>'printbaar') = 'false'
+                                  AND nullif(q.payload->>'wachtTot', '') IS NOT NULL
+                                  AND (q.payload->>'wachtTot')::timestamptz <= now())
+       FROM public.pick_queue q WHERE q.cancelled_at IS NULL AND q.completed_at IS NULL),
+    (SELECT COALESCE(max(c.updated_at)::text, '') FROM public.order_carts c),
+    (SELECT COALESCE(max(o.updated_at)::text, '') FROM public.orders o));
+$function$;
+REVOKE ALL ON FUNCTION public.logistics_pickwachtrij_sig() FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_pickwachtrij_sig() TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_pickwachtrij_overslaan()
+ RETURNS boolean LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE v_sig text := public.logistics_pickwachtrij_sig(); v_oud text; v_wanneer timestamptz;
+BEGIN
+  SELECT cursor, bijgewerkt_op INTO v_oud, v_wanneer FROM public.logistics_werker_stand WHERE werker = 'pickwachtrij-vingerafdruk';
+  IF v_oud = v_sig AND v_wanneer > now() - interval '10 minutes' THEN RETURN true; END IF;
+  INSERT INTO public.logistics_werker_stand AS s (werker, cursor, bijgewerkt_op) VALUES ('pickwachtrij-vingerafdruk', v_sig, now())
+  ON CONFLICT (werker) DO UPDATE SET cursor = EXCLUDED.cursor, bijgewerkt_op = now();
+  RETURN false;
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_pickwachtrij_overslaan() FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_pickwachtrij_overslaan() TO service_role;
+
+-- 4. Voorraadmail: niet meer direct in de trigger, maar door de werker na commit (en minstens 2 minuten later).
+CREATE OR REPLACE FUNCTION public.logistics_stock_alert_email_trigger()
+ RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+BEGIN
+  -- E1-C/4: de melding blijft 'pending'; logistics_stock_email_klaarzetten zet hem pas na commit in de outbox.
+  RETURN NULL;
+END; $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_stock_email_klaarzetten(p_max integer DEFAULT 50)
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE r record; v_gezet int := 0; v_vervallen int := 0; v_fouten int := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_stock_email_klaarzetten');
+  IF public.logistics_uitgang_uit() THEN RETURN jsonb_build_object('overgeslagen', 'proefstand'); END IF;
+  FOR r IN
+    SELECT a.id, a.order_id, o.id AS o_id, o.deleted_at, o.cancelled_at, a.status
+      FROM public.logistics_stock_alerts a LEFT JOIN public.orders o ON o.id = a.order_id
+     WHERE a.email_status = 'pending' AND a.email_enabled AND a.created_at <= now() - interval '2 minutes'
+     ORDER BY a.created_at LIMIT greatest(COALESCE(p_max, 50), 1)
+  LOOP
+    BEGIN
+      IF r.status <> 'open' OR (r.order_id IS NOT NULL AND (r.o_id IS NULL OR r.deleted_at IS NOT NULL OR r.cancelled_at IS NOT NULL)) THEN
+        UPDATE public.logistics_stock_alerts SET email_status = 'skipped',
+               email_error = 'Niet verstuurd: de order bestaat niet meer of de melding is al afgehandeld.' WHERE id = r.id;
+        v_vervallen := v_vervallen + 1;
+      ELSE
+        PERFORM public.logistics_queue_stock_email(r.id);
+        v_gezet := v_gezet + 1;
+      END IF;
+    EXCEPTION WHEN OTHERS THEN
+      v_fouten := v_fouten + 1;
+      PERFORM public.logistics_melding('logistics_stock_email_klaarzetten', r.order_id,
+        'Voorraadmail kon niet worden klaargezet; de volgende ronde probeert het opnieuw', SQLERRM);
+    END;
+  END LOOP;
+  RETURN jsonb_build_object('klaargezet', v_gezet, 'vervallen', v_vervallen, 'fouten', v_fouten);
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_stock_email_klaarzetten(integer) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_stock_email_klaarzetten(integer) TO service_role;
+
+-- 1. Ophaalmoment: elke vervoerderswissel bepaalt het moment opnieuw (ook binnen een Engine-schrijfactie).
+CREATE OR REPLACE FUNCTION public.logistics_orders_pickup_moment()
+RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE n jsonb; v_basis jsonb;
+BEGIN
+  IF TG_OP = 'UPDATE' AND NEW.carrier_id IS DISTINCT FROM OLD.carrier_id THEN
+    -- E1-C/1: andere vervoerder = nieuw moment, tenzij de planning is vastgezet.
+    IF NEW.plan_locked_at IS NOT NULL THEN RETURN NEW; END IF;
+    BEGIN
+      v_basis := COALESCE(NEW.custom_fields, '{}'::jsonb) - 'pickup_moment' - 'pickup_moment_key' - 'pickup_moment_bron' - 'pickup_moment_reden';
+      n := public.logistics_pickup_cf_nieuw(v_basis, 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 na vervoerderswissel mislukt voor order %: %', NEW.id, SQLERRM;
+      PERFORM public.logistics_melding('logistics_orders_pickup_moment', NEW.id,
+        'Ophaalmoment kon na een vervoerderswissel niet opnieuw worden bepaald', SQLERRM);
+    END;
+    RETURN NEW;
+  END IF;
+  IF COALESCE(current_setting('logistics.pickup_writer', true), '') = 'engine' THEN RETURN NEW; END IF;
+  IF TG_OP = 'UPDATE'
+     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 $$;
+
+-- 1. Open orders waarvan het ophaalmoment niet past bij de huidige vervoerder.
+CREATE OR REPLACE FUNCTION public.logistics_pickup_afwijkend(p_voorbeelden integer DEFAULT 20)
+ RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE v_regel jsonb := public.logistics_pickup_regel(); v jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_pickup_afwijkend');
+  WITH o AS (
+    SELECT o.id, o.order_number, o.carrier_id, public.logistics_order_date(o.delivery_date::text) AS dag,
+           o.custom_fields->>'pickup_moment' AS huidig,
+           public.logistics_pickup_cf_nieuw(
+             o.custom_fields - 'pickup_moment' - 'pickup_moment_key' - 'pickup_moment_bron' - 'pickup_moment_reden',
+             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 o.plan_locked_at IS NULL AND o.carrier_id IS NOT NULL
+       AND coalesce(o.delivery_date, '') ~ '^\d{4}-\d{2}-\d{2}'
+       AND public.logistics_order_date(o.delivery_date::text) >= public.logistics_local_today()
+       AND COALESCE(o.custom_fields->>'pickup_moment_bron', '') <> 'handmatig'
+       AND NOT public.logistics_order_is_backfill(o.id)
+  ), a AS (
+    SELECT o.*, o.n->>'pickup_moment' AS verwacht
+      FROM o
+     WHERE o.n IS NOT NULL
+       AND public.logistics_pickup_ts(o.huidig, o.dag) IS DISTINCT FROM public.logistics_pickup_ts(o.n->>'pickup_moment', o.dag)
+  )
+  SELECT jsonb_build_object('aantal', (SELECT count(*) FROM a),
+    'voorbeelden', COALESCE((SELECT jsonb_agg(jsonb_build_object('order', order_number, 'orderId', id, 'huidig', huidig, 'verwacht', verwacht))
+                               FROM (SELECT * FROM a ORDER BY dag, order_number LIMIT greatest(COALESCE(p_voorbeelden, 20), 0)) x), '[]'::jsonb))
+    INTO v;
+  RETURN v;
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_pickup_afwijkend(integer) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_pickup_afwijkend(integer) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_pickup_herstel_voorbeeld()
+ RETURNS jsonb LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$ SELECT public.logistics_pickup_afwijkend(500) $function$;
+REVOKE ALL ON FUNCTION public.logistics_pickup_herstel_voorbeeld() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_pickup_herstel_voorbeeld() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_pickup_herstel_uitvoeren(p_max integer DEFAULT 500)
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE r jsonb; v_cf jsonb; o record; v_n jsonb; v_hersteld int := 0; v_fouten jsonb := '[]'::jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_pickup_herstel_uitvoeren');
+  FOR r IN SELECT jsonb_array_elements(public.logistics_pickup_afwijkend(greatest(COALESCE(p_max, 500), 1))->'voorbeelden') LOOP
+    BEGIN
+      SELECT * INTO o FROM public.orders WHERE id = (r->>'orderId')::uuid FOR UPDATE;
+      v_cf := COALESCE(o.custom_fields, '{}'::jsonb) - 'pickup_moment' - 'pickup_moment_key' - 'pickup_moment_bron' - 'pickup_moment_reden';
+      v_n := public.logistics_pickup_cf_nieuw(v_cf, o.carrier_id, o.delivery_date::text, o.deleted_at, o.cancelled_at, o.plan_locked_at, NULL);
+      IF v_n IS NOT NULL THEN
+        UPDATE public.orders SET custom_fields = v_n, updated_at = now() WHERE id = o.id;
+        INSERT INTO public.logistics_trace_events(phase, step, status, reason, order_ref, actor)
+        VALUES ('ophaalmoment', 'Ophaalmoment hersteld', 'geslaagd',
+                'Was ' || COALESCE(r->>'huidig', 'leeg') || ', nu ' || COALESCE(v_n->>'pickup_moment', 'leeg') || ' (past bij de huidige vervoerder).',
+                o.order_number, 'beheer');
+        v_hersteld := v_hersteld + 1;
+      END IF;
+    EXCEPTION WHEN OTHERS THEN
+      v_fouten := v_fouten || jsonb_build_array(jsonb_build_object('order', r->>'order', 'fout', SQLERRM));
+      PERFORM public.logistics_melding('logistics_pickup_herstel_uitvoeren', (r->>'orderId')::uuid, 'Ophaalmoment herstellen mislukt', SQLERRM);
+    END;
+  END LOOP;
+  RETURN jsonb_build_object('hersteld', v_hersteld, 'fouten', v_fouten, 'nogAfwijkend', (public.logistics_pickup_afwijkend(0)->>'aantal')::int);
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_pickup_herstel_uitvoeren(integer) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_pickup_herstel_uitvoeren(integer) TO service_role;
+
+-- A. "Al aangemeld" alleen voor de vervoerder waarbij de order echt is aangemeld.
+CREATE OR REPLACE FUNCTION public.logistics_carrier_frozen_reason(p_order_id uuid)
+ RETURNS text
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE v_locked timestamptz; v_carrier uuid; v_hit boolean;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_carrier_frozen_reason');
+  SELECT plan_locked_at, carrier_id INTO v_locked, v_carrier FROM public.orders WHERE id = p_order_id;
+  IF v_locked IS NOT NULL THEN RETURN 'de planning is vastgezet'; END IF;
+  BEGIN
+    IF public.logistics_order_is_frozen(p_order_id) THEN RETURN 'het picken is begonnen of de order staat op een vastgezette kar'; END IF;
+  EXCEPTION WHEN undefined_function OR undefined_table THEN NULL; END;
+  BEGIN
+    IF public.logistics_order_frozen(p_order_id) THEN RETURN 'de order is gepickt, gecontroleerd of afgemeld'; END IF;
+  EXCEPTION WHEN undefined_function OR undefined_table THEN NULL; END;
+  IF to_regprocedure('public.afh_order_aangemeld_bij(uuid,uuid)') IS NOT NULL THEN
+    -- E1-C/A: Afhandeling weet bij welke vervoerder de order echt is aangemeld.
+    IF v_carrier IS NULL THEN RETURN NULL; END IF;
+    BEGIN
+      EXECUTE 'SELECT public.afh_order_aangemeld_bij($1, $2)' INTO v_hit USING p_order_id, v_carrier;
+      IF COALESCE(v_hit, false) THEN RETURN 'de order is al bij deze vervoerder aangemeld'; END IF;
+    EXCEPTION WHEN OTHERS THEN
+      PERFORM public.logistics_melding('logistics_carrier_frozen_reason', p_order_id, 'Controle op vervoerdersaanmelding mislukt; de order is niet als aangemeld gezien', SQLERRM);
+    END;
+    RETURN NULL;
+  END IF;
+  IF to_regclass('public.carrier_signup_dispatches') IS NOT NULL THEN
+    BEGIN
+      EXECUTE 'SELECT EXISTS (SELECT 1 FROM public.carrier_signup_dispatches d
+                WHERE nullif(to_jsonb(d)->>''sent_at'', '''') IS NOT NULL
+                  AND coalesce(to_jsonb(d)->''order_ids'', ''[]''::jsonb) ? $1)'
+        INTO v_hit USING p_order_id::text;
+      IF v_hit THEN RETURN 'de order is al bij de vervoerder aangemeld'; END IF;
+    EXCEPTION WHEN OTHERS THEN
+    PERFORM public.logistics_melding('logistics_carrier_frozen_reason', NULL, 'Controle op vervoerdersaanmelding mislukt; de order is niet als aangemeld gezien', SQLERRM); END;
+  END IF;
+  RETURN NULL;
+END $function$;
+
+-- 2. Werkers: gespreide start, en bezette gegevens overslaan in plaats van wachten.
+CREATE OR REPLACE FUNCTION public.logistics_werker_draai(p_werker text, p_stappen jsonb)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_start timestamptz;
+  v_eind timestamptz;
+  v_n integer := jsonb_array_length(p_stappen);
+  v_begin integer := 0; v_i integer; s jsonb; v_t timestamptz; v_txt text;
+  v_uit jsonb := '[]'::jsonb; v_fouten integer := 0; v_uitgesteld integer := 0; v_eerste_uitgesteld integer; v_bezet integer := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_werker_draai');
+  IF NOT pg_try_advisory_xact_lock(hashtext('logistics_werker:' || p_werker)) THEN
+    RETURN jsonb_build_object('werker', p_werker, 'overgeslagen', 'vorige ronde van deze werker loopt nog');
+  END IF;
+  -- E1-C/2: vaste korte startverschuiving per werker (nooit meer dan 1 s), zodat ze niet tegelijk beginnen.
+  PERFORM pg_sleep(CASE p_werker WHEN 'pickwachtrij' THEN 0.3 WHEN 'taken' THEN 0.6 WHEN 'onderhoud' THEN 0.9 ELSE 0 END);
+  -- Bezette gegevens: na 1 s overslaan; de volgende ronde pakt het op.
+  PERFORM set_config('lock_timeout', '1000', true);
+  v_start := clock_timestamp();
+  v_eind := clock_timestamp() + make_interval(secs => public.logistics_werker_budget_ms() / 1000.0);
+  SELECT COALESCE(NULLIF(cursor, '')::integer, 0) INTO v_begin FROM public.logistics_werker_stand WHERE werker = p_werker;
+  v_begin := COALESCE(v_begin, 0) % GREATEST(v_n, 1);
+  FOR k IN 0 .. v_n - 1 LOOP
+    v_i := (v_begin + k) % v_n;
+    s := p_stappen -> v_i;
+    IF clock_timestamp() >= v_eind THEN
+      v_uitgesteld := v_uitgesteld + 1;
+      v_eerste_uitgesteld := COALESCE(v_eerste_uitgesteld, v_i);
+      v_uit := v_uit || jsonb_build_object('stap', s->>'naam', 'uitkomst', 'uitgesteld naar de volgende ronde');
+      CONTINUE;
+    END IF;
+    IF (s ? 'functie') AND to_regprocedure(s->>'functie') IS NULL THEN
+      v_uit := v_uit || jsonb_build_object('stap', s->>'naam', 'uitkomst', 'overgeslagen: onderdeel ontbreekt in deze omgeving');
+      CONTINUE;
+    END IF;
+    v_t := clock_timestamp();
+    BEGIN
+      EXECUTE format('SELECT (%s)::text', s->>'sql') INTO v_txt;
+      v_uit := v_uit || jsonb_build_object('stap', s->>'naam',
+        'ms', (extract(epoch FROM clock_timestamp() - v_t) * 1000)::int, 'uitkomst', left(COALESCE(v_txt, ''), 300));
+    EXCEPTION
+      WHEN lock_not_available THEN
+        v_bezet := v_bezet + 1;
+        v_uit := v_uit || jsonb_build_object('stap', s->>'naam',
+          'ms', (extract(epoch FROM clock_timestamp() - v_t) * 1000)::int, 'uitkomst', 'overgeslagen: gegevens even bezet, volgende ronde');
+      WHEN OTHERS THEN
+        v_fouten := v_fouten + 1;
+        v_uit := v_uit || jsonb_build_object('stap', s->>'naam',
+          'ms', (extract(epoch FROM clock_timestamp() - v_t) * 1000)::int, 'fout', left(SQLERRM, 300));
+        PERFORM public.logistics_melding('werker ' || p_werker, NULL,
+          'Stap "' || (s->>'naam') || '" mislukt; de volgende ronde probeert het opnieuw', SQLERRM);
+    END;
+  END LOOP;
+  PERFORM set_config('lock_timeout', '0', true);
+
+  INSERT INTO public.logistics_werker_stand AS w (werker, laatste_start, laatste_eind, laatste_duur_ms, uitgesteld, fouten, stappen, cursor, bijgewerkt_op)
+  VALUES (p_werker, v_start, clock_timestamp(), (extract(epoch FROM clock_timestamp() - v_start) * 1000)::int,
+          v_uitgesteld, v_fouten, v_uit, COALESCE(v_eerste_uitgesteld, 0)::text, now())
+  ON CONFLICT (werker) DO UPDATE
+     SET laatste_start = EXCLUDED.laatste_start, laatste_eind = EXCLUDED.laatste_eind,
+         laatste_duur_ms = EXCLUDED.laatste_duur_ms, uitgesteld = EXCLUDED.uitgesteld, fouten = EXCLUDED.fouten,
+         stappen = EXCLUDED.stappen, cursor = EXCLUDED.cursor, bijgewerkt_op = now();
+
+  RETURN jsonb_build_object('werker', p_werker, 'duurMs', (extract(epoch FROM clock_timestamp() - v_start) * 1000)::int,
+    'uitgesteld', v_uitgesteld, 'fouten', v_fouten, 'bezet', v_bezet, 'stappen', v_uit);
+END $function$;
+
+-- 4/5. Pickwachtrij-werker zet voorraadmails klaar; planningswerker neemt de bufferbesluiten over van de oude taak.
+CREATE OR REPLACE FUNCTION public.logistics_werker_pickwachtrij()
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_werker_pickwachtrij');
+  RETURN public.logistics_werker_draai('pickwachtrij', jsonb_build_array(
+    jsonb_build_object('naam', 'Orders afronden', 'sql', 'public.logistics_order_finalize_run(25, 120)'),
+    jsonb_build_object('naam', 'Pickwachtrij bijwerken', 'sql', 'public.logistics_sync_pick_queue()'),
+    jsonb_build_object('naam', 'Laadtoestand', 'sql', 'public.logistics_refresh_plan_state_als_nodig()'),
+    jsonb_build_object('naam', 'Verzendbrieven aanvullen', 'sql', 'public.logistics_ensure_shipping_notes(200)'),
+    jsonb_build_object('naam', 'Verkeerde verzendbrieven herstellen', 'sql', 'public.logistics_fix_wrong_shipping_notes()'),
+    jsonb_build_object('naam', 'Verzendbrieven vrijgeven', 'sql', 'public.logistics_shipping_note_release(NULL::text)'),
+    jsonb_build_object('naam', 'Verzendbrieven na acceptatie', 'sql', 'public.logistics_shipping_note_ensure_accepted(NULL::uuid, 100)'),
+    jsonb_build_object('naam', 'Voorraadmails klaarzetten', 'sql', 'public.logistics_stock_email_klaarzetten(50)'),
+    jsonb_build_object('naam', 'Status voorraadmails', 'sql', 'public.logistics_sync_stock_alert_email_status(500)'),
+    jsonb_build_object('naam', 'Printopdrachten zonder kar', 'sql', 'public.logistics_cleanup_orphan_print_jobs()'),
+    jsonb_build_object('naam', 'Barcodeverzoeken', 'sql', 'public.logistics_fulfill_barcode_requests(100)')
+  ));
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_werker_planning()
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_werker_planning');
+  RETURN public.logistics_werker_draai('planning', jsonb_build_array(
+    jsonb_build_object('naam', 'Werkset bijwerken', 'sql', 'public.logistics_werkset_herstel(500)'),
+    jsonb_build_object('naam', 'Ophaalmomenten verversen', 'sql', 'public.logistics_refresh_pickup_moments(4)'),
+    jsonb_build_object('naam', 'Wees-taken afsluiten', 'sql', 'public.logistics_cancel_orphan_tasks()'),
+    jsonb_build_object('naam', 'Ontbrekende orders aanmelden', 'sql', 'public.logistics_reconcile_missing_plan_queue()'),
+    jsonb_build_object('naam', 'Vervoerders bepalen', 'sql', 'public.logistics_carrier_recalc_run(50)'),
+    jsonb_build_object('naam', 'Herindelen na wijziging', 'sql', 'public.logistics_rebuffer_pending()'),
+    jsonb_build_object('naam', 'Bufferbesluiten', 'sql', 'public.logistics_reapply_buffer_decisions()'),
+    jsonb_build_object('naam', 'Dubbele bufferregels opruimen', 'sql', 'public.logistics_prune_buffer_member_queue()'),
+    jsonb_build_object('naam', 'Afgehandelde buffers sluiten', 'sql', 'public.logistics_buffer_detach_late_orders(NULL::uuid)'),
+    jsonb_build_object('naam', 'Orders zonder kar bewaken', 'sql', 'public.logistics_bewaak_zonder_kar()'),
+    jsonb_build_object('naam', 'Planwachtrij opruimen', 'sql', 'public.logistics_plan_housekeeping()'),
+    jsonb_build_object('naam', 'Karindeling onderhoud', 'sql', 'public.logistics_karindeling_onderhoud()')
+  ));
+END $function$;
+
+-- 3. Logboek: technische regels niet zichtbaar; bekende gebeurtenissen in gewone taal.
+CREATE OR REPLACE FUNCTION public.logistics_logboek_tekst(p_tabel text, p_actie text)
+ RETURNS text LANGUAGE sql IMMUTABLE SET search_path TO 'public'
+AS $function$
+  SELECT CASE
+    WHEN p_tabel = 'order_carts' AND p_actie = 'UPDATE' THEN 'Kar opnieuw ingedeeld'
+    WHEN p_tabel = 'order_carts' AND p_actie = 'DELETE' THEN 'Kar vervallen'
+    WHEN p_tabel = 'pick_queue' AND p_actie = 'INSERT' THEN 'Kar in de pickwachtrij gezet'
+    WHEN p_tabel = 'pick_queue' AND p_actie = 'UPDATE' THEN 'Pickwachtrij bijgewerkt'
+    WHEN p_tabel = 'logistics_plan_queue' AND p_actie = 'INSERT' THEN 'Indeling aangevraagd'
+    ELSE NULL END
+$function$;
+REVOKE ALL ON FUNCTION public.logistics_logboek_tekst(text, text) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_logboek_tekst(text, text) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_logboek_doorsturen()
+ RETURNS trigger
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_fout boolean := (NEW.status = 'mislukt' OR NEW.error IS NOT NULL);
+  -- Vaste momenten en de markering 'ingehaald' altijd bewaren (Golf 1 / 8, M, 14).
+  v_altijd boolean := (COALESCE(NEW.node_id, '') = 'stap:afmelden' OR COALESCE(NEW.decision, '') IN ('ingehaald', 'toch indelen'));
+  v_order_id uuid; v_leverdag text; v_vervalt date; v_vorige record; v_tekst text;
+BEGIN
+  -- E1-C/3: technische regels ("tabel INSERT/UPDATE") niet bewaren; bekende gebeurtenissen in gewone taal.
+  IF NEW.step ~ '^[a-z_]+ (INSERT|UPDATE|DELETE)$' OR COALESCE(NEW.actor, '') LIKE 'database:%' THEN
+    v_tekst := public.logistics_logboek_tekst(COALESCE(NEW.db_table, split_part(NEW.step, ' ', 1)),
+                                               COALESCE(NEW.db_action, split_part(NEW.step, ' ', 2)));
+    IF NEW.step ~ '^[a-z_]+ (INSERT|UPDATE|DELETE)$' THEN
+      IF v_tekst IS NULL AND NOT v_fout THEN RETURN NULL; END IF;
+      NEW.step := COALESCE(v_tekst, 'Wijziging kon niet worden opgeslagen');
+    END IF;
+    NEW.actor := 'systeem';
+  END IF;
+  IF NEW.order_ref IS NOT NULL THEN
+    IF NOT v_fout AND NOT v_altijd THEN
+      SELECT o.id, o.delivery_date::text INTO v_order_id, v_leverdag
+        FROM public.orders o WHERE o.order_number = NEW.order_ref
+       ORDER BY o.created_at DESC LIMIT 1;
+      IF v_order_id IS NOT NULL AND (public.logistics_order_is_backfill(v_order_id)
+           OR public.logistics_order_date(v_leverdag) < public.logistics_local_today() - 1) THEN
+        RETURN NULL;
+      END IF;
+    END IF;
+    IF NEW.actor = 'afgeleid' AND NEW.node_id IS NOT NULL THEN
+      IF EXISTS (SELECT 1 FROM public.logistics_logboek_alles a
+                  WHERE a.order_ref = NEW.order_ref AND a.node_id = NEW.node_id AND a.actor = 'afgeleid') THEN
+        RETURN NULL;
+      END IF;
+    ELSE
+      SELECT a.status, a.decision, a.reason, a.error, a.db_old, a.db_new, a.output INTO v_vorige
+        FROM public.logistics_logboek_alles a
+       WHERE a.order_ref = NEW.order_ref AND a.step IS NOT DISTINCT FROM NEW.step
+       ORDER BY a.created_at DESC LIMIT 1;
+      IF FOUND
+         AND v_vorige.status IS NOT DISTINCT FROM NEW.status
+         AND v_vorige.decision IS NOT DISTINCT FROM NEW.decision
+         AND v_vorige.reason IS NOT DISTINCT FROM NEW.reason
+         AND v_vorige.error IS NOT DISTINCT FROM NEW.error
+         AND v_vorige.db_old IS NOT DISTINCT FROM NEW.db_old
+         AND v_vorige.db_new IS NOT DISTINCT FROM NEW.db_new
+         AND v_vorige.output IS NOT DISTINCT FROM NEW.output THEN
+        RETURN NULL;
+      END IF;
+    END IF;
+  END IF;
+
+  v_vervalt := (COALESCE(NEW.created_at, now()) AT TIME ZONE public.logistics_tz())::date
+             + public.logistics_retention_days(CASE WHEN v_fout THEN 'trace_error_retention_days' ELSE 'trace_retention_days' END);
+  PERFORM public.logistics_logboek_partitie(v_vervalt);
+
+  INSERT INTO public.logistics_logboek (
+    id, trace_id, order_ref, order_source, cart_ref, slip_ref, phase, step, status, actor,
+    input, output, reads, decision, reason, values_used, rule, db_table, db_record, db_action, db_old, db_new,
+    external_system, external_action, external_ref, external_status, external_response,
+    error, attempts, next_attempt_at, duration_ms, created_at, node_id, error_class, calc, next_step, vervalt_op)
+  VALUES (
+    COALESCE(NEW.id, gen_random_uuid()), NEW.trace_id, NEW.order_ref, NEW.order_source, NEW.cart_ref, NEW.slip_ref,
+    NEW.phase, NEW.step, NEW.status, NEW.actor, NEW.input, NEW.output, NEW.reads, NEW.decision, NEW.reason,
+    NEW.values_used, NEW.rule, NEW.db_table, NEW.db_record, NEW.db_action, NEW.db_old, NEW.db_new,
+    NEW.external_system, NEW.external_action, NEW.external_ref, NEW.external_status, NEW.external_response,
+    NEW.error, NEW.attempts, NEW.next_attempt_at, NEW.duration_ms, COALESCE(NEW.created_at, now()),
+    NEW.node_id, NEW.error_class, NEW.calc, NEW.next_step, v_vervalt);
+  RETURN NULL;
+EXCEPTION WHEN OTHERS THEN
+  PERFORM public.logistics_melding('logistics_logboek_doorsturen', v_order_id,
+    'Logboekregel kon niet worden bewaard; de verwerking ging door', SQLERRM);
+  RETURN NULL;
+END $function$;
+
+-- 9. Stand van de indeling per order.
+CREATE OR REPLACE FUNCTION public.logistics_order_indeling_stand(p_order_id uuid)
+ RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_regels int; v_karren int; v_open timestamptz; v_laatst record; v_fp record; v_bij timestamptz;
+  v_verouderd jsonb; v_reden text; v_volgende timestamptz := date_trunc('minute', now()) + interval '1 minute';
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_order_indeling_stand');
+  SELECT count(*) INTO v_regels FROM logistics_active.order_items oi WHERE oi.order_id = p_order_id;
+  IF COALESCE(v_regels, 0) = 0 THEN
+    RETURN jsonb_build_object('stand', 'geen_regels', 'bezig_sinds', NULL, 'bijgewerkt_op', NULL, 'verwacht_klaar', NULL,
+      'tekst', 'Deze order heeft nog geen regels om in te delen.');
+  END IF;
+  SELECT min(q.enqueued_at) INTO v_open FROM public.logistics_plan_queue q
+   WHERE q.order_id = p_order_id AND q.status NOT IN ('done','geblokkeerd','opgelost','gearchiveerd');
+  SELECT q.status, q.error, q.reason_code, q.updated_at INTO v_laatst FROM public.logistics_plan_queue q
+   WHERE q.order_id = p_order_id ORDER BY q.updated_at DESC NULLS LAST LIMIT 1;
+  SELECT f.uitkomst, f.bijgewerkt_op INTO v_fp FROM public.logistics_plan_vingerafdruk f WHERE f.order_id = p_order_id;
+  SELECT count(DISTINCT c.id), max(c.updated_at) INTO v_karren, v_bij FROM logistics_active.order_carts c
+   WHERE c.order_id = p_order_id
+      OR EXISTS (SELECT 1 FROM logistics_active.order_cart_items ci JOIN public.order_items oi ON oi.id = ci.order_item_id
+                  WHERE ci.cart_id = c.id AND oi.order_id = p_order_id);
+  v_bij := GREATEST(v_bij, CASE WHEN v_fp.uitkomst IS DISTINCT FROM 'geblokkeerd' THEN v_fp.bijgewerkt_op END);
+
+  IF v_open IS NOT NULL THEN
+    RETURN jsonb_build_object('stand', 'bezig', 'bezig_sinds', v_open, 'bijgewerkt_op', v_bij, 'verwacht_klaar', v_volgende,
+      'tekst', 'Indeling wordt gemaakt');
+  END IF;
+  IF v_laatst.status = 'geblokkeerd' THEN
+    v_reden := CASE WHEN v_laatst.error IS NULL OR v_laatst.error ~* '(error|sqlstate|function|relation|column|syntax|violates|null value|timeout|exception|[a-z]+_[a-z_]+\()'
+                    THEN 'De indeling kon niet worden gemaakt. Probeer het later opnieuw of neem contact op met de beheerder.'
+                    ELSE v_laatst.error END;
+    RETURN jsonb_build_object('stand', 'niet_gelukt', 'bezig_sinds', NULL, 'bijgewerkt_op', v_bij, 'verwacht_klaar', NULL,
+      'tekst', v_reden);
+  END IF;
+  v_verouderd := public.logistics_order_indeling_verouderd_core(p_order_id);
+  IF COALESCE((v_verouderd->>'verouderd')::boolean, false) OR COALESCE(v_karren, 0) = 0 THEN
+    RETURN jsonb_build_object('stand', 'bezig', 'bezig_sinds', COALESCE(v_laatst.updated_at, now()), 'bijgewerkt_op', v_bij,
+      'verwacht_klaar', v_volgende, 'tekst', 'Indeling wordt gemaakt');
+  END IF;
+  RETURN jsonb_build_object('stand', 'klaar', 'bezig_sinds', NULL, 'bijgewerkt_op', v_bij, 'verwacht_klaar', NULL,
+    'tekst', 'Indeling is bijgewerkt' || COALESCE(' om ' || public.logistics_local_hhmi(v_bij), ''));
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_order_indeling_stand(uuid) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_order_indeling_stand(uuid) TO authenticated, service_role;
+
+-- 10. Kar-tekening.
+CREATE OR REPLACE FUNCTION public.logistics_xml(p text)
+ RETURNS text LANGUAGE sql IMMUTABLE SET search_path TO 'public'
+AS $function$
+  SELECT replace(replace(replace(replace(replace(COALESCE(p, ''), '&', '&amp;'), '<', '&lt;'), '>', '&gt;'), '"', '&quot;'), '''', '&apos;')
+$function$;
+REVOKE ALL ON FUNCTION public.logistics_xml(text) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_xml(text) TO authenticated, service_role;
+
+-- Klantkleuren: instelling in de werkwijze (alleen namen van themakleuren), anders veilige standaardlijst.
+CREATE OR REPLACE FUNCTION public.logistics_klantkleuren()
+ RETURNS text[] LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+  WITH bron AS (
+    SELECT NULLIF(COALESCE(rc.settings->'karrenindeling'->'fields'->>'klantkleuren', rc.settings->'karrenindeling'->>'klantkleuren'), '') AS v
+      FROM public.logistics_rule_configs rc
+      LEFT JOIN public.logistics_strategies s ON s.id = rc.strategy_id
+     ORDER BY (rc.is_active AND coalesce(s.is_active, false)) DESC, rc.is_active DESC, rc.updated_at DESC NULLS LAST
+     LIMIT 1),
+  k AS (
+    SELECT array_agg('var(' || t || ')' ORDER BY n) AS l
+      FROM bron, regexp_split_to_table(bron.v, '\s*,\s*') WITH ORDINALITY AS x(t, n)
+     WHERE t ~ '^--[a-z0-9-]{1,40}$')
+  SELECT CASE WHEN COALESCE(cardinality(k.l), 0) > 0 THEN k.l
+              ELSE ARRAY['var(--chart-1)','var(--chart-2)','var(--chart-3)','var(--chart-4)','var(--chart-5)'] END
+    FROM k
+$function$;
+REVOKE ALL ON FUNCTION public.logistics_klantkleuren() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_klantkleuren() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_kar_tekening(p_order_id uuid, p_opties jsonb DEFAULT '{}'::jsonb)
+ RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_stand jsonb; v_opt jsonb := COALESCE(p_opties, '{}'::jsonb); v_pakbon boolean;
+  v_kleuren text[] := public.logistics_klantkleuren();
+  v_order record; v_fase text; v_fl jsonb; v_fl_bron boolean;
+  c record; v_totaal int; v_nr int := 0; v_soort text; v_woord text; v_max int;
+  v_letters jsonb; v_lagen jsonb; v_laag jsonb; v_blokken jsonb; it record; v_cur int; v_span int; i int;
+  v_svg text; v_y numeric; v_h numeric; v_x numeric; v_w numeric; v_som numeric; b jsonb; v_kleur text; v_tekst text;
+  v_status text; v_waarsch jsonb; v_gedeeld int; v_dragers jsonb := '[]'::jsonb; v_rij text := ''; v_label text;
+  v_fusten int; v_n int; v_m int; v_cellen int; v_fl_kar text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_kar_tekening');
+  v_pakbon := COALESCE(v_opt->>'vorm', '') = 'pakbon';
+  v_stand := public.logistics_order_indeling_stand(p_order_id);
+  SELECT o.id, o.order_number, o.status, o.order_source, o.floriday_sales_order_id INTO v_order FROM public.orders o WHERE o.id = p_order_id;
+  v_fase := public.logistics_status_fase(v_order.status);
+  v_fl_bron := v_order.floriday_sales_order_id IS NOT NULL OR COALESCE(v_order.order_source, '') ILIKE '%floriday%';
+  IF v_fl_bron THEN v_fl := public.logistics_floriday_gelijk(p_order_id); END IF;
+
+  SELECT count(*) INTO v_totaal FROM (
+    SELECT DISTINCT c2.id FROM logistics_active.order_carts c2
+     WHERE c2.order_id = p_order_id
+        OR EXISTS (SELECT 1 FROM logistics_active.order_cart_items ci JOIN public.order_items oi ON oi.id = ci.order_item_id
+                    WHERE ci.cart_id = c2.id AND oi.order_id = p_order_id)) x;
+
+  FOR c IN
+    SELECT DISTINCT ON (c2.cart_number, c2.id) c2.id, c2.cart_number, c2.occupancy_pct, c2.total_layers_used, c2.max_layers, c2.weight_kg,
+           COALESCE(t.capacity_model, 'layered') AS soort, COALESCE(t.name, c2.carrier_type, 'Ladingdrager') AS naam,
+           t.layers_per_carrier, t.max_crates_per_layer, t.max_weight_kg
+      FROM logistics_active.order_carts c2
+      LEFT JOIN public.load_carrier_types t ON t.id = c2.carrier_type_id
+     WHERE c2.order_id = p_order_id
+        OR EXISTS (SELECT 1 FROM logistics_active.order_cart_items ci JOIN public.order_items oi ON oi.id = ci.order_item_id
+                    WHERE ci.cart_id = c2.id AND oi.order_id = p_order_id)
+     ORDER BY c2.cart_number, c2.id
+  LOOP
+    v_nr := v_nr + 1;
+    CONTINUE WHEN (v_opt ? 'drager_id') AND (v_opt->>'drager_id') <> c.id::text;
+    v_soort := CASE WHEN c.soort IN ('layered','stacked','single','none') THEN c.soort ELSE 'layered' END;
+    v_woord := CASE v_soort WHEN 'layered' THEN 'Kar' WHEN 'none' THEN 'Colli' ELSE 'Pallet' END;
+    v_max := GREATEST(1, COALESCE(c.max_layers, c.layers_per_carrier, CEIL(COALESCE(c.total_layers_used, 1))::int, 1));
+
+    -- Klantletters per order op deze drager: eigen order eerst (A).
+    SELECT COALESCE(jsonb_object_agg(order_id::text, chr((64 + rn)::int)), '{}'::jsonb) INTO v_letters FROM (
+      SELECT oi.order_id, row_number() OVER (ORDER BY (oi.order_id = p_order_id) DESC, min(o2.order_number)) AS rn
+        FROM public.order_cart_items ci JOIN public.order_items oi ON oi.id = ci.order_item_id
+        JOIN public.orders o2 ON o2.id = oi.order_id
+       WHERE ci.cart_id = c.id GROUP BY oi.order_id) l;
+    SELECT count(DISTINCT oi.order_id) FILTER (WHERE oi.order_id <> p_order_id) INTO v_gedeeld
+      FROM public.order_cart_items ci JOIN public.order_items oi ON oi.id = ci.order_item_id WHERE ci.cart_id = c.id;
+
+    -- Lagen opbouwen: met laagnummer per regel, anders opeenvolgend volgens het aantal lagen per regel.
+    v_lagen := '[]'::jsonb;
+    FOR i IN 1 .. v_max LOOP
+      v_lagen := v_lagen || jsonb_build_array(jsonb_build_object('index', i, 'hoogte_aandeel', round(1.0 / v_max, 4), 'blokken', '[]'::jsonb));
+    END LOOP;
+    v_cur := 1;
+    FOR it IN
+      SELECT ci.id, ci.layer_index, COALESCE(ci.crates_in_layer, ci.crates, ci.boxes, 0) AS fusten, ci.lagen, ci.layer_fraction,
+             COALESCE(ci.product_name, oi.product_name, 'Product') AS product, oi.order_id
+        FROM public.order_cart_items ci LEFT JOIN public.order_items oi ON oi.id = ci.order_item_id
+       WHERE ci.cart_id = c.id ORDER BY ci.layer_index NULLS LAST, ci.created_at, ci.id
+    LOOP
+      IF it.layer_index IS NOT NULL THEN v_cur := it.layer_index; v_span := 1;
+      ELSE v_span := GREATEST(1, CEIL(COALESCE(it.lagen, it.layer_fraction, 1))::int); END IF;
+      FOR i IN v_cur .. v_cur + v_span - 1 LOOP
+        IF i > jsonb_array_length(v_lagen) THEN
+          v_lagen := v_lagen || jsonb_build_array(jsonb_build_object('index', i, 'hoogte_aandeel', 0, 'blokken', '[]'::jsonb));
+        END IF;
+        b := CASE WHEN it.order_id = p_order_id
+                  THEN jsonb_build_object('klantletter', v_letters->>it.order_id::text, 'product', it.product,
+                                          'fusten', CEIL(it.fusten::numeric / v_span)::int, 'eigen_order', true)
+                  ELSE jsonb_build_object('klantletter', NULL, 'product', NULL,
+                                          'fusten', CEIL(it.fusten::numeric / v_span)::int, 'eigen_order', false) END;
+        v_lagen := jsonb_set(v_lagen, ARRAY[(i - 1)::text, 'blokken'], (v_lagen->(i - 1)->'blokken') || jsonb_build_array(b));
+      END LOOP;
+      IF it.layer_index IS NULL THEN v_cur := v_cur + v_span; END IF;
+    END LOOP;
+    -- Gelijke hoogtes als er meer lagen zijn ontstaan dan het maximum.
+    IF jsonb_array_length(v_lagen) > v_max THEN
+      SELECT jsonb_agg(jsonb_set(l, '{hoogte_aandeel}', to_jsonb(round(1.0 / jsonb_array_length(v_lagen), 4))) ORDER BY n) INTO v_lagen
+        FROM jsonb_array_elements(v_lagen) WITH ORDINALITY x(l, n);
+    END IF;
+    SELECT COALESCE(sum((bb->>'fusten')::int), 0) INTO v_fusten
+      FROM jsonb_array_elements(v_lagen) l, jsonb_array_elements(l->'blokken') bb;
+
+    -- Status uit bestaande pick- en controlegegevens.
+    v_status := CASE
+      WHEN v_fase IN ('verzonden','gereed_voor_facturatie','gefactureerd','afgehandeld_floriday') THEN 'afgemeld'
+      WHEN public.logistics_cart_scanned(c.id) THEN 'gecontroleerd'
+      WHEN EXISTS (SELECT 1 FROM public.pick_queue q WHERE q.reference = c.id::text AND q.cancelled_at IS NULL AND q.completed_at IS NOT NULL) THEN 'gepickt'
+      WHEN EXISTS (SELECT 1 FROM public.pick_queue q WHERE q.reference = c.id::text AND q.cancelled_at IS NULL AND q.printed_at IS NOT NULL) THEN 'geprint'
+      WHEN EXISTS (SELECT 1 FROM public.pick_queue q WHERE q.reference = c.id::text AND q.cancelled_at IS NULL AND (q.payload->>'printbaar') = 'true') THEN 'vrijgegeven'
+      ELSE 'open' END;
+
+    v_waarsch := '[]'::jsonb;
+    IF c.max_weight_kg IS NOT NULL AND c.weight_kg IS NOT NULL AND c.weight_kg > c.max_weight_kg THEN
+      v_waarsch := v_waarsch || to_jsonb(v_woord || ' is te zwaar: ' || round(c.weight_kg) || ' kg, maximaal ' || round(c.max_weight_kg) || ' kg');
+    END IF;
+    IF COALESCE(c.occupancy_pct, 0) > 100 THEN
+      v_waarsch := v_waarsch || to_jsonb(v_woord || ' is voller dan toegestaan (' || round(c.occupancy_pct) || '%)');
+    END IF;
+    IF jsonb_array_length(v_lagen) > v_max THEN
+      v_waarsch := v_waarsch || to_jsonb('Er zijn meer lagen gevuld dan de ' || lower(v_woord) || ' heeft');
+    END IF;
+
+    v_fl_kar := NULL;
+    IF v_fl_bron THEN
+      SELECT COALESCE(e->>'uitkomst', e->>'stand') INTO v_fl_kar
+        FROM jsonb_array_elements(CASE WHEN jsonb_typeof(v_fl->'karren') = 'array' THEN v_fl->'karren' ELSE '[]'::jsonb END) e
+       WHERE COALESCE(e->>'cartId', e->>'kar_id', e->>'id') = c.id::text LIMIT 1;
+      v_fl_kar := COALESCE(v_fl_kar, v_fl->>'uitkomst', v_fl->>'stand');
+    END IF;
+
+    v_label := CASE WHEN v_soort = 'none' THEN 'Colli 1–' || GREATEST(v_fusten, 1)
+                    ELSE v_woord || ' ' || v_nr || ' van ' || v_totaal END;
+
+    -- SVG: alleen themakleuren, alle tekst ge-escaped, geen scripts of externe verwijzingen.
+    v_svg := '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 200 260" role="img" aria-label="' || public.logistics_xml(v_label || ', ' || c.naam) || '">'
+          || '<title>' || public.logistics_xml(v_label || ' – ' || c.naam) || '</title>'
+          || '<rect x="1" y="1" width="198" height="258" rx="6" fill="var(--card)" stroke="var(--border)"/>'
+          || '<text x="10" y="18" font-size="12" fill="var(--foreground)">' || public.logistics_xml(v_label) || '</text>';
+    IF v_soort = 'layered' THEN
+      v_y := 240; v_h := 210.0 / GREATEST(jsonb_array_length(v_lagen), 1);
+      FOR i IN 0 .. jsonb_array_length(v_lagen) - 1 LOOP
+        v_laag := v_lagen->i; v_y := v_y - v_h;
+        v_svg := v_svg || '<line x1="10" y1="' || round(v_y + v_h, 1) || '" x2="190" y2="' || round(v_y + v_h, 1) || '" stroke="var(--muted-foreground)" stroke-width="2"/>';
+        SELECT COALESCE(sum((bb->>'fusten')::int), 0) INTO v_som FROM jsonb_array_elements(v_laag->'blokken') bb;
+        v_som := GREATEST(v_som, COALESCE(c.max_crates_per_layer, 0), 1); v_x := 12;
+        FOR b IN SELECT * FROM jsonb_array_elements(v_laag->'blokken') LOOP
+          v_w := 176.0 * (b->>'fusten')::numeric / v_som;
+          v_kleur := CASE WHEN (b->>'eigen_order')::boolean
+                          THEN v_kleuren[1 + ((ascii(COALESCE(b->>'klantletter', 'A')) - 65) % cardinality(v_kleuren))]
+                          ELSE 'var(--muted)' END;
+          v_svg := v_svg || '<rect x="' || round(v_x, 1) || '" y="' || round(v_y + 2, 1) || '" width="' || round(GREATEST(v_w - 2, 1), 1)
+                || '" height="' || round(GREATEST(v_h - 4, 1), 1) || '" rx="2" fill="' || v_kleur || '" stroke="var(--border)"/>';
+          IF NOT v_pakbon AND v_w >= 24 AND v_h >= 12 THEN
+            v_tekst := CASE WHEN (b->>'eigen_order')::boolean THEN COALESCE(b->>'klantletter', '') || ' ' || (b->>'fusten') ELSE (b->>'fusten') END;
+            v_svg := v_svg || '<text x="' || round(v_x + 3, 1) || '" y="' || round(v_y + v_h / 2 + 4, 1) || '" font-size="9" fill="var(--foreground)">'
+                  || public.logistics_xml(v_tekst) || '</text>';
+          END IF;
+          v_x := v_x + v_w;
+        END LOOP;
+      END LOOP;
+    ELSIF v_soort = 'stacked' THEN
+      v_n := GREATEST(1, COALESCE(c.max_crates_per_layer, 4)); v_m := GREATEST(1, CEIL(v_fusten::numeric / v_n)::int);
+      v_h := LEAST(30, 200.0 / v_m);
+      FOR i IN 0 .. v_m - 1 LOOP
+        FOR v_cur IN 0 .. LEAST(v_n, v_fusten - i * v_n) - 1 LOOP
+          v_svg := v_svg || '<rect x="' || round(12 + v_cur * (176.0 / v_n), 1) || '" y="' || round(232 - (i + 1) * v_h, 1)
+                || '" width="' || round(176.0 / v_n - 2, 1) || '" height="' || round(v_h - 2, 1) || '" fill="' || v_kleuren[1] || '" stroke="var(--border)"/>';
+        END LOOP;
+      END LOOP;
+      v_svg := v_svg || '<rect x="8" y="234" width="184" height="8" fill="var(--muted-foreground)"/>'
+            || '<text x="10" y="254" font-size="10" fill="var(--foreground)">' || public.logistics_xml(v_n || ' dozen per laag × ' || v_m || ' lagen') || '</text>';
+    ELSIF v_soort = 'single' THEN
+      SELECT string_agg(DISTINCT bb->>'product', ', ') INTO v_tekst
+        FROM jsonb_array_elements(v_lagen) l, jsonb_array_elements(l->'blokken') bb WHERE (bb->>'eigen_order')::boolean;
+      v_svg := v_svg || '<rect x="20" y="40" width="160" height="180" rx="4" fill="' || v_kleuren[1] || '" stroke="var(--border)"/>'
+            || '<text x="28" y="130" font-size="11" fill="var(--foreground)">' || public.logistics_xml(left(COALESCE(v_tekst, 'Product'), 28)) || '</text>'
+            || '<text x="28" y="148" font-size="11" fill="var(--foreground)">' || public.logistics_xml(v_fusten || ' stuks') || '</text>';
+    ELSE
+      v_cellen := LEAST(GREATEST(v_fusten, 1), 60);
+      FOR i IN 0 .. v_cellen - 1 LOOP
+        v_svg := v_svg || '<rect x="' || (12 + (i % 6) * 30) || '" y="' || (28 + (i / 6) * 22) || '" width="26" height="18" rx="2" fill="' || v_kleuren[1] || '" stroke="var(--border)"/>'
+              || '<text x="' || (16 + (i % 6) * 30) || '" y="' || (41 + (i / 6) * 22) || '" font-size="9" fill="var(--foreground)">' || (i + 1) || '</text>';
+      END LOOP;
+    END IF;
+    IF v_gedeeld > 0 THEN
+      v_svg := v_svg || '<text x="10" y="32" font-size="9" fill="var(--muted-foreground)">'
+            || public.logistics_xml('gedeeld met ' || v_gedeeld || CASE WHEN v_gedeeld = 1 THEN ' andere order' ELSE ' andere orders' END) || '</text>';
+    END IF;
+    v_svg := v_svg || '</svg>';
+    v_rij := v_rij || '<g transform="translate(' || ((v_nr - 1) * 70) || ',0) scale(0.33)">' || substr(v_svg, position('>' IN v_svg) + 1, length(v_svg) - position('>' IN v_svg) - 6) || '</g>';
+
+    v_dragers := v_dragers || jsonb_build_array(jsonb_build_object(
+      'id', c.id, 'nummer', v_nr, 'totaal', v_totaal, 'soort', v_soort, 'naam', c.naam,
+      'vulgraad_pct', CASE WHEN c.occupancy_pct IS NOT NULL THEN round(c.occupancy_pct) END,
+      'lagen_gebruikt', CASE WHEN c.total_layers_used IS NOT NULL THEN round(c.total_layers_used, 1) END,
+      'lagen_max', CASE WHEN v_soort IN ('layered','stacked') THEN v_max END,
+      'gewicht_kg', CASE WHEN c.weight_kg IS NOT NULL THEN round(c.weight_kg, 1) END,
+      'status', v_status, 'floriday_gelijk', v_fl_kar, 'gedeeld_met', v_gedeeld,
+      'waarschuwingen', v_waarsch, 'lagen', v_lagen, 'svg', v_svg));
+  END LOOP;
+
+  RETURN jsonb_build_object(
+    'stand', v_stand->'stand', 'bezig_sinds', v_stand->'bezig_sinds', 'bijgewerkt_op', v_stand->'bijgewerkt_op',
+    'verwacht_klaar', v_stand->'verwacht_klaar', 'tekst', v_stand->'tekst',
+    'svg_rij', CASE WHEN jsonb_array_length(v_dragers) = 0 THEN NULL
+                    ELSE '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ' || GREATEST(jsonb_array_length(v_dragers) * 70, 70)
+                         || ' 90" role="img" aria-label="Overzicht van ' || jsonb_array_length(v_dragers) || ' ladingdragers"><title>Overzicht ladingdragers</title>'
+                         || v_rij || '</svg>' END,
+    'dragers', v_dragers);
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_kar_tekening(uuid, jsonb) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_kar_tekening(uuid, jsonb) TO authenticated, service_role;
+
+-- Installatiecontrole E1-C (alleen lezen).
+CREATE OR REPLACE FUNCTION public.logistics_install_check_e1c()
+ RETURNS TABLE(onderdeel text, ok boolean, toelichting text)
+ LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE f text; v_order uuid; v jsonb; v_n int;
+BEGIN
+  FOREACH f IN ARRAY ARRAY['logistics_uitgang_uit()','logistics_pickup_afwijkend(integer)','logistics_pickup_herstel_voorbeeld()',
+      'logistics_pickup_herstel_uitvoeren(integer)','logistics_stock_email_klaarzetten(integer)','logistics_pickwachtrij_overslaan()',
+      'logistics_order_indeling_stand(uuid)','logistics_kar_tekening(uuid,jsonb)','logistics_klantkleuren()','logistics_xml(text)'] 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;
+  IF to_regprocedure('public.logistics_pickup_afwijkend(integer)') IS NOT NULL THEN
+    v_n := (public.logistics_pickup_afwijkend(0)->>'aantal')::int;
+    onderdeel := 'ophaalmoment past bij vervoerder'; ok := v_n = 0;
+    toelichting := CASE WHEN ok THEN 'alle open orders kloppen'
+                        ELSE v_n || ' open orders hebben een ophaalmoment van een andere vervoerder: draai het herstel (handmatige stap)' END;
+    RETURN NEXT;
+  END IF;
+  SELECT c.order_id INTO v_order FROM logistics_active.order_carts c WHERE c.order_id IS NOT NULL ORDER BY c.updated_at DESC LIMIT 1;
+  IF v_order IS NOT NULL AND to_regprocedure('public.logistics_kar_tekening(uuid,jsonb)') IS NOT NULL THEN
+    v := public.logistics_kar_tekening(v_order, '{}'::jsonb);
+    onderdeel := 'stand en kar-tekening';
+    ok := (v->>'stand') IN ('bezig','klaar','niet_gelukt','geen_regels') AND jsonb_typeof(v->'dragers') = 'array';
+    toelichting := CASE WHEN ok THEN 'geldige uitkomst voor een bestaande order' ELSE 'ongeldige uitkomst' END;
+    RETURN NEXT;
+  END IF;
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_install_check_e1c() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_e1c() TO authenticated, service_role;
+
+-- Golf 1-controle neemt E1-C mee.
+DO $e1c2$
+DECLARE d text;
+BEGIN
+  d := pg_get_functiondef('public.logistics_install_check_golf1()'::regprocedure);
+  IF position('logistics_install_check_e1c' IN d) = 0 THEN
+    d := regexp_replace(d, E'\\nEND \\$function\\$\\s*$', E'\n  RETURN QUERY SELECT * FROM public.logistics_install_check_e1c();\nEND $function$');
+    EXECUTE d;
+  END IF;
+END $e1c2$;
+
+CREATE OR REPLACE FUNCTION public.logistics_schema_versie()
+ RETURNS text LANGUAGE sql IMMUTABLE SET search_path TO 'public'
+AS $function$ SELECT '2026-11-10f'::text $function$;
+
+-- ===== E1-C: interne hulpfuncties alleen voor server (20261111081737) =====
+REVOKE EXECUTE ON FUNCTION public.logistics_klantkleuren() FROM authenticated;
+REVOKE EXECUTE ON FUNCTION public.logistics_install_check_e1c() FROM authenticated;
+REVOKE EXECUTE ON FUNCTION public.logistics_pickup_herstel_voorbeeld() FROM authenticated;
+REVOKE EXECUTE ON FUNCTION public.logistics_pickup_afwijkend(integer) FROM authenticated;
+-- ===== E1-C: klantletter in kar-tekening (20261111081807) =====
+DO $fix$
+DECLARE d text;
+BEGIN
+  d := pg_get_functiondef('public.logistics_kar_tekening(uuid,jsonb)'::regprocedure);
+  IF position('chr(64 + rn)' IN d) > 0 THEN
+    d := replace(d, 'chr(64 + rn)', 'chr((64 + rn)::int)');
+    EXECUTE d;
+  END IF;
+END $fix$;
+-- ===== E1-C: achterstand pickwachtrij ook overslaan zonder wijziging (20261111082613) =====
+CREATE OR REPLACE FUNCTION public.logistics_sync_pick_queue()
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE v_core jsonb; v_back jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_sync_pick_queue');
+  v_core := public.logistics_sync_pick_queue_core();
+  -- E1-C/2: niets veranderd sinds de vorige ronde = ook de achterstand niet opnieuw doorrekenen.
+  IF COALESCE(v_core->>'guard', '') = 'niets veranderd sinds de vorige ronde' THEN
+    RETURN v_core || jsonb_build_object('achterstand', jsonb_build_object('overgeslagen', 'niets veranderd'));
+  END IF;
+  BEGIN
+    v_back := public.logistics_sync_pick_queue_backlog();
+  EXCEPTION WHEN others THEN
+    v_back := jsonb_build_object('achterstand', 'fout', 'reden', SQLERRM);
+    PERFORM public.logistics_melding('logistics_sync_pick_queue', NULL, 'Achterstand van de pickwachtrij kon niet worden bijgewerkt; de volgende ronde probeert het opnieuw', SQLERRM);
+  END;
+  RETURN COALESCE(v_core, '{}'::jsonb) || jsonb_build_object('achterstand', v_back);
+END $function$;
+-- ===== Vervolg E1-C (2026-11-10g): kar-tekening, afleveradressen, verzendmoment, laadtoestand =====
+-- ===== 2026-11-10g Vervolg E1-C =====
+
+-- Punt 1: kar-tekening tekenen vanuit de dragergegevens (puur, geen tabellen).
+CREATE OR REPLACE FUNCTION public.logistics_kar_svg(p jsonb, p_klein boolean DEFAULT false)
+ RETURNS text LANGUAGE plpgsql IMMUTABLE SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_soort text := coalesce(p->>'soort', 'layered');
+  v_lagen jsonb := CASE WHEN jsonb_typeof(p->'lagen') = 'array' THEN p->'lagen' ELSE '[]'::jsonb END;
+  v_kl jsonb := CASE WHEN jsonb_typeof(p->'kleuren') = 'array' AND jsonb_array_length(p->'kleuren') > 0 THEN p->'kleuren' ELSE '["#56B4E9"]'::jsonb END;
+  v_fg text := 'var(--foreground, #1f2937)'; v_mut text := 'var(--muted-foreground, #6b7280)';
+  v_bd text := 'var(--border, #d1d5db)'; v_card text := 'var(--card, #ffffff)'; v_red text := 'var(--destructive, #dc2626)';
+  v_grijs text := 'var(--muted, #e5e7eb)'; v_prim text := 'var(--primary, #2563eb)';
+  v_label text := coalesce(p->>'label', 'Ladingdrager'); v_naam text := coalesce(p->>'naam', '');
+  v_pakbon boolean := coalesce((p->>'pakbon')::boolean, false);
+  v_top numeric := 64; v_bot numeric; v_x0 numeric := 34; v_iw numeric := 166;
+  v_n int; v_lh numeric; v_yb numeric; v_yt numeric; v_sh numeric; v_sw numeric;
+  v_laag jsonb; b jsonb; i int; k int; v_P int; v_pos int; v_f int; v_s int; v_som int;
+  v_kleur text; v_x numeric; v_bx numeric; v_titel text; v_body text := ''; v_desc text := '';
+  v_pct numeric; v_g int; v_w jsonb; v_chars int; v_tekst text; v_eigen boolean; v_letter text; v_ly numeric; v_naam_ok boolean;
+BEGIN
+  v_bot := CASE WHEN v_soort = 'layered' THEN 280 ELSE 282 END;
+  -- Kop
+  IF NOT p_klein THEN
+    v_tekst := v_label || CASE WHEN v_naam <> '' THEN ' · ' || v_naam ELSE '' END;
+    IF length(v_tekst) > 34 THEN v_tekst := left(v_tekst, 33) || '…'; END IF;
+    v_body := v_body || '<text x="12" y="20" font-size="13" font-weight="600" fill="' || v_fg || '">' || public.logistics_xml(v_tekst) || '</text>';
+    v_pct := (p->>'vulgraad_pct')::numeric;
+    IF v_pct IS NOT NULL THEN
+      v_body := v_body || '<rect x="12" y="28" width="166" height="8" rx="4" fill="' || v_grijs || '"/>'
+             || '<rect x="12" y="28" width="' || round(greatest(166 * least(v_pct, 100) / 100, 2), 1) || '" height="8" rx="4" fill="'
+             || CASE WHEN v_pct > 100 THEN v_red ELSE v_prim END || '"/>'
+             || '<text x="186" y="36" font-size="11" fill="' || v_fg || '">' || round(v_pct) || ' %</text>';
+    END IF;
+    v_g := coalesce((p->>'gedeeld_met')::int, 0);
+    IF v_g > 0 THEN
+      v_body := v_body || '<text x="12" y="52" font-size="10" fill="' || v_mut || '">'
+             || public.logistics_xml('gedeeld met ' || v_g || CASE WHEN v_g = 1 THEN ' andere order' ELSE ' andere orders' END) || '</text>';
+    END IF;
+    IF jsonb_typeof(p->'waarschuwingen') = 'array' AND jsonb_array_length(p->'waarschuwingen') > 0 THEN
+      SELECT string_agg(x, '; ') INTO v_tekst FROM jsonb_array_elements_text(p->'waarschuwingen') x;
+      v_body := v_body || '<g><title>' || public.logistics_xml(v_tekst) || '</title><circle cx="224" cy="16" r="9" fill="' || v_red || '"/>'
+             || '<text x="224" y="21" font-size="13" font-weight="700" text-anchor="middle" fill="' || v_card || '">!</text></g>';
+      v_desc := v_desc || ' Let op: ' || v_tekst || '.';
+    END IF;
+  ELSE
+    v_body := v_body || '<text x="120" y="50" font-size="52" font-weight="700" text-anchor="middle" fill="' || v_fg || '">'
+           || coalesce((p->>'nummer')::int, 1) || '</text>';
+  END IF;
+
+  IF v_soort IN ('layered', 'stacked') THEN
+    v_n := greatest(jsonb_array_length(v_lagen), 1);
+    v_lh := (v_bot - v_top) / v_n;
+    IF v_soort = 'layered' THEN
+      v_body := v_body || '<rect x="26" y="' || (v_top - 8) || '" width="5" height="' || (v_bot - v_top + 10) || '" rx="2" fill="' || v_mut || '"/>'
+             || '<rect x="203" y="' || (v_top - 8) || '" width="5" height="' || (v_bot - v_top + 10) || '" rx="2" fill="' || v_mut || '"/>'
+             || '<rect x="22" y="' || v_bot || '" width="190" height="7" rx="2" fill="' || v_mut || '"/>'
+             || '<circle cx="42" cy="' || (v_bot + 19) || '" r="8" fill="' || v_card || '" stroke="' || v_mut || '" stroke-width="3"/>'
+             || '<circle cx="192" cy="' || (v_bot + 19) || '" r="8" fill="' || v_card || '" stroke="' || v_mut || '" stroke-width="3"/>'
+             || '<circle cx="42" cy="' || (v_bot + 19) || '" r="2" fill="' || v_mut || '"/><circle cx="192" cy="' || (v_bot + 19) || '" r="2" fill="' || v_mut || '"/>';
+    ELSE
+      v_body := v_body || '<rect x="24" y="' || v_bot || '" width="186" height="5" rx="1" fill="' || v_mut || '"/>'
+             || '<rect x="28" y="' || (v_bot + 5) || '" width="20" height="10" fill="' || v_mut || '"/>'
+             || '<rect x="107" y="' || (v_bot + 5) || '" width="20" height="10" fill="' || v_mut || '"/>'
+             || '<rect x="186" y="' || (v_bot + 5) || '" width="20" height="10" fill="' || v_mut || '"/>'
+             || '<rect x="24" y="' || (v_bot + 15) || '" width="186" height="4" rx="1" fill="' || v_mut || '"/>';
+    END IF;
+    FOR i IN 0 .. v_n - 1 LOOP
+      v_laag := coalesce(v_lagen->i, '{}'::jsonb);
+      v_yb := v_bot - i * v_lh; v_yt := v_yb - v_lh;
+      IF v_soort = 'layered' AND i > 0 THEN
+        v_body := v_body || '<rect x="29" y="' || round(v_yb - 1.5, 1) || '" width="176" height="3" rx="1" fill="' || v_mut || '"/>';
+      END IF;
+      v_P := least(greatest(coalesce((v_laag->>'plekken')::int, 1), 1), 40);
+      v_sw := v_iw / v_P; v_sh := greatest(v_lh - 7, 2);
+      v_pos := 0; v_som := 0;
+      FOR b IN SELECT x FROM jsonb_array_elements(CASE WHEN jsonb_typeof(v_laag->'blokken') = 'array' THEN v_laag->'blokken' ELSE '[]'::jsonb END) x LOOP
+        EXIT WHEN v_pos >= v_P;
+        v_f := least(greatest(coalesce((b->>'fusten')::int, 0), 0), v_P - v_pos);
+        v_s := least(greatest(v_f, round(coalesce((b->>'aandeel')::numeric, 0) * v_P)::int), v_P - v_pos);
+        CONTINUE WHEN v_s = 0;
+        v_eigen := coalesce((b->>'eigen_order')::boolean, false) OR (b->>'klantletter') IS NOT NULL;
+        v_letter := b->>'klantletter';
+        v_kleur := CASE WHEN v_eigen THEN v_kl->>(coalesce((b->>'kleur_index')::int, 0) % jsonb_array_length(v_kl)) ELSE v_grijs END;
+        v_bx := v_x0 + v_pos * v_sw;
+        IF v_pos > 0 THEN
+          v_body := v_body || '<line x1="' || round(v_bx, 1) || '" y1="' || round(v_yt + 2, 1) || '" x2="' || round(v_bx, 1) || '" y2="' || round(v_yb - 3, 1)
+                 || '" stroke="' || v_fg || '" stroke-width="0.8" opacity="0.6"/>';
+        END IF;
+        v_titel := concat_ws(' · ', CASE WHEN v_eigen THEN nullif(b->>'product', '') ELSE 'Andere order' END,
+                             CASE WHEN coalesce((b->>'eigen_order')::boolean, false) THEN nullif(b->>'klant', '') END,
+                             (b->>'fusten') || CASE WHEN (b->>'fusten') = '1' THEN ' fust' ELSE ' fusten' END,
+                             'laag ' || (i + 1) || ': ' || round(coalesce((b->>'aandeel')::numeric, 0) * 100) || ' % van de laag');
+        v_body := v_body || '<g><title>' || public.logistics_xml(v_titel) || '</title>';
+        v_naam_ok := NOT p_klein AND NOT v_pakbon AND v_eigen AND nullif(b->>'product', '') IS NOT NULL AND v_s * v_sw >= 56 AND v_sh >= 34;
+        v_ly := CASE WHEN v_naam_ok THEN v_yt + 3 + 14 ELSE v_yt + 3 + v_sh / 2 + 4 END;
+        FOR k IN 0 .. v_f - 1 LOOP
+          v_x := v_bx + k * v_sw;
+          v_body := v_body || '<rect x="' || round(v_x + 1.5, 1) || '" y="' || round(v_yt + 3, 1) || '" width="' || round(greatest(v_sw - 3, 1), 1)
+                 || '" height="' || round(v_sh, 1) || '" rx="3" fill="' || v_kleur || '" stroke="' || v_fg || '" stroke-width="0.6"/>';
+          IF NOT v_eigen THEN
+            v_body := v_body || '<rect x="' || round(v_x + 1.5, 1) || '" y="' || round(v_yt + 3, 1) || '" width="' || round(greatest(v_sw - 3, 1), 1)
+                   || '" height="' || round(v_sh, 1) || '" rx="3" fill="url(#lgx-arc)"/>';
+          ELSIF NOT p_klein AND v_letter IS NOT NULL AND v_sw >= 12 AND v_sh >= 14 THEN
+            v_body := v_body || '<text x="' || round(v_x + v_sw / 2, 1) || '" y="' || round(v_ly, 1) || '" font-size="11" font-weight="700" text-anchor="middle" fill="'
+                   || v_fg || '" stroke="' || v_card || '" stroke-width="2.5" paint-order="stroke">' || public.logistics_xml(v_letter) || '</text>';
+          END IF;
+        END LOOP;
+        FOR k IN v_f .. v_s - 1 LOOP
+          v_x := v_bx + k * v_sw;
+          v_body := v_body || '<rect x="' || round(v_x + 1.5, 1) || '" y="' || round(v_yt + 3, 1) || '" width="' || round(greatest(v_sw - 3, 1), 1)
+                 || '" height="' || round(v_sh, 1) || '" rx="3" fill="none" stroke="' || v_bd || '" stroke-dasharray="3 2"/>';
+        END LOOP;
+        IF v_naam_ok THEN
+          v_chars := floor((v_s * v_sw - 8) / 6)::int;
+          v_tekst := b->>'product';
+          IF length(v_tekst) > v_chars THEN v_tekst := left(v_tekst, greatest(v_chars - 1, 1)) || '…'; END IF;
+          v_body := v_body || '<text x="' || round(v_bx + 4, 1) || '" y="' || round(v_yb - 8, 1) || '" font-size="10" fill="' || v_fg
+                 || '" stroke="' || v_card || '" stroke-width="2.5" paint-order="stroke">' || public.logistics_xml(v_tekst) || '</text>';
+        END IF;
+        v_body := v_body || '</g>';
+        v_pos := v_pos + v_s; v_som := v_som + v_f;
+      END LOOP;
+      FOR k IN v_pos .. v_P - 1 LOOP
+        v_x := v_x0 + k * v_sw;
+        v_body := v_body || '<rect x="' || round(v_x + 1.5, 1) || '" y="' || round(v_yt + 3, 1) || '" width="' || round(greatest(v_sw - 3, 1), 1)
+               || '" height="' || round(v_sh, 1) || '" rx="3" fill="none" stroke="' || v_bd || '" stroke-dasharray="3 2"/>';
+      END LOOP;
+      IF NOT p_klein THEN
+        v_body := v_body || '<text x="15" y="' || round(v_yt + v_lh / 2 + 4, 1) || '" font-size="10" text-anchor="middle" fill="' || v_mut || '">' || (i + 1) || '</text>'
+               || '<text x="212" y="' || round(v_yt + v_lh / 2 + 4, 1) || '" font-size="10" fill="' || v_fg || '">' || v_som || '/' || v_P
+               || CASE WHEN v_som >= v_P THEN '<tspan fill="' || v_prim || '" font-weight="700"> ✓</tspan>' ELSE '' END || '</text>';
+      END IF;
+      IF nullif(v_laag->>'waarschuwing', '') IS NOT NULL THEN
+        v_body := v_body || '<g><title>' || public.logistics_xml(v_laag->>'waarschuwing') || '</title><rect x="33" y="' || round(v_yt + 1, 1) || '" width="168" height="'
+               || round(greatest(v_lh - 2, 1), 1) || '" rx="3" fill="none" stroke="' || v_red || '" stroke-width="2"/>'
+               || CASE WHEN NOT p_klein THEN '<text x="232" y="' || round(v_yt + v_lh / 2 + 4, 1) || '" font-size="12" font-weight="700" fill="' || v_red || '">!</text>' ELSE '' END
+               || '</g>';
+      END IF;
+      v_desc := v_desc || ' Laag ' || (i + 1) || ': ' || v_som || ' van ' || v_P || ' plekken.';
+    END LOOP;
+  ELSIF v_soort = 'single' THEN
+    SELECT x INTO b FROM jsonb_array_elements(v_lagen) l, jsonb_array_elements(coalesce(l->'blokken', '[]'::jsonb)) x
+     WHERE coalesce((x->>'eigen_order')::boolean, false) LIMIT 1;
+    SELECT coalesce(sum((x->>'fusten')::int), 0) INTO v_som FROM jsonb_array_elements(v_lagen) l, jsonb_array_elements(coalesce(l->'blokken', '[]'::jsonb)) x;
+    v_kleur := CASE WHEN b IS NULL THEN v_grijs ELSE v_kl->>(coalesce((b->>'kleur_index')::int, 0) % jsonb_array_length(v_kl)) END;
+    v_body := v_body || '<g><title>' || public.logistics_xml(concat_ws(' · ', coalesce(b->>'product', 'Product'), nullif(b->>'klant', ''), v_som || ' stuks')) || '</title>'
+           || '<rect x="46" y="96" width="148" height="160" rx="8" fill="' || v_kleur || '" stroke="' || v_fg || '" stroke-width="1"/>'
+           || '<line x1="46" y1="136" x2="194" y2="136" stroke="' || v_fg || '" stroke-width="0.8" opacity="0.5"/>'
+           || '<line x1="46" y1="216" x2="194" y2="216" stroke="' || v_fg || '" stroke-width="0.8" opacity="0.5"/>'
+           || '<rect x="40" y="88" width="160" height="12" rx="4" fill="' || v_kleur || '" stroke="' || v_fg || '" stroke-width="1"/>';
+    IF NOT p_klein THEN
+      v_tekst := coalesce(b->>'product', 'Product'); IF length(v_tekst) > 22 THEN v_tekst := left(v_tekst, 21) || '…'; END IF;
+      v_body := v_body || '<circle cx="120" cy="168" r="18" fill="' || v_card || '" stroke="' || v_fg || '" stroke-width="1"/>'
+             || '<text x="120" y="176" font-size="20" font-weight="700" text-anchor="middle" fill="' || v_fg || '">' || public.logistics_xml(coalesce(b->>'klantletter', '')) || '</text>'
+             || CASE WHEN NOT v_pakbon THEN '<text x="120" y="122" font-size="12" text-anchor="middle" fill="' || v_fg || '" stroke="' || v_card || '" stroke-width="2.5" paint-order="stroke">' || public.logistics_xml(v_tekst) || '</text>' ELSE '' END
+             || '<text x="120" y="240" font-size="12" text-anchor="middle" fill="' || v_fg || '" stroke="' || v_card || '" stroke-width="2.5" paint-order="stroke">' || v_som || ' stuks</text>';
+    END IF;
+    v_body := v_body || '</g>';
+    v_desc := v_desc || ' Eén colli met ' || v_som || ' stuks.';
+  ELSE
+    v_pos := 0;
+    FOR b IN SELECT x FROM jsonb_array_elements(v_lagen) l, jsonb_array_elements(coalesce(l->'blokken', '[]'::jsonb)) x LOOP
+      v_eigen := coalesce((b->>'eigen_order')::boolean, false) OR (b->>'klantletter') IS NOT NULL;
+      v_kleur := CASE WHEN v_eigen THEN v_kl->>(coalesce((b->>'kleur_index')::int, 0) % jsonb_array_length(v_kl)) ELSE v_grijs END;
+      v_f := greatest(coalesce((b->>'fusten')::int, 0), 0);
+      v_body := v_body || '<g><title>' || public.logistics_xml(concat_ws(' · ', CASE WHEN v_eigen THEN b->>'product' ELSE 'Andere order' END, v_f || ' colli')) || '</title>';
+      FOR k IN 0 .. v_f - 1 LOOP
+        EXIT WHEN v_pos >= 48;
+        v_body := v_body || '<rect x="' || (14 + (v_pos % 6) * 36) || '" y="' || (66 + (v_pos / 6) * 27) || '' || '" width="32" height="23" rx="3" fill="' || v_kleur
+               || '" stroke="' || v_fg || '" stroke-width="0.6"/>'
+               || CASE WHEN NOT v_eigen THEN '<rect x="' || (14 + (v_pos % 6) * 36) || '" y="' || (66 + (v_pos / 6) * 27) || '" width="32" height="23" rx="3" fill="url(#lgx-arc)"/>' ELSE '' END
+               || CASE WHEN NOT p_klein THEN '<text x="' || (30 + (v_pos % 6) * 36) || '" y="' || (82 + (v_pos / 6) * 27) || '" font-size="10" text-anchor="middle" fill="' || v_fg
+                       || '" stroke="' || v_card || '" stroke-width="2.5" paint-order="stroke">' || (v_pos + 1) || '</text>' ELSE '' END;
+        v_pos := v_pos + 1;
+      END LOOP;
+      v_body := v_body || '</g>';
+    END LOOP;
+    v_desc := v_desc || ' ' || v_pos || ' colli.';
+  END IF;
+
+  RETURN '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 240 320" role="img" aria-label="' || public.logistics_xml(v_label || ', ' || v_naam) || '">'
+      || '<title>' || public.logistics_xml(v_label || CASE WHEN v_naam <> '' THEN ' · ' || v_naam ELSE '' END) || '</title>'
+      || '<desc>' || public.logistics_xml(btrim(v_desc)) || '</desc>'
+      || '<defs><pattern id="lgx-arc" width="6" height="6" patternUnits="userSpaceOnUse" patternTransform="rotate(45)"><line x1="0" y1="0" x2="0" y2="6" stroke="' || v_mut || '" stroke-width="1.5" opacity="0.6"/></pattern></defs>'
+      || '<rect x="1" y="1" width="238" height="318" rx="10" fill="' || v_card || '" stroke="' || v_bd || '"/>'
+      || v_body || '</svg>';
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_kar_svg(jsonb, boolean) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_kar_svg(jsonb, boolean) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_kar_tekening(p_order_id uuid, p_opties jsonb DEFAULT '{}'::jsonb)
+ RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_stand jsonb; v_opt jsonb := COALESCE(p_opties, '{}'::jsonb); v_pakbon boolean; v_alle boolean;
+  v_kleuren text[] := public.logistics_klantkleuren(); v_kl jsonb := '[]'::jsonb;
+  v_fb text[] := ARRAY['#E69F00','#56B4E9','#009E73','#CC79A7','#0072B2','#D55E00','#F0E442'];
+  v_order record; v_fase text; v_fl jsonb; v_fl_bron boolean;
+  c record; v_totaal int; v_nr int := 0; v_soort text; v_woord text; v_max int;
+  v_letters jsonb; v_lagen jsonb; it record; v_cur int; v_span int; i int; j int;
+  v_frac numeric; v_vrij numeric; v_aandeel numeric; v_rest int; v_f int; b jsonb; v_eigen boolean; v_letter text;
+  v_status text; v_waarsch jsonb; v_gedeeld int; v_dragers jsonb := '[]'::jsonb; v_rij text := ''; v_label text;
+  v_fusten int; v_fl_kar text; v_P int; v_prevP int; v_sumA numeric; v_sumF int; v_d jsonb; v_svg text; v_klein text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_kar_tekening');
+  v_pakbon := COALESCE(v_opt->>'vorm', '') = 'pakbon';
+  v_alle := COALESCE((v_opt->>'alle_orders')::boolean, false) AND NOT v_pakbon;
+  FOR i IN 1 .. cardinality(v_kleuren) LOOP
+    v_kl := v_kl || to_jsonb(CASE WHEN v_kleuren[i] ~ '^var\(--[a-z0-9-]+\)$'
+                                  THEN left(v_kleuren[i], length(v_kleuren[i]) - 1) || ', ' || v_fb[1 + ((i - 1) % 7)] || ')'
+                                  ELSE v_kleuren[i] END);
+  END LOOP;
+  v_stand := public.logistics_order_indeling_stand(p_order_id);
+  SELECT o.id, o.order_number, o.status, o.order_source, o.floriday_sales_order_id, o.customer_name INTO v_order FROM public.orders o WHERE o.id = p_order_id;
+  v_fase := public.logistics_status_fase(v_order.status);
+  v_fl_bron := v_order.floriday_sales_order_id IS NOT NULL OR COALESCE(v_order.order_source, '') ILIKE '%floriday%';
+  IF v_fl_bron THEN v_fl := public.logistics_floriday_gelijk(p_order_id); END IF;
+
+  SELECT count(*) INTO v_totaal FROM (
+    SELECT DISTINCT c2.id FROM logistics_active.order_carts c2
+     WHERE c2.order_id = p_order_id
+        OR EXISTS (SELECT 1 FROM logistics_active.order_cart_items ci JOIN public.order_items oi ON oi.id = ci.order_item_id
+                    WHERE ci.cart_id = c2.id AND oi.order_id = p_order_id)) x;
+
+  FOR c IN
+    SELECT DISTINCT ON (c2.cart_number, c2.id) c2.id, c2.cart_number, c2.occupancy_pct, c2.total_layers_used, c2.max_layers, c2.weight_kg,
+           COALESCE(t.capacity_model, 'layered') AS soort, COALESCE(t.name, c2.carrier_type, 'Ladingdrager') AS naam,
+           t.layers_per_carrier, t.max_crates_per_layer, t.max_weight_kg
+      FROM logistics_active.order_carts c2
+      LEFT JOIN public.load_carrier_types t ON t.id = c2.carrier_type_id
+     WHERE c2.order_id = p_order_id
+        OR EXISTS (SELECT 1 FROM logistics_active.order_cart_items ci JOIN public.order_items oi ON oi.id = ci.order_item_id
+                    WHERE ci.cart_id = c2.id AND oi.order_id = p_order_id)
+     ORDER BY c2.cart_number, c2.id
+  LOOP
+    v_nr := v_nr + 1;
+    CONTINUE WHEN (v_opt ? 'drager_id') AND (v_opt->>'drager_id') <> c.id::text;
+    v_soort := CASE WHEN c.soort IN ('layered','stacked','single','none') THEN c.soort ELSE 'layered' END;
+    v_woord := CASE v_soort WHEN 'layered' THEN 'Kar' WHEN 'none' THEN 'Colli' WHEN 'single' THEN 'Colli' ELSE 'Pallet' END;
+    v_max := GREATEST(1, COALESCE(c.max_layers, c.layers_per_carrier, CEIL(COALESCE(c.total_layers_used, 1))::int, 1));
+
+    SELECT COALESCE(jsonb_object_agg(order_id::text, chr((64 + rn)::int)), '{}'::jsonb) INTO v_letters FROM (
+      SELECT oi.order_id, row_number() OVER (ORDER BY (oi.order_id = p_order_id) DESC, min(o2.order_number)) AS rn
+        FROM public.order_cart_items ci JOIN public.order_items oi ON oi.id = ci.order_item_id
+        JOIN public.orders o2 ON o2.id = oi.order_id
+       WHERE ci.cart_id = c.id GROUP BY oi.order_id) l;
+    SELECT count(DISTINCT oi.order_id) FILTER (WHERE oi.order_id <> p_order_id) INTO v_gedeeld
+      FROM public.order_cart_items ci JOIN public.order_items oi ON oi.id = ci.order_item_id WHERE ci.cart_id = c.id;
+
+    -- Lagen: deel-lagen van verschillende regels delen één laag zolang ze passen.
+    v_lagen := '[]'::jsonb;
+    FOR i IN 1 .. v_max LOOP
+      v_lagen := v_lagen || jsonb_build_array(jsonb_build_object('index', i, 'hoogte_aandeel', round(1.0 / v_max, 4), 'blokken', '[]'::jsonb));
+    END LOOP;
+    v_cur := 1; v_vrij := 1.0;
+    FOR it IN
+      SELECT ci.id, ci.layer_index, COALESCE(ci.crates_in_layer, ci.crates, ci.boxes, 0) AS fusten, ci.lagen, ci.layer_fraction,
+             COALESCE(ci.product_name, oi.product_name, 'Product') AS product, oi.order_id
+        FROM public.order_cart_items ci LEFT JOIN public.order_items oi ON oi.id = ci.order_item_id
+       WHERE ci.cart_id = c.id ORDER BY ci.layer_index NULLS LAST, ci.created_at, ci.id
+    LOOP
+      v_frac := GREATEST(COALESCE(it.lagen, it.layer_fraction, 1), 0.01);
+      v_eigen := it.order_id = p_order_id;
+      v_letter := v_letters->>it.order_id::text;
+      IF it.layer_index IS NOT NULL THEN
+        v_cur := it.layer_index; v_span := 1;
+      ELSIF v_frac < 0.9999 THEN
+        IF v_vrij + 0.0001 < v_frac THEN v_cur := v_cur + 1; v_vrij := 1.0; END IF;
+        v_span := 1;
+      ELSE
+        IF v_vrij < 0.9999 THEN v_cur := v_cur + 1; v_vrij := 1.0; END IF;
+        v_span := CEIL(v_frac - 0.0001)::int;
+      END IF;
+      v_rest := it.fusten;
+      FOR j IN 1 .. v_span LOOP
+        i := v_cur + j - 1;
+        WHILE i > jsonb_array_length(v_lagen) LOOP
+          v_lagen := v_lagen || jsonb_build_array(jsonb_build_object('index', jsonb_array_length(v_lagen) + 1, 'hoogte_aandeel', 0, 'blokken', '[]'::jsonb));
+        END LOOP;
+        v_aandeel := CASE WHEN it.layer_index IS NOT NULL THEN LEAST(v_frac, 1) ELSE LEAST(1, v_frac - (j - 1)) END;
+        v_f := CASE WHEN j = v_span THEN v_rest ELSE ROUND(it.fusten * v_aandeel / v_frac)::int END;
+        v_rest := v_rest - v_f;
+        b := CASE WHEN v_eigen OR v_alle
+                  THEN jsonb_build_object('klantletter', v_letter, 'product', CASE WHEN v_pakbon THEN NULL ELSE it.product END,
+                                          'klant', CASE WHEN v_eigen THEN v_order.customer_name END,
+                                          'fusten', v_f, 'eigen_order', v_eigen, 'aandeel', round(v_aandeel, 4),
+                                          'kleur_index', GREATEST(ascii(COALESCE(v_letter, 'A')) - 65, 0))
+                  ELSE jsonb_build_object('klantletter', NULL, 'product', NULL, 'fusten', v_f, 'eigen_order', false, 'aandeel', round(v_aandeel, 4)) END;
+        v_lagen := jsonb_set(v_lagen, ARRAY[(i - 1)::text, 'blokken'], (v_lagen->(i - 1)->'blokken') || jsonb_build_array(b));
+      END LOOP;
+      IF it.layer_index IS NULL THEN
+        IF v_span = 1 AND v_frac < 0.9999 THEN v_vrij := v_vrij - v_frac;
+        ELSIF v_frac - (v_span - 1) < 0.9999 THEN v_cur := v_cur + v_span - 1; v_vrij := 1 - (v_frac - (v_span - 1));
+        ELSE v_cur := v_cur + v_span; v_vrij := 1.0; END IF;
+      END IF;
+    END LOOP;
+    IF jsonb_array_length(v_lagen) > v_max THEN
+      SELECT jsonb_agg(jsonb_set(l, '{hoogte_aandeel}', to_jsonb(round(1.0 / jsonb_array_length(v_lagen), 4))) ORDER BY n) INTO v_lagen
+        FROM jsonb_array_elements(v_lagen) WITH ORDINALITY x(l, n);
+    END IF;
+
+    -- Plekken per laag uit de belading: fusten gedeeld door het deel van de laag dat ze innemen.
+    v_prevP := c.max_crates_per_layer;
+    FOR i IN 0 .. jsonb_array_length(v_lagen) - 1 LOOP
+      SELECT max(CASE WHEN (bb->>'aandeel')::numeric > 0 THEN round((bb->>'fusten')::numeric / (bb->>'aandeel')::numeric) END),
+             coalesce(sum((bb->>'aandeel')::numeric), 0), coalesce(sum((bb->>'fusten')::int), 0)
+        INTO v_P, v_sumA, v_sumF
+        FROM jsonb_array_elements(v_lagen->i->'blokken') bb;
+      v_P := CASE WHEN v_sumF = 0 THEN COALESCE(v_prevP, c.max_crates_per_layer, 1) ELSE GREATEST(COALESCE(v_P, v_sumF), v_sumF, 1) END;
+      v_P := LEAST(GREATEST(v_P, 1), 40);
+      IF v_sumF > 0 THEN v_prevP := v_P; END IF;
+      v_lagen := jsonb_set(v_lagen, ARRAY[i::text, 'plekken'], to_jsonb(v_P));
+      IF i + 1 > v_max AND v_sumF > 0 THEN
+        v_lagen := jsonb_set(v_lagen, ARRAY[i::text, 'waarschuwing'], to_jsonb('Te hoog: deze laag past niet meer op de ' || lower(v_woord)));
+      ELSIF v_sumA > 1.001 THEN
+        v_lagen := jsonb_set(v_lagen, ARRAY[i::text, 'waarschuwing'], to_jsonb('Te vol: deze laag is voor ' || round(v_sumA * 100) || ' % gevuld'));
+      END IF;
+    END LOOP;
+    -- Lege plekken op lege lagen onderaan aanvullen met de maat van de eerste gevulde laag.
+    SELECT (l->>'plekken')::int INTO v_P FROM jsonb_array_elements(v_lagen) l
+     WHERE jsonb_array_length(l->'blokken') > 0 ORDER BY (l->>'index')::int LIMIT 1;
+    IF v_P IS NOT NULL THEN
+      FOR i IN 0 .. jsonb_array_length(v_lagen) - 1 LOOP
+        EXIT WHEN jsonb_array_length(v_lagen->i->'blokken') > 0;
+        v_lagen := jsonb_set(v_lagen, ARRAY[i::text, 'plekken'], to_jsonb(v_P));
+      END LOOP;
+    END IF;
+    SELECT COALESCE(sum((bb->>'fusten')::int), 0) INTO v_fusten
+      FROM jsonb_array_elements(v_lagen) l, jsonb_array_elements(l->'blokken') bb;
+
+    v_status := CASE
+      WHEN v_fase IN ('verzonden','gereed_voor_facturatie','gefactureerd','afgehandeld_floriday') THEN 'afgemeld'
+      WHEN public.logistics_cart_scanned(c.id) THEN 'gecontroleerd'
+      WHEN EXISTS (SELECT 1 FROM public.pick_queue q WHERE q.reference = c.id::text AND q.cancelled_at IS NULL AND q.completed_at IS NOT NULL) THEN 'gepickt'
+      WHEN EXISTS (SELECT 1 FROM public.pick_queue q WHERE q.reference = c.id::text AND q.cancelled_at IS NULL AND q.printed_at IS NOT NULL) THEN 'geprint'
+      WHEN EXISTS (SELECT 1 FROM public.pick_queue q WHERE q.reference = c.id::text AND q.cancelled_at IS NULL AND (q.payload->>'printbaar') = 'true') THEN 'vrijgegeven'
+      ELSE 'open' END;
+
+    v_waarsch := '[]'::jsonb;
+    IF c.max_weight_kg IS NOT NULL AND c.weight_kg IS NOT NULL AND c.weight_kg > c.max_weight_kg THEN
+      v_waarsch := v_waarsch || to_jsonb(v_woord || ' is te zwaar: ' || round(c.weight_kg) || ' kg, maximaal ' || round(c.max_weight_kg) || ' kg');
+    END IF;
+    IF COALESCE(c.occupancy_pct, 0) > 100 THEN
+      v_waarsch := v_waarsch || to_jsonb(v_woord || ' is voller dan toegestaan (' || round(c.occupancy_pct) || '%)');
+    END IF;
+    IF jsonb_array_length(v_lagen) > v_max THEN
+      v_waarsch := v_waarsch || to_jsonb('Er zijn meer lagen gevuld dan de ' || lower(v_woord) || ' heeft');
+    END IF;
+
+    v_fl_kar := NULL;
+    IF v_fl_bron THEN
+      SELECT COALESCE(e->>'uitkomst', e->>'stand') INTO v_fl_kar
+        FROM jsonb_array_elements(CASE WHEN jsonb_typeof(v_fl->'karren') = 'array' THEN v_fl->'karren' ELSE '[]'::jsonb END) e
+       WHERE COALESCE(e->>'cartId', e->>'kar_id', e->>'id') = c.id::text LIMIT 1;
+      v_fl_kar := COALESCE(v_fl_kar, v_fl->>'uitkomst', v_fl->>'stand');
+    END IF;
+
+    v_label := CASE WHEN v_soort IN ('none','single') THEN v_woord || ' ' || v_nr || ' van ' || v_totaal
+                    ELSE v_woord || ' ' || v_nr || ' van ' || v_totaal END;
+    v_d := jsonb_build_object('soort', v_soort, 'label', v_label, 'naam', c.naam, 'nummer', v_nr,
+             'vulgraad_pct', CASE WHEN c.occupancy_pct IS NOT NULL THEN round(c.occupancy_pct) END,
+             'gedeeld_met', v_gedeeld, 'kleuren', v_kl, 'waarschuwingen', v_waarsch, 'lagen', v_lagen, 'pakbon', v_pakbon);
+    v_svg := public.logistics_kar_svg(v_d, false);
+    v_klein := public.logistics_kar_svg(v_d, true);
+    v_rij := v_rij || '<svg x="' || ((v_nr - 1) * 64) || '" y="0" width="60" height="80"' || substr(v_klein, length('<svg') + 1);
+
+    v_dragers := v_dragers || jsonb_build_array(jsonb_build_object(
+      'id', c.id, 'nummer', v_nr, 'totaal', v_totaal, 'soort', v_soort, 'naam', c.naam,
+      'vulgraad_pct', CASE WHEN c.occupancy_pct IS NOT NULL THEN round(c.occupancy_pct) END,
+      'lagen_gebruikt', CASE WHEN c.total_layers_used IS NOT NULL THEN round(c.total_layers_used, 1) END,
+      'lagen_max', CASE WHEN v_soort IN ('layered','stacked') THEN v_max END,
+      'gewicht_kg', CASE WHEN c.weight_kg IS NOT NULL THEN round(c.weight_kg, 1) END,
+      'status', v_status, 'floriday_gelijk', v_fl_kar, 'gedeeld_met', v_gedeeld,
+      'waarschuwingen', v_waarsch, 'lagen', v_lagen, 'svg', v_svg));
+  END LOOP;
+
+  RETURN jsonb_build_object(
+    'stand', v_stand->'stand', 'bezig_sinds', v_stand->'bezig_sinds', 'bijgewerkt_op', v_stand->'bijgewerkt_op',
+    'verwacht_klaar', v_stand->'verwacht_klaar', 'tekst', v_stand->'tekst',
+    'svg_rij', CASE WHEN jsonb_array_length(v_dragers) = 0 THEN NULL
+                    ELSE '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ' || GREATEST(jsonb_array_length(v_dragers) * 64, 64)
+                         || ' 80" role="img" aria-label="Overzicht van ' || jsonb_array_length(v_dragers)
+                         || CASE WHEN jsonb_array_length(v_dragers) = 1 THEN ' ladingdrager' ELSE ' ladingdragers' END
+                         || '"><title>Overzicht ladingdragers</title>' || v_rij || '</svg>' END,
+    'dragers', v_dragers);
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_kar_tekening(uuid, jsonb) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_kar_tekening(uuid, jsonb) TO authenticated, service_role;
+
+-- Punt 2: afleveradressen per vervoerder (Afhandeling), ook zonder GLN. Ontbreekt de kolom: lege lijst.
+CREATE OR REPLACE FUNCTION public.logistics_carrier_adressen(p_carrier_id uuid)
+ RETURNS jsonb LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+  SELECT COALESCE((SELECT CASE WHEN jsonb_typeof(to_jsonb(ca)->'delivery_location_ids') = 'array'
+                               THEN to_jsonb(ca)->'delivery_location_ids' ELSE '[]'::jsonb END
+                     FROM public.carriers ca WHERE ca.id = p_carrier_id), '[]'::jsonb)
+$function$;
+REVOKE ALL ON FUNCTION public.logistics_carrier_adressen(uuid) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_carrier_adressen(uuid) TO service_role;
+
+DO $mig$
+DECLARE v_def text; v_nieuw text; a1 text; a2 text;
+BEGIN
+  v_def := pg_get_functiondef('public.logistics_resolve_carrier_core(jsonb,boolean)'::regprocedure);
+  IF position('logistics_carrier_adressen' IN v_def) > 0 THEN RETURN; END IF;
+  a1 := E'  IF v_cust IS NOT NULL THEN\n    SELECT to_jsonb(x) INTO cu FROM public.customers x WHERE x.id = v_cust;';
+  a2 := E'        v_skip := public.logistics_carrier_skip_reason(r.id);\n        IF v_skip IS NULL AND NOT public.logistics_carrier_picks_up_for(r.id, v_date) THEN';
+  IF position(a1 IN v_def) = 0 OR position(a2 IN v_def) = 0 THEN
+    RAISE EXCEPTION 'logistics_resolve_carrier_core: verwachte tekst niet gevonden; aanpassing niet toegepast';
+  END IF;
+  v_nieuw := replace(v_def, a1, E'  -- E1-C vervolg punt 2: vervoerders met dit afleveradres in hun lijst (ook zonder GLN).\n'
+    || E'  IF l IS NOT NULL AND (l->>''id'') IS NOT NULL THEN\n'
+    || E'    FOR r IN SELECT ca.id FROM public.carriers ca\n'
+    || E'              WHERE public.logistics_carrier_adressen(ca.id) ? (l->>''id'')\n'
+    || E'              ORDER BY ca.sort_order NULLS LAST, ca.id LOOP\n'
+    || E'      v_skip := public.logistics_carrier_skip_reason(r.id);\n'
+    || E'      IF v_skip IS NULL THEN\n'
+    || E'        RETURN public.logistics_carrier_result(r.id, ''afleveradres'', ''Vervoerder rijdt naar dit afleveradres.'', v_skips);\n'
+    || E'      END IF;\n'
+    || E'      v_skips := v_skips || (''afleveradressen: '' || v_skip);\n'
+    || E'    END LOOP;\n'
+    || E'  END IF;\n\n' || a1);
+  v_nieuw := replace(v_nieuw, a2, E'        v_skip := public.logistics_carrier_skip_reason(r.id);\n'
+    || E'        IF v_skip IS NULL AND jsonb_array_length(public.logistics_carrier_adressen(r.id)) > 0\n'
+    || E'           AND NOT (public.logistics_carrier_adressen(r.id) ? coalesce(l->>''id'', '''')) THEN\n'
+    || E'          v_skip := (SELECT name FROM public.carriers WHERE id = r.id) || '': rijdt niet naar dit afleveradres'';\n'
+    || E'        END IF;\n'
+    || E'        IF v_skip IS NULL AND NOT public.logistics_carrier_picks_up_for(r.id, v_date) THEN');
+  EXECUTE v_nieuw;
+END $mig$;
+
+-- Punt 3: sluitregel van buffer en karindeling volgens de werkwijze.
+CREATE OR REPLACE FUNCTION public.logistics_buffer_sluiten_modus()
+ RETURNS text LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+  SELECT COALESCE((
+    SELECT CASE WHEN v IN ('verzendmoment', 'werkuren') THEN v ELSE 'werkuren' END FROM (
+      SELECT public.logistics_rule_text(rc.settings, 'order_verwerking', 'buffer_sluiten', 'werkuren') AS v
+        FROM public.logistics_rule_configs rc
+        LEFT JOIN public.logistics_strategies s ON s.id = rc.strategy_id
+       ORDER BY (rc.is_active AND coalesce(s.is_active, false)) DESC, rc.is_active DESC, rc.updated_at DESC NULLS LAST
+       LIMIT 1) x), 'werkuren')
+$function$;
+REVOKE ALL ON FUNCTION public.logistics_buffer_sluiten_modus() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_buffer_sluiten_modus() TO authenticated, service_role;
+
+DO $mig$
+DECLARE v_def text; v_nieuw text; a0 text; a1 text; a2 text; a3 text; a4 text;
+BEGIN
+  v_def := pg_get_functiondef('public.logistics_schedule_tasks(text)'::regprocedure);
+  IF position('tmp_logistics_verzend' IN v_def) > 0 THEN RETURN; END IF;
+  a0 := E'\n  WITH pick AS (';
+  a1 := E'    SELECT id, pickup_at, new_rule, dep,\n           CASE\n             WHEN new_rule AND pickup_at IS NULL THEN NULL';
+  a2 := E'           CASE WHEN new_rule THEN\n                  CASE WHEN off_min <= dur_min THEN pickup_at';
+  a3 := E'      FROM work\n  ), clamped AS (';
+  a4 := E'             || CASE WHEN c.shifted THEN';
+  IF position(a0 IN v_def) = 0 OR position(a1 IN v_def) = 0 OR position(a2 IN v_def) = 0
+     OR position(a3 IN v_def) = 0 OR position(a4 IN v_def) = 0 THEN
+    RAISE EXCEPTION 'logistics_schedule_tasks: verwachte tekst niet gevonden; aanpassing niet toegepast';
+  END IF;
+  v_nieuw := replace(v_def, a0, E'\n  -- E1-C vervolg punt 3: buffer en karindeling sluiten op het verzendmoment van de aanmelding (werkwijze).\n'
+    || E'  CREATE TEMP TABLE IF NOT EXISTS tmp_logistics_verzend (task_id uuid PRIMARY KEY, verzend_at timestamptz) ON COMMIT DROP;\n'
+    || E'  TRUNCATE tmp_logistics_verzend;\n'
+    || E'  IF public.logistics_buffer_sluiten_modus() = ''verzendmoment'' AND EXISTS (SELECT 1 FROM tmp_logistics_dep) THEN\n'
+    || E'    BEGIN\n'
+    || E'      INSERT INTO tmp_logistics_verzend(task_id, verzend_at)\n'
+    || E'      SELECT t.id, a.aanmeld_at\n'
+    || E'        FROM public.logistics_aanmeldmoment(ARRAY(SELECT d.order_id FROM tmp_logistics_dep d)) a\n'
+    || E'        JOIN tmp_logistics_dep d ON d.order_id = a.order_id\n'
+    || E'        JOIN public.logistics_tasks t ON t.order_ref = d.ref AND t.task_type IN (''buffer.close'', ''load.compose'') AND t.status IN (''planned'', ''ready'')\n'
+    || E'       WHERE a.aanmeld_at IS NOT NULL AND a.bron IN (''gepland'', ''verstuurd'')\n'
+    || E'      ON CONFLICT (task_id) DO NOTHING;\n'
+    || E'    EXCEPTION WHEN OTHERS THEN\n'
+    || E'      PERFORM public.logistics_melding(''logistics_schedule_tasks'', NULL,\n'
+    || E'        ''Verzendmoment van de aanmelding niet te lezen; buffer en karindeling volgen nu de werkuren'', SQLERRM);\n'
+    || E'    END;\n'
+    || E'  END IF;\n' || a0);
+  v_nieuw := replace(v_nieuw, a1, E'    SELECT id, pickup_at, new_rule, dep, vzz.verzend_at,\n           CASE\n'
+    || E'             WHEN vzz.verzend_at IS NOT NULL AND task_type = ''buffer.close'' THEN vzz.verzend_at\n'
+    || E'             WHEN vzz.verzend_at IS NOT NULL AND task_type = ''load.compose'' THEN vzz.verzend_at - interval ''10 minutes''\n'
+    || E'             WHEN new_rule AND pickup_at IS NULL THEN NULL');
+  v_nieuw := replace(v_nieuw, a2, E'           CASE WHEN vzz.verzend_at IS NOT NULL AND task_type IN (''buffer.close'', ''load.compose'') THEN vzz.verzend_at\n'
+    || E'                WHEN new_rule THEN\n                  CASE WHEN off_min <= dur_min THEN pickup_at');
+  v_nieuw := replace(v_nieuw, a3, E'      FROM work\n      LEFT JOIN tmp_logistics_verzend vzz ON vzz.task_id = work.id\n  ), clamped AS (');
+  v_nieuw := replace(v_nieuw, a4, E'             || CASE WHEN c.task_type IN (''buffer.close'', ''load.compose'') THEN jsonb_build_object(\n'
+    || E'                    ''sluitRegel'', CASE WHEN c.verzend_at IS NOT NULL THEN ''verzendmoment'' ELSE ''werkuren'' END,\n'
+    || E'                    ''verzendAt'', c.verzend_at) ELSE ''{}''::jsonb END\n' || a4);
+  EXECUTE v_nieuw;
+END $mig$;
+
+-- Nieuwe werkwijze Standaard krijgt "Op het verzendmoment"; bestaande werkwijzen blijven ongewijzigd.
+DO $mig$
+DECLARE v_def text; v_nieuw text;
+BEGIN
+  v_def := pg_get_functiondef('public.logistics_ensure_defaults()'::regprocedure);
+  IF position('buffer_sluiten' IN v_def) > 0 THEN RETURN; END IF;
+  IF (length(v_def) - length(replace(v_def, '''buffer_enabled'', true,', ''))) / length('''buffer_enabled'', true,') <> 1 THEN
+    RAISE EXCEPTION 'logistics_ensure_defaults: verwachte tekst niet precies één keer gevonden';
+  END IF;
+  v_nieuw := replace(v_def, '''buffer_enabled'', true,', '''buffer_enabled'', true, ''buffer_sluiten'', ''verzendmoment'',');
+  EXECUTE v_nieuw;
+END $mig$;
+
+-- Punt 4: laadtoestand alleen bij een wijziging die hem raakt.
+CREATE OR REPLACE FUNCTION public.logistics_laadtoestand_sig()
+ RETURNS text LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+  SELECT md5(concat_ws('|',
+    (SELECT string_agg(q.id::text, ',' ORDER BY q.id) FROM public.pick_queue q WHERE q.cancelled_at IS NULL AND q.completed_at IS NULL),
+    (SELECT string_agg(pq.order_id::text || pq.status, ',' ORDER BY pq.order_id, pq.status) FROM public.logistics_plan_queue pq WHERE pq.status IN ('pending', 'running')),
+    (SELECT count(*)::text || ':' || coalesce(max(c.updated_at)::text, '') FROM logistics_active.order_carts c),
+    (SELECT string_agg(s || ':' || n, ',' ORDER BY s) FROM (SELECT t.status AS s, count(*) AS n FROM public.logistics_tasks t GROUP BY t.status) x),
+    (SELECT count(*)::text FROM public.logistics_tasks t WHERE t.status IN ('planned', 'ready') AND t.planned_start <= now()),
+    (SELECT count(*)::text || ':' || coalesce(max(r.created_at)::text, '') FROM public.logistics_pick_data_requests r WHERE r.finished_at IS NULL)))
+$function$;
+REVOKE ALL ON FUNCTION public.logistics_laadtoestand_sig() FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_laadtoestand_sig() TO service_role;
+
+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_sig text; v_prev text; v_at timestamptz; v_res jsonb; v_bezig boolean;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_refresh_plan_state_als_nodig');
+  v_sig := public.logistics_laadtoestand_sig();
+  SELECT value->>'sig', (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';
+  -- Vangnet: hooguit elke 15 minuten toch een volledige ronde.
+  IF NOT coalesce(v_bezig, false) AND v_at IS NOT NULL AND v_sig = v_prev AND v_at > now() - interval '15 minutes' THEN
+    RETURN jsonb_build_object('overgeslagen', 'niets veranderd sinds de vorige ronde');
+  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('sig', v_sig, 'at', now()), now())
+  ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+  RETURN v_res;
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_e1c()
+ RETURNS TABLE(onderdeel text, ok boolean, toelichting text)
+ LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE f text; v_order uuid; v jsonb; v_n int;
+BEGIN
+  FOREACH f IN ARRAY ARRAY['logistics_uitgang_uit()','logistics_pickup_afwijkend(integer)','logistics_pickup_herstel_voorbeeld()',
+      'logistics_pickup_herstel_uitvoeren(integer)','logistics_stock_email_klaarzetten(integer)','logistics_pickwachtrij_overslaan()',
+      'logistics_order_indeling_stand(uuid)','logistics_kar_tekening(uuid,jsonb)','logistics_klantkleuren()','logistics_xml(text)',
+      'logistics_kar_svg(jsonb,boolean)','logistics_carrier_adressen(uuid)','logistics_buffer_sluiten_modus()','logistics_laadtoestand_sig()'] 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;
+  IF to_regprocedure('public.logistics_pickup_afwijkend(integer)') IS NOT NULL THEN
+    v_n := (public.logistics_pickup_afwijkend(0)->>'aantal')::int;
+    onderdeel := 'ophaalmoment past bij vervoerder'; ok := v_n = 0;
+    toelichting := CASE WHEN ok THEN 'alle open orders kloppen'
+                        ELSE v_n || ' open orders hebben een ophaalmoment van een andere vervoerder: draai het herstel (handmatige stap)' END;
+    RETURN NEXT;
+  END IF;
+  SELECT c.order_id INTO v_order FROM logistics_active.order_carts c WHERE c.order_id IS NOT NULL ORDER BY c.updated_at DESC LIMIT 1;
+  IF v_order IS NOT NULL AND to_regprocedure('public.logistics_kar_tekening(uuid,jsonb)') IS NOT NULL THEN
+    v := public.logistics_kar_tekening(v_order, '{}'::jsonb);
+    onderdeel := 'stand en kar-tekening';
+    ok := (v->>'stand') IN ('bezig','klaar','niet_gelukt','geen_regels') AND jsonb_typeof(v->'dragers') = 'array';
+    toelichting := CASE WHEN ok THEN 'geldige uitkomst voor een bestaande order' ELSE 'ongeldige uitkomst' END;
+    RETURN NEXT;
+  END IF;
+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-10g'::text $function$;
+REVOKE EXECUTE ON FUNCTION public.logistics_buffer_sluiten_modus() FROM authenticated;
+DO $mig$
+DECLARE v_def text; a text := 'CASE WHEN v_som >= v_P THEN';
+BEGIN
+  v_def := pg_get_functiondef('public.logistics_kar_svg(jsonb,boolean)'::regprocedure);
+  IF position('nullif(v_laag->>''waarschuwing'', '''') IS NULL AND v_som >= v_P' IN v_def) > 0 THEN RETURN; END IF;
+  IF position(a IN v_def) = 0 THEN RAISE EXCEPTION 'logistics_kar_svg: verwachte tekst niet gevonden'; END IF;
+  EXECUTE replace(v_def, a, 'CASE WHEN nullif(v_laag->>''waarschuwing'', '''') IS NULL AND v_som >= v_P THEN');
+END $mig$;
+
+-- ===== Vervolg E1-E (2026-11-10h)
+-- E1-E (schemaversie 2026-11-10h): eigen ophaaltijd leidend; sluitregel omzetten geldt ook voor vandaag.
+CREATE OR REPLACE FUNCTION public.logistics_pickup_eigen_tijd(p_carrier_id uuid, p_cf jsonb)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_soort text; v_pm text; v_bron text; v_geldig boolean;
+BEGIN
+  IF p_carrier_id IS NULL THEN RETURN jsonb_build_object('eigen', false, 'soort', NULL); END IF;
+  SELECT to_jsonb(c)->>'carrier_kind' INTO v_soort FROM public.carriers c WHERE c.id = p_carrier_id;
+  IF COALESCE(v_soort, '') NOT IN ('klant_haalt_op', 'eigen_vervoer') THEN
+    RETURN jsonb_build_object('eigen', false, 'soort', v_soort);
+  END IF;
+  v_pm := nullif(btrim(COALESCE(p_cf->>'pickup_moment', '')), '');
+  v_bron := COALESCE(p_cf->>'pickup_moment_bron', '');
+  v_geldig := v_pm ~ '^\d{4}-\d{2}-\d{2}\|\d{1,2}:\d{2}$';
+  RETURN jsonb_build_object('eigen', v_geldig AND v_bron <> 'auto', 'soort', v_soort,
+                            'tijd', CASE WHEN v_geldig AND v_bron <> 'auto' THEN v_pm END);
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_pickup_eigen_tijd(uuid, jsonb) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_pickup_eigen_tijd(uuid, jsonb) TO service_role;
+
+-- Ophaalmoment-trigger: een eigen tijd blijft staan, ook bij aanmaken en vervoerderswissel.
+CREATE OR REPLACE FUNCTION public.logistics_orders_pickup_moment()
+RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE n jsonb; v_basis jsonb; v_eigen jsonb;
+BEGIN
+  BEGIN
+    v_eigen := public.logistics_pickup_eigen_tijd(NEW.carrier_id, NEW.custom_fields);
+  EXCEPTION WHEN OTHERS THEN
+    v_eigen := '{"eigen":false}'::jsonb;
+    PERFORM public.logistics_melding('logistics_orders_pickup_moment', NEW.id, 'Soort vervoerder kon niet worden gelezen', SQLERRM);
+  END;
+  -- E1-E/1: eigen tijd (klant haalt op / eigen vervoer met tijd) is leidend.
+  IF COALESCE((v_eigen->>'eigen')::boolean, false) THEN
+    IF COALESCE(NEW.custom_fields->>'pickup_moment_bron', '') <> 'eigen' OR (NEW.custom_fields ? 'pickup_moment_reden') THEN
+      NEW.custom_fields := (NEW.custom_fields - 'pickup_moment_reden' - 'pickup_moment_key') || jsonb_build_object('pickup_moment_bron', 'eigen');
+    END IF;
+    RETURN NEW;
+  END IF;
+  IF TG_OP = 'UPDATE' AND NEW.carrier_id IS DISTINCT FROM OLD.carrier_id THEN
+    IF NEW.plan_locked_at IS NOT NULL THEN RETURN NEW; END IF;
+    BEGIN
+      v_basis := COALESCE(NEW.custom_fields, '{}'::jsonb) - 'pickup_moment' - 'pickup_moment_key' - 'pickup_moment_bron' - 'pickup_moment_reden';
+      n := public.logistics_pickup_cf_nieuw(v_basis, 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 na vervoerderswissel mislukt voor order %: %', NEW.id, SQLERRM;
+      PERFORM public.logistics_melding('logistics_orders_pickup_moment', NEW.id,
+        'Ophaalmoment kon na een vervoerderswissel niet opnieuw worden bepaald', SQLERRM);
+    END;
+    RETURN NEW;
+  END IF;
+  IF COALESCE(current_setting('logistics.pickup_writer', true), '') = 'engine' THEN RETURN NEW; END IF;
+  IF TG_OP = 'UPDATE'
+     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 $$;
+
+-- E1-E: gerichte aanpassingen op bestaande functies (idempotent: alleen als de nieuwe tekst er nog niet in staat).
+
+DO $do$
+DECLARE d text := pg_get_functiondef('public.logistics_pickup_cf_nieuw(jsonb,uuid,text,timestamptz,timestamptz,timestamptz,jsonb)'::regprocedure); a text := $e1e0a$  BEGIN v_dag := public.logistics_order_date(p_delivery_date);$e1e0a$; b text := $e1e0b$  IF (public.logistics_pickup_eigen_tijd(p_carrier_id, cf)->>'soort') = 'klant_haalt_op' THEN
+    n := (cf - 'pickup_moment' - 'pickup_moment_key')
+         || jsonb_build_object('pickup_moment_bron', 'eigen', 'pickup_moment_reden', 'Ophaaltijd van de klant ontbreekt; vul die in bij de order');
+    IF n = cf THEN RETURN NULL; END IF;
+    RETURN n;
+  END IF;
+  BEGIN v_dag := public.logistics_order_date(p_delivery_date);$e1e0b$;
+BEGIN
+  IF strpos(d, b) > 0 THEN RETURN; END IF;
+  IF strpos(d, a) = 0 THEN RAISE EXCEPTION 'E1-E: verwachte tekst niet gevonden in logistics_pickup_cf_nieuw(jsonb,uuid,text,timestamptz,timestamptz,timestamptz,jsonb)'; END IF;
+  EXECUTE replace(d, a, b);
+END $do$;
+
+DO $do$
+DECLARE d text := pg_get_functiondef('public.logistics_pickup_afwijkend(integer)'::regprocedure); a text := $e1e1a$       AND NOT public.logistics_order_is_backfill(o.id)$e1e1a$; b text := $e1e1b$       AND NOT public.logistics_order_is_backfill(o.id)
+       AND NOT COALESCE((public.logistics_pickup_eigen_tijd(o.carrier_id, o.custom_fields)->>'eigen')::boolean, false)$e1e1b$;
+BEGIN
+  IF strpos(d, b) > 0 THEN RETURN; END IF;
+  IF strpos(d, a) = 0 THEN RAISE EXCEPTION 'E1-E: verwachte tekst niet gevonden in logistics_pickup_afwijkend(integer)'; END IF;
+  EXECUTE replace(d, a, b);
+END $do$;
+
+DO $do$
+DECLARE d text := pg_get_functiondef('public.logistics_pickup_herstel_uitvoeren(integer)'::regprocedure); a text := $e1e2a$      SELECT * INTO o FROM public.orders WHERE id = (r->>'orderId')::uuid FOR UPDATE;$e1e2a$; b text := $e1e2b$      SELECT * INTO o FROM public.orders WHERE id = (r->>'orderId')::uuid FOR UPDATE;
+      CONTINUE WHEN COALESCE((public.logistics_pickup_eigen_tijd(o.carrier_id, o.custom_fields)->>'eigen')::boolean, false);$e1e2b$;
+BEGIN
+  IF strpos(d, b) > 0 THEN RETURN; END IF;
+  IF strpos(d, a) = 0 THEN RAISE EXCEPTION 'E1-E: verwachte tekst niet gevonden in logistics_pickup_herstel_uitvoeren(integer)'; END IF;
+  EXECUTE replace(d, a, b);
+END $do$;
+
+DO $do$
+DECLARE d text := pg_get_functiondef('public.logistics_install_check()'::regprocedure); a text := $e1e3a$'logistics_pickup_herbereken()'] LOOP$e1e3a$; b text := $e1e3b$'logistics_pickup_herbereken()', 'logistics_pickup_eigen_tijd(uuid,jsonb)'] LOOP$e1e3b$;
+BEGIN
+  IF strpos(d, b) > 0 THEN RETURN; END IF;
+  IF strpos(d, a) = 0 THEN RAISE EXCEPTION 'E1-E: verwachte tekst niet gevonden in logistics_install_check()'; END IF;
+  EXECUTE replace(d, a, b);
+END $do$;
+
+DO $do$
+DECLARE d text := pg_get_functiondef('public.logistics_schedule_tasks(text)'::regprocedure); a text := $e1e4a$                     AND tt.planned_start >= c.raw_start AND tt.planned_start <= now()$e1e4a$; b text := $e1e4b$                     AND tt.planned_start >= c.raw_start AND tt.planned_start <= now()
+                     AND NOT (c.task_type IN ('buffer.close', 'load.compose')
+                              AND COALESCE(tt.payload->>'sluitRegel', 'werkuren')
+                                  IS DISTINCT FROM CASE WHEN c.verzend_at IS NOT NULL THEN 'verzendmoment' ELSE 'werkuren' END)$e1e4b$;
+BEGIN
+  IF strpos(d, b) > 0 THEN RETURN; END IF;
+  IF strpos(d, a) = 0 THEN RAISE EXCEPTION 'E1-E: verwachte tekst niet gevonden in logistics_schedule_tasks(text)'; END IF;
+  EXECUTE replace(d, a, b);
+END $do$;
+
+DO $do$
+DECLARE d text := pg_get_functiondef('public.logistics_schedule_tasks(text)'::regprocedure); a text := $e1e5a$   WHERE n.id = t.id
+     AND (t.planned_start$e1e5a$; b text := $e1e5b$   WHERE n.id = t.id
+     AND NOT (t.task_type IN ('buffer.close', 'load.compose')
+              AND public._logistics_order_karren_vast((SELECT o.id FROM public.orders o WHERE o.order_number = t.order_ref AND o.deleted_at IS NULL LIMIT 1)))
+     AND (t.planned_start$e1e5b$;
+BEGIN
+  IF strpos(d, b) > 0 THEN RETURN; END IF;
+  IF strpos(d, a) = 0 THEN RAISE EXCEPTION 'E1-E: verwachte tekst niet gevonden in logistics_schedule_tasks(text)'; END IF;
+  EXECUTE replace(d, a, b);
+END $do$;
+
+-- E1-E/A: eigen tijd gewijzigd in Verkoop -> taken opnieuw plannen, zolang er niets geprint of gepickt is.
+CREATE OR REPLACE FUNCTION public.logistics_eigen_tijd_herplan()
+RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  IF NEW.order_number IS NULL OR NEW.deleted_at IS NOT NULL THEN RETURN NULL; END IF;
+  IF (NEW.custom_fields->>'pickup_moment') IS NOT DISTINCT FROM (OLD.custom_fields->>'pickup_moment')
+     AND NEW.carrier_id IS NOT DISTINCT FROM OLD.carrier_id THEN RETURN NULL; END IF;
+  BEGIN
+    IF public._logistics_order_karren_vast(NEW.id) THEN
+      INSERT INTO public.logistics_trace_events(phase, step, status, reason, order_ref, actor)
+      VALUES ('ophaalmoment', 'Ophaaltijd gewijzigd', 'overgeslagen',
+              'Er is al een kar geprint of gepickt; de planning blijft zoals hij was.', NEW.order_number, 'engine');
+      RETURN NULL;
+    END IF;
+    PERFORM public.logistics_schedule_tasks(NEW.order_number);
+    INSERT INTO public.logistics_trace_events(phase, step, status, reason, order_ref, actor)
+    VALUES ('ophaalmoment', 'Ophaaltijd gewijzigd', 'geslaagd',
+            'Was ' || COALESCE(OLD.custom_fields->>'pickup_moment', 'leeg') || ', nu ' || COALESCE(NEW.custom_fields->>'pickup_moment', 'leeg') || '; taken opnieuw gepland.',
+            NEW.order_number, 'engine');
+  EXCEPTION WHEN OTHERS THEN
+    RAISE WARNING 'logistiek-engine: herplannen na ophaaltijd mislukt voor order %: %', NEW.id, SQLERRM;
+    PERFORM public.logistics_melding('logistics_eigen_tijd_herplan', NEW.id,
+      'Taken konden na een gewijzigde ophaaltijd niet opnieuw worden gepland; de volgende ronde probeert het opnieuw', SQLERRM);
+  END;
+  RETURN NULL;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_eigen_tijd_herplan() FROM PUBLIC, anon, authenticated;
+DROP TRIGGER IF EXISTS trg_logistics_eigen_tijd_herplan ON public.orders;
+CREATE TRIGGER trg_logistics_eigen_tijd_herplan AFTER UPDATE OF custom_fields, carrier_id ON public.orders
+  FOR EACH ROW EXECUTE FUNCTION public.logistics_eigen_tijd_herplan();
+
+-- E1-E/2+B: wissel van sluitregel in de werkwijze -> alle open taken meteen opnieuw plannen (geen merge-run).
+CREATE OR REPLACE FUNCTION public.logistics_sluitregel_gewisseld()
+RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  IF public.logistics_rule_text(NEW.settings, 'order_verwerking', 'buffer_sluiten', 'werkuren')
+     IS NOT DISTINCT FROM public.logistics_rule_text(OLD.settings, 'order_verwerking', 'buffer_sluiten', 'werkuren') THEN
+    RETURN NULL;
+  END IF;
+  BEGIN
+    PERFORM public.logistics_schedule_tasks(NULL);
+  EXCEPTION WHEN OTHERS THEN
+    RAISE WARNING 'logistiek-engine: herplannen na wissel sluitregel mislukt: %', SQLERRM;
+    PERFORM public.logistics_melding('logistics_sluitregel_gewisseld', NULL,
+      'Na het wisselen van de sluitregel konden de taken niet meteen opnieuw worden gepland; de volgende ronde doet het alsnog', SQLERRM);
+  END;
+  RETURN NULL;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_sluitregel_gewisseld() FROM PUBLIC, anon, authenticated;
+DROP TRIGGER IF EXISTS trg_logistics_sluitregel_gewisseld ON public.logistics_rule_configs;
+CREATE TRIGGER trg_logistics_sluitregel_gewisseld AFTER UPDATE OF settings ON public.logistics_rule_configs
+  FOR EACH ROW EXECUTE FUNCTION public.logistics_sluitregel_gewisseld();
+
+CREATE OR REPLACE FUNCTION public.logistics_schema_versie()
+ RETURNS text LANGUAGE sql IMMUTABLE SET search_path TO 'public'
+AS $function$ SELECT '2026-11-10h'::text $function$;
+
+-- ===== Correctie E1-E (2026-11-10i)
+-- E1-E correctie (2026-11-10i): een aanmelding telt alleen als "verstuurd" bij de huidige vervoerder en zonder onjuist-markering.
+CREATE OR REPLACE FUNCTION public.logistics_aanmelding_geldig_at(p_order_id uuid, p_carrier_id uuid)
+RETURNS timestamptz LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_ok boolean; v_sent timestamptz; v_onj boolean;
+BEGIN
+  IF p_order_id IS NULL OR p_carrier_id IS NULL OR to_regclass('public.carrier_signup_dispatches') IS NULL THEN RETURN NULL; END IF;
+  IF to_regprocedure('public.afh_order_aangemeld_bij(uuid,uuid)') IS NOT NULL THEN
+    EXECUTE 'SELECT public.afh_order_aangemeld_bij($1, $2)' INTO v_ok USING p_order_id, p_carrier_id;
+    IF NOT COALESCE(v_ok, false) THEN RETURN NULL; END IF;
+  END IF;
+  v_onj := EXISTS (SELECT 1 FROM information_schema.columns
+                    WHERE table_schema = 'public' AND table_name = 'carrier_signup_dispatches' AND column_name = 'onjuist_at');
+  EXECUTE format('SELECT min(d.sent_at) FROM public.carrier_signup_dispatches d
+                   WHERE d.carrier_id = $2 AND d.sent_at IS NOT NULL
+                     AND $1 = ANY(COALESCE(d.order_ids, ''{}''::uuid[])) %s',
+                 CASE WHEN v_onj THEN 'AND d.onjuist_at IS NULL' ELSE '' END)
+    INTO v_sent USING p_order_id, p_carrier_id;
+  RETURN v_sent;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_aanmelding_geldig_at(uuid, uuid) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_aanmelding_geldig_at(uuid, uuid) TO service_role;
+
+-- Gepland verzendmoment volgens de aanmeldgroepen van Afhandeling, bij voorkeur bij de huidige vervoerder.
+CREATE OR REPLACE FUNCTION public.logistics_aanmelding_gepland_at(p_order_id uuid, p_carrier_id uuid)
+RETURNS timestamptz LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_cfg jsonb; v_lead int; v_dag date; v_groups jsonb; v_at timestamptz;
+BEGIN
+  IF p_order_id IS NULL OR to_regprocedure('public.afh_signup_config()') IS NULL
+     OR to_regprocedure('public.afh_signup_groups(date,date,text)') IS NULL THEN RETURN NULL; END IF;
+  EXECUTE 'SELECT public.afh_signup_config()' INTO v_cfg;
+  v_lead := nullif(v_cfg->>'lead_minutes', '')::int;
+  SELECT public.logistics_order_date(o.delivery_date::text) INTO v_dag FROM public.orders o WHERE o.id = p_order_id;
+  IF v_lead IS NULL OR v_dag IS NULL OR nullif(v_cfg->>'timezone', '') IS NULL THEN RETURN NULL; END IF;
+  EXECUTE 'SELECT public.afh_signup_groups($1, $2, $3)->''groups''' INTO v_groups USING v_dag - 1, v_dag + 1, v_cfg->>'timezone';
+  SELECT (g->>'signup_deadline')::timestamptz - make_interval(mins => v_lead) INTO v_at
+    FROM jsonb_array_elements(COALESCE(v_groups, '[]'::jsonb)) g
+   WHERE EXISTS (SELECT 1 FROM jsonb_array_elements(COALESCE(g->'orders', '[]'::jsonb)) e WHERE (e->>'orderId')::uuid = p_order_id)
+   ORDER BY ((g->>'carrier_id')::uuid IS NOT DISTINCT FROM p_carrier_id) DESC, (g->>'signup_deadline')::timestamptz
+   LIMIT 1;
+  RETURN v_at;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_aanmelding_gepland_at(uuid, uuid) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_aanmelding_gepland_at(uuid, uuid) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_aanmeldmoment(p_order_ids uuid[])
+ RETURNS TABLE(order_id uuid, aanmeld_at timestamp with time zone, bron text, tekst text)
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE v_tz text; r record; v_fout text; v_cid uuid; v_at timestamptz; v_bron text; v_sent timestamptz;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_aanmeldmoment');
+  BEGIN v_tz := public.logistics_opening_timezone(); EXCEPTION WHEN others THEN v_tz := NULL; END;
+  IF to_regprocedure('public.afh_signup_moment_for_orders(uuid[])') IS NOT NULL THEN
+    BEGIN
+      FOR r IN EXECUTE 'SELECT order_id, aanmeld_at, bron FROM public.afh_signup_moment_for_orders(p_order_ids => $1)'
+               USING p_order_ids
+      LOOP
+        v_at := r.aanmeld_at; v_bron := r.bron;
+        -- E1-E correctie: "verstuurd" alleen bij een geldige aanmelding voor de huidige vervoerder.
+        IF v_bron = 'verstuurd' THEN
+          SELECT o.carrier_id INTO v_cid FROM public.orders o WHERE o.id = r.order_id;
+          v_sent := public.logistics_aanmelding_geldig_at(r.order_id, v_cid);
+          IF v_sent IS NOT NULL THEN
+            v_at := v_sent;
+          ELSE
+            v_at := public.logistics_aanmelding_gepland_at(r.order_id, v_cid);
+            v_bron := CASE WHEN v_at IS NOT NULL THEN 'gepland' ELSE 'onbekend' END;
+          END IF;
+        END IF;
+        order_id := r.order_id; aanmeld_at := v_at; bron := v_bron;
+        tekst := CASE WHEN v_at IS NOT NULL AND v_tz IS NOT NULL AND v_bron IN ('verstuurd', 'gepland')
+                      THEN 'Verzendbrief komt vrij na de transportaanmelding om ' || to_char(v_at AT TIME ZONE v_tz, 'HH24:MI')
+                      ELSE 'Tijdstip van de transportaanmelding is nog niet bekend' END;
+        RETURN NEXT;
+      END LOOP;
+      RETURN;
+    EXCEPTION WHEN insufficient_privilege THEN v_fout := '42501';
+              WHEN others THEN v_fout := SQLSTATE;
+    END;
+  END IF;
+  FOR r IN SELECT unnest(coalesce(p_order_ids, '{}')) AS id LOOP
+    order_id := r.id; aanmeld_at := NULL; bron := coalesce('fout_' || v_fout, 'onbekend');
+    tekst := 'Tijdstip van de transportaanmelding is nog niet bekend';
+    RETURN NEXT;
+  END LOOP;
+END $function$;
+
+DO $do$
+DECLARE d text := pg_get_functiondef('public.logistics_install_check()'::regprocedure);
+  a text := $a$'logistics_pickup_eigen_tijd(uuid,jsonb)'] LOOP$a$;
+  b text := $b$'logistics_pickup_eigen_tijd(uuid,jsonb)', 'logistics_aanmelding_geldig_at(uuid,uuid)', 'logistics_aanmelding_gepland_at(uuid,uuid)'] LOOP$b$;
+BEGIN
+  IF strpos(d, b) > 0 THEN RETURN; END IF;
+  IF strpos(d, a) = 0 THEN RAISE EXCEPTION 'E1-E correctie: verwachte tekst niet gevonden in logistics_install_check'; END IF;
+  EXECUTE replace(d, a, b);
+END $do$;
+
+CREATE OR REPLACE FUNCTION public.logistics_schema_versie()
+ RETURNS text LANGUAGE sql IMMUTABLE SET search_path TO 'public'
+AS $function$ SELECT '2026-11-10i'::text $function$;