@flowselections/logistiek-engine 1.0.189 → 1.0.193

package/db/schema/logistiek-engine.sql

@@ -30364,3 +30364,1471 @@ END $function$;
 REVOKE ALL ON FUNCTION public.logistics_plan_fail_log(text, uuid, text, text) FROM PUBLIC, anon, authenticated;
 GRANT EXECUTE ON FUNCTION public.logistics_plan_fail_log(text, uuid, text, text) TO service_role;
 COMMENT ON FUNCTION public.logistics_plan_fail_log(text, uuid, text, text) IS 'Logistiek Engine: legt een mislukte aanmelding voor (her)planning vast in het logboek en zet de order alsnog in de planwachtrij.';
+
+-- ===========================================================================
+-- 1.0.190: dubbelzinnige overloads, verzendbrief zonder terugval, controle.
+-- Herhaalbaar; verwijdert niets.
+-- ===========================================================================
+CREATE OR REPLACE FUNCTION public.logistics_scan_delays()
+ RETURNS integer
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  rec record;
+  cnt integer := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_scan_delays');
+  FOR rec IN
+    SELECT o.id
+      FROM public.orders o
+     WHERE o.deleted_at IS NULL
+       AND o.delivery_date IS NOT NULL
+       AND NULLIF(o.delivery_date::text, '')::date < current_date
+       AND COALESCE(o.status::text, '') NOT IN ('delivered', 'cancelled', 'Geleverd', 'Geannuleerd')
+       AND NOT EXISTS (
+         SELECT 1 FROM public.logistics_delay_alerts d
+          WHERE d.order_id = o.id AND d.status = 'open')
+     LIMIT 200
+  LOOP
+    PERFORM public.logistics_report_delay(p_order_id => rec.id, p_reason => 'Geplande leverdatum is verstreken', p_expected_date => NULL::date, p_force_customer_email => false);
+    cnt := cnt + 1;
+  END LOOP;
+  RETURN cnt;
+END;
+$function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_document_type_map(_document_code text)
+ RETURNS doc_layout_type[]
+ LANGUAGE sql
+ IMMUTABLE
+ SET search_path TO 'public'
+AS $function$
+  WITH c AS (SELECT lower(btrim(coalesce(_document_code, ''))) AS code)
+  SELECT CASE
+    WHEN c.code = '' THEN ARRAY[]::public.doc_layout_type[]
+    WHEN c.code LIKE '%pakbon%' THEN ARRAY['pakbon']::public.doc_layout_type[]
+    WHEN c.code LIKE '%afleverbrief%' OR c.code LIKE '%afleverbon%'
+      THEN ARRAY['afleverbrief','transportdocument']::public.doc_layout_type[]
+    WHEN c.code LIKE '%veilingbrief%'
+      THEN ARRAY['veilingbrief','transportdocument']::public.doc_layout_type[]
+    WHEN c.code LIKE '%veilingbon%'
+      THEN ARRAY['veilingbon','veilingbrief','transportdocument']::public.doc_layout_type[]
+    WHEN c.code LIKE '%verzendbrief%' OR c.code LIKE '%transportbrief%'
+      THEN ARRAY['afleverbrief','transportdocument']::public.doc_layout_type[]
+    WHEN c.code LIKE '%verzendlabel%'
+      THEN ARRAY['verzendlabel','transportdocument']::public.doc_layout_type[]
+    WHEN c.code LIKE '%productiebon%'
+      THEN ARRAY['productiebon']::public.doc_layout_type[]
+    WHEN c.code LIKE '%productielijst%'
+      THEN ARRAY['magazijnlijst','productiebon']::public.doc_layout_type[]
+    WHEN c.code LIKE '%controlelijst%' OR c.code LIKE '%controlebrief%'
+      THEN ARRAY['controlelijst']::public.doc_layout_type[]
+    WHEN c.code LIKE '%magazijnlijst%'
+      THEN ARRAY['magazijnlijst']::public.doc_layout_type[]
+    WHEN c.code LIKE '%sticker%'
+      THEN ARRAY['sticker','etiket']::public.doc_layout_type[]
+    WHEN c.code LIKE '%etiket%'
+      THEN ARRAY['etiket','sticker']::public.doc_layout_type[]
+    WHEN c.code LIKE '%productlabel%'
+      THEN ARRAY['productlabel','etiket']::public.doc_layout_type[]
+    WHEN c.code LIKE '%barcode%'
+      THEN ARRAY['barcode_label','etiket']::public.doc_layout_type[]
+    WHEN c.code LIKE '%label%'
+      THEN ARRAY['etiket']::public.doc_layout_type[]
+    WHEN c.code LIKE '%factuur%' THEN ARRAY['factuur']::public.doc_layout_type[]
+    WHEN c.code LIKE '%offerte%' THEN ARRAY['offerte']::public.doc_layout_type[]
+    WHEN c.code LIKE '%orderbevestiging%' THEN ARRAY['orderbevestiging']::public.doc_layout_type[]
+    WHEN c.code LIKE '%retourbon%' THEN ARRAY['vrij']::public.doc_layout_type[]
+    ELSE ARRAY[]::public.doc_layout_type[]
+  END
+  FROM c;
+$function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_shipping_note_job_for_slip(_slip_job_id uuid)
+ RETURNS uuid
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  slip public.print_jobs;
+  layout_meta jsonb;
+  v_layout uuid;
+  v_doc_type text;
+  v_layout_type text;
+  v_key text;
+  v_bron boolean;
+  v_order text;
+  v_res jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_shipping_note_job_for_slip');
+  SELECT * INTO slip FROM public.print_jobs WHERE id = _slip_job_id;
+  IF NOT FOUND THEN RETURN NULL; END IF;
+  v_order := coalesce(slip.payload->>'ordernummer', slip.payload->>'order_number');
+
+  v_bron := public.logistics_payload_is_floriday(slip.payload);
+  IF v_bron IS TRUE THEN
+    INSERT INTO public.logistics_events(source_module, event_type, status, processed_at, payload)
+    VALUES ('logistiek-engine', 'shippingnote.blocked', 'verwerkt', now(), jsonb_build_object(
+      'slipJobId', _slip_job_id, 'orderNumber', v_order,
+      'reason', 'floriday_order_geen_eigen_verzendbrief'));
+    RETURN NULL;
+  END IF;
+
+  v_key := 'verzendbrief-bij-pakbon:' || _slip_job_id::text;
+
+  -- 1.0.190: geen terugval meer. Herkomst onbekend of geen layout = fail closed met reden.
+  IF v_bron IS NULL THEN
+    BEGIN
+      INSERT INTO public.logistics_trace_events(phase, step, status, reason, order_ref, slip_ref)
+      VALUES ('verzendbrief', 'Verzendbrief wacht: herkomst onbekend', 'geblokkeerd',
+        'HERKOMST_ONBEKEND: de herkomst van de order kon niet worden bepaald; er wordt geen verzendbrief gegokt.',
+        coalesce(v_order, slip.payload->>'order_id'), _slip_job_id::text);
+    EXCEPTION WHEN OTHERS THEN NULL;
+    END;
+    RETURN NULL;
+  END IF;
+
+  layout_meta := public.logistics_document_for_order(
+    public.logistics_try_uuid(coalesce(slip.payload->>'order_id', slip.payload->>'orderId')), 'verzendbrief');
+  v_layout := public.logistics_try_uuid(layout_meta->>'layout_id');
+  SELECT l.documenttype::text INTO v_layout_type FROM public.document_layouts l WHERE l.id = v_layout AND l.actief IS TRUE;
+  IF NOT coalesce((layout_meta->>'ok')::boolean, false) OR v_layout_type IS NULL THEN
+    BEGIN
+      INSERT INTO public.logistics_trace_events(phase, step, status, reason, order_ref, slip_ref)
+      VALUES ('verzendbrief', 'Verzendbrief wacht: geen layout', 'geblokkeerd',
+        'GEEN_LAYOUT_VERZENDBRIEF: ' || coalesce(nullif(layout_meta->>'reden', ''), 'Er is geen actieve layout voor de verzendbrief van deze order.'),
+        coalesce(v_order, slip.payload->>'order_id'), _slip_job_id::text);
+    EXCEPTION WHEN OTHERS THEN NULL;
+    END;
+    RETURN NULL;
+  END IF;
+  v_doc_type := v_layout_type;
+
+  v_res := public.logistics_print_via_layout(
+    v_doc_type, coalesce(slip.documentnaam, 'Verzendbrief') || ' · verzendbrief', NULL, NULL,
+    v_layout, nullif(slip.payload->>'print_plek_id', '')::uuid, 'eigen', coalesce(slip.is_herprint, false),
+    (coalesce(slip.payload, '{}'::jsonb) - 'cartId' - 'pick_station' - 'printPlekId' - 'print_place_id' - 'printPlaceId')
+      || jsonb_build_object(
+        'ordernummer', v_order,
+        'document_type_code', 'verzendbrief', 'documentType', 'verzendbrief', 'layout_id', v_layout,
+        'trigger', 'with_packing_slip', 'is_floriday', false,
+        'layout_keuze', layout_meta->>'keuze',
+        'packing_slip_job_id', _slip_job_id, 'print_batch_key', 'kar-print:' || _slip_job_id::text),
+    v_key);
+
+  IF NOT coalesce((v_res->>'ok')::boolean, false) THEN
+    BEGIN
+      INSERT INTO public.logistics_trace_events(phase, step, status, reason, order_ref, slip_ref)
+      VALUES ('verzendbrief', 'Verzendbrief bij pakbon niet geprint', 'mislukt', v_res->>'error',
+              coalesce(v_order, slip.payload->>'order_id'), _slip_job_id::text);
+    EXCEPTION WHEN OTHERS THEN NULL;
+    END;
+    RETURN NULL;
+  END IF;
+  RETURN (v_res->>'job_id')::uuid;
+END;
+$function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_overload_check()
+RETURNS TABLE(onderdeel text, ok boolean, toelichting text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE r record; v_n integer := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_overload_check');
+  -- Dubbelzinnig: een kortere overload waarvan de aanroep ook op een langere past
+  -- (alle extra parameters van de langere hebben een standaardwaarde).
+  FOR r IN
+    SELECT a.proname,
+           pg_get_function_identity_arguments(a.oid) AS kort,
+           pg_get_function_identity_arguments(b.oid) AS lang
+      FROM pg_proc a
+      JOIN pg_proc b ON b.proname = a.proname AND b.pronamespace = a.pronamespace AND b.oid <> a.oid
+     WHERE a.pronamespace = 'public'::regnamespace
+       AND a.proname LIKE 'logistics\_%'
+       AND b.pronargs > a.pronargs
+       AND b.pronargs - b.pronargdefaults <= a.pronargs
+       AND (a.pronargs = 0 OR (b.proargtypes::oid[])[0:a.pronargs - 1] = (a.proargtypes::oid[])[0:a.pronargs - 1])
+  LOOP
+    v_n := v_n + 1;
+    onderdeel := 'overload:' || r.proname;
+    ok := false;
+    toelichting := format('Dubbelzinnig: (%s) en (%s). Aanroepen gebeuren met benoemde argumenten; Shell-objecten worden niet verwijderd.', r.kort, r.lang);
+    RETURN NEXT;
+  END LOOP;
+  IF v_n = 0 THEN
+    onderdeel := 'overloads'; ok := true; toelichting := 'Geen dubbelzinnige overloads'; RETURN NEXT;
+  END IF;
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_overload_check() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_overload_check() TO authenticated, service_role;
+
+DO $ic190$
+DECLARE v_def text;
+BEGIN
+  v_def := pg_get_functiondef('public.logistics_install_check()'::regprocedure);
+  IF v_def NOT LIKE '%logistics_overload_check()%' THEN
+    v_def := regexp_replace(v_def, 'END \$function\$\s*$', E'  RETURN QUERY SELECT * FROM public.logistics_overload_check();\nEND $function$');
+    EXECUTE v_def;
+  END IF;
+END $ic190$;
+-- 1.0.190 deel 2: verzendbriefstatus, barcode-pad, stickerreden, stickermaten, beladingbevestiging. Herhaalbaar; verwijdert niets.
+CREATE OR REPLACE FUNCTION public.logistics_shipping_note_status(p_slip_job_id uuid DEFAULT NULL::uuid, p_cart_id uuid DEFAULT NULL::uuid)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_note public.logistics_slip_shipping_note;
+  v_slip public.print_jobs;
+  v_job public.print_jobs;
+  v_state text; v_message text; v_cart uuid;
+  v_vrijgave boolean := false; v_scan_ok boolean;
+BEGIN
+  IF p_slip_job_id IS NULL AND p_cart_id IS NULL THEN
+    RETURN jsonb_build_object('status','mislukt','message',
+      'De pakbon of kar ontbreekt; de verzendbriefstatus kan niet worden opgehaald.','attempts',0,'nextAttemptAt',NULL);
+  END IF;
+  IF p_slip_job_id IS NOT NULL THEN
+    SELECT * INTO v_slip FROM public.print_jobs WHERE id = p_slip_job_id;
+  ELSE
+    SELECT * INTO v_slip FROM public.print_jobs p
+     WHERE lower(coalesce(p.payload->>'document_type_code', p.payload->>'documentType', p.documenttype::text, '')) LIKE '%pakbon%'
+       AND nullif(coalesce(p.payload->>'cart_id', p.payload->'cart'->>'cartId'), '') = p_cart_id::text
+     ORDER BY p.created_at DESC LIMIT 1;
+  END IF;
+  IF v_slip.id IS NULL THEN
+    RETURN jsonb_build_object('status','mislukt','message','De bijbehorende pakbon is niet gevonden.',
+      'attempts',0,'nextAttemptAt',NULL,'cartId',p_cart_id);
+  END IF;
+  BEGIN
+    v_cart := coalesce(nullif(v_slip.payload->>'cart_id','')::uuid, nullif(v_slip.payload->'cart'->>'cartId','')::uuid, p_cart_id);
+  EXCEPTION WHEN invalid_text_representation THEN v_cart := p_cart_id;
+  END;
+  SELECT * INTO v_note FROM public.logistics_slip_shipping_note s
+   WHERE s.slip_job_id = v_slip.id ORDER BY s.created_at DESC LIMIT 1;
+
+  IF v_note.id IS NULL THEN
+    SELECT * INTO v_job FROM public.print_jobs p
+     WHERE p.idempotentie_sleutel = 'verzendbrief-bij-pakbon:' || v_slip.id::text
+        OR (p.payload->>'packing_slip_job_id' = v_slip.id::text
+            AND lower(coalesce(p.payload->>'document_type_code', p.documenttype::text, '')) ~ '(verzend|aflever)')
+     ORDER BY p.created_at DESC LIMIT 1;
+    IF v_job.id IS NULL THEN
+      IF v_slip.created_at < now() - interval '15 minutes' THEN
+        v_state := 'mislukt';
+        v_message := 'Er is geen verzendbrief bij deze pakbon aangemaakt. Controleer de printwachtrij of print de pakbon opnieuw.';
+      ELSE
+        v_state := 'klaar_voor_print'; v_message := 'Verzendbrief wordt klaargezet.';
+      END IF;
+    ELSIF v_job.status = 'voltooid' THEN
+      v_state := 'geprint'; v_message := 'Pakbon en verzendbrief zijn naar de printer gestuurd.';
+    ELSIF v_job.status IN ('wachtend','bezig') THEN
+      v_state := 'klaar_voor_print'; v_message := 'Verzendbrief wordt klaargezet.';
+    ELSE
+      v_state := 'mislukt'; v_message := 'De verzendbrief kon niet worden geprint. Controleer de printwachtrij.';
+    END IF;
+    RETURN jsonb_build_object('status',v_state,'message',v_message,
+      'attempts',coalesce(v_job.pogingen,0),'nextAttemptAt',v_job.volgende_poging,
+      'slipJobId',v_slip.id,'shippingNoteJobId',v_job.id,'cartId',v_cart,
+      'orderNumber',coalesce(v_slip.payload->>'order_number', v_slip.payload->'data'->>'orderNumber'));
+  END IF;
+
+  IF v_note.print_job_id IS NOT NULL THEN
+    SELECT * INTO v_job FROM public.print_jobs WHERE id = v_note.print_job_id;
+  END IF;
+  v_scan_ok := EXISTS (SELECT 1 FROM public.logistics_control_scan cs
+                        WHERE cs.cart_id = coalesce(v_note.cart_id, v_cart) AND cs.approved_at IS NOT NULL);
+
+  IF v_note.status = 'mislukt' THEN
+    v_state := 'mislukt'; v_message := 'De officiële Floriday-afleverbrief kon niet worden klaargezet. Controleer de verzendbriefwachtrij.';
+  ELSIF v_note.status = 'wacht_op_vrijgave'
+     OR (v_note.status = 'wachtend' AND v_note.retry_class IN ('wacht_op_vrijgave','wacht_op_kenmerk'))
+     OR (v_note.status = 'wachtend' AND v_note.retry_class IS NULL AND coalesce(v_note.attempts,0) = 0 AND NOT v_scan_ok) THEN
+    v_state := 'wacht_op_floriday'; v_vrijgave := true;
+    -- 1.0.190: echte wachtreden uit de wachtrij, geen vaste tekst meer.
+    v_message := 'Pakbon geprint — verzendbrief wacht: ' || coalesce(nullif(btrim(v_note.error), ''),
+      CASE WHEN NOT v_scan_ok THEN 'op een goedgekeurde controlescan.'
+           ELSE 'tot Afhandeling de belading naar Floriday heeft gestuurd (na het aanmeldmoment van het transport).' END);
+  ELSIF v_note.status = 'wachtend' AND v_note.retry_class = 'nog_niet_beschikbaar' THEN
+    v_state := 'wacht_op_floriday'; v_message := 'Pakbon geprint — wachten op officiële Floriday-afleverbrief.';
+  ELSIF v_note.status = 'wachtend' AND v_note.retry_class = 'tijdelijk' AND coalesce(v_note.attempts,0) > 0
+        AND coalesce(v_note.error,'') ~* '(5\d\d|429|time-?out|netwerk|verbinding|niet bereikbaar)' THEN
+    v_state := 'klaar_voor_print'; v_message := 'Floriday is tijdelijk niet bereikbaar. De verzendbrief wordt automatisch opnieuw geprobeerd.';
+  ELSIF v_note.status = 'wachtend' AND v_note.retry_class = 'limiet_bereikt' THEN
+    v_state := 'mislukt'; v_message := 'Het maximale aantal pogingen voor de verzendbrief is bereikt. Controleer de verzendbriefwachtrij.';
+  ELSIF v_note.status = 'wachtend' THEN
+    v_state := 'klaar_voor_print'; v_message := 'Verzendbrief wordt klaargezet.';
+  ELSIF v_job.status = 'voltooid' THEN
+    v_state := 'geprint'; v_message := 'Pakbon en verzendbrief zijn naar de printer gestuurd.';
+  ELSIF v_job.status IN ('mislukt','geannuleerd') THEN
+    v_state := 'mislukt'; v_message := 'De verzendbrief kon niet worden geprint. Controleer de printwachtrij.';
+  ELSE
+    v_state := 'klaar_voor_print'; v_message := 'De officiële Floriday-afleverbrief wordt naar dezelfde printer gestuurd.';
+  END IF;
+
+  RETURN jsonb_build_object('status',v_state,'message',v_message,
+    'attempts',coalesce(v_note.attempts,0),'nextAttemptAt',v_note.next_attempt_at,
+    'slipJobId',v_slip.id,'shippingNoteJobId',v_note.print_job_id,
+    'cartId',coalesce(v_note.cart_id, v_cart),'orderNumber',v_note.order_number,
+    'wachtOpVrijgave', v_vrijgave,
+    'wachtReden', CASE WHEN v_vrijgave THEN coalesce(nullif(btrim(v_note.error), ''), v_message) END,
+    'wachtCode', CASE WHEN v_vrijgave THEN coalesce(v_note.retry_class, v_note.status) END,
+    -- Verwacht tijdstip: volgt zodra Afhandeling het aanmeldmoment levert (koppelprompt).
+    'verwachtOm', NULL::timestamptz);
+END;
+$function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_shipping_note_from_barcode(p_barcode text, p_allow_reprint boolean DEFAULT false, p_station_id uuid DEFAULT NULL::uuid)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_look jsonb;
+  v_cart jsonb;
+  v_cart_id uuid;
+  v_order_id uuid;
+  v_order_number text;
+  v_layout jsonb;
+  v_layout_id uuid;
+  v_doc_type text;
+  v_plek uuid;
+  v_herprint boolean;
+  v_volgnr integer;
+  v_res jsonb;
+BEGIN
+  v_look := public.logistics_barcode_lookup(p_barcode);
+  IF NOT COALESCE((v_look->>'ok')::boolean, false) THEN
+    RETURN v_look;
+  END IF;
+
+  v_cart := v_look->'cart';
+  v_cart_id := nullif(v_cart->>'cartId', '')::uuid;
+  v_order_id := nullif(v_look->>'orderId', '')::uuid;
+  v_order_number := v_look->'order'->>'orderNumber';
+
+  IF COALESCE((v_look->>'alreadyPrinted')::boolean, false) AND NOT COALESCE(p_allow_reprint, false) THEN
+    RETURN v_look || jsonb_build_object(
+      'ok', false,
+      'errorCode', 'al_geprint',
+      'error', 'Voor deze kar is al een verzendbrief gemaakt. Kies bewust voor opnieuw printen als dat de bedoeling is.');
+  END IF;
+
+  -- 1.0.190: layout via de centrale documentkeuze per order; geen terugval op 'verzendlabel'.
+  v_layout := public.logistics_document_for_order(v_order_id, 'verzendbrief');
+  v_layout_id := public.logistics_try_uuid(v_layout->>'layout_id');
+  SELECT l.documenttype::text INTO v_doc_type FROM public.document_layouts l WHERE l.id = v_layout_id AND l.actief IS TRUE;
+  IF NOT coalesce((v_layout->>'ok')::boolean, false) OR v_doc_type IS NULL THEN
+    RETURN v_look || jsonb_build_object(
+      'ok', false,
+      'errorCode', 'GEEN_LAYOUT_VERZENDBRIEF',
+      'error', coalesce(nullif(v_layout->>'reden', ''), 'Er is geen actieve layout voor de verzendbrief van deze order.'),
+      'printJobId', NULL, 'layoutId', NULL, 'documentType', NULL, 'printPlekId', NULL);
+  END IF;
+
+  PERFORM public.logistics_ensure_cart_barcode(v_cart_id);
+
+  IF p_station_id IS NOT NULL THEN
+    SELECT k.print_plek_id INTO v_plek FROM public.print_plek_koppelingen k
+     WHERE k.bron = 'pickstation' AND k.bron_id = p_station_id::text
+     ORDER BY k.created_at LIMIT 1;
+  END IF;
+
+  v_herprint := COALESCE(p_allow_reprint, false) AND COALESCE((v_look->>'alreadyPrinted')::boolean, false);
+  SELECT count(*) INTO v_volgnr FROM public.logistics_shipping_note_scan WHERE cart_id = v_cart_id;
+
+  v_res := public.logistics_print_via_layout(
+    v_doc_type, 'Verzendbrief ' || coalesce(v_order_number, ''), NULL, NULL,
+    v_layout_id, v_plek, NULL, v_herprint,
+    jsonb_build_object(
+      'source', 'pakbon_scan',
+      'barcode', v_look->>'barcode',
+      'order_id', v_order_id,
+      'ordernummer', v_order_number,
+      'order_number', v_order_number,
+      'customer_name', v_look->'order'->>'customerName',
+      'cart_id', v_cart_id,
+      'cart_index', v_cart->>'cartIndex',
+      'cart_total', v_cart->>'cartTotal',
+      'cart_label', v_cart->>'cartLabel',
+      'print_plek_id', v_plek,
+      'station_id', p_station_id,
+      'layout_keuze', v_layout->>'keuze',
+      'data', v_cart),
+    'verzendbrief-scan:' || coalesce(v_cart_id::text, v_look->>'barcode') || ':' || v_volgnr::text);
+
+  IF NOT coalesce((v_res->>'ok')::boolean, false) THEN
+    RETURN v_look || jsonb_build_object(
+      'ok', false,
+      'errorCode', lower(v_res->>'error_code'),
+      'error', v_res->>'error',
+      'printJobId', NULL, 'layoutId', v_layout_id, 'documentType', v_doc_type, 'printPlekId', v_plek);
+  END IF;
+
+  IF NOT coalesce((v_res->>'bestaand')::boolean, false) THEN
+    INSERT INTO public.logistics_shipping_note_scan(cart_id, order_id, barcode, print_job_id, is_reprint)
+    VALUES (v_cart_id, v_order_id, v_look->>'barcode', (v_res->>'job_id')::uuid,
+            COALESCE((v_look->>'alreadyPrinted')::boolean, false));
+  END IF;
+
+  RETURN v_look || jsonb_build_object(
+    'ok', true,
+    'printJobId', (v_res->>'job_id')::uuid,
+    'layoutId', v_layout_id,
+    'documentType', v_doc_type,
+    'printPlekId', v_plek,
+    'warning', NULL);
+END;
+$function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_cart_sticker_state(p_cart_id uuid)
+ RETURNS jsonb
+ LANGUAGE sql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+  WITH s AS (SELECT * FROM public.logistics_sticker_prints WHERE cart_id = p_cart_id),
+  vraag AS (
+    SELECT count(*) FILTER (WHERE coalesce(oi.needs_sticker, false)) AS met_sticker, count(*) AS regels
+      FROM public.order_cart_items ci
+      LEFT JOIN public.order_items oi ON oi.id::text = split_part(ci.order_item_id::text, '::', 1)
+     WHERE ci.cart_id = p_cart_id
+  ),
+  t AS (
+    SELECT
+      count(*) FILTER (WHERE status <> 'niet_printen') AS totaal,
+      count(*) FILTER (WHERE status IN ('in_printwachtrij','afgemeld')) AS in_wachtrij,
+      count(*) FILTER (WHERE status IN ('wacht_op_moment','klaar')) AS wachtend,
+      count(*) FILTER (WHERE status IN ('geblokkeerd','mislukt')) AS geblokkeerd,
+      count(*) FILTER (WHERE status = 'niet_printen') AS niet_printen,
+      (array_agg(reden ORDER BY soort, bron_id) FILTER (WHERE status = 'niet_printen' AND coalesce(btrim(reden), '') <> ''))[1] AS niet_reden,
+      coalesce(jsonb_agg(jsonb_build_object('soort', soort, 'stickerId', bron_id, 'kopieen', kopieen,
+         'status', status, 'reden', reden, 'printJobId', print_job_id, 'breedteMm', breedte_mm, 'hoogteMm', hoogte_mm)
+         ORDER BY soort, bron_id), '[]'::jsonb) AS regels
+    FROM s
+  )
+  SELECT jsonb_build_object(
+    'cartId', p_cart_id,
+    'totaal', t.totaal,
+    'inPrintwachtrij', t.in_wachtrij,
+    'wachtend', t.wachtend,
+    'geblokkeerd', t.geblokkeerd,
+    'regels', t.regels,
+    -- 1.0.190: waarom deze kar geen stickers heeft, in gewone taal.
+    'stickersNodig', t.totaal > 0,
+    'geenStickersReden', CASE
+      WHEN t.totaal > 0 THEN NULL
+      WHEN t.niet_printen > 0 THEN coalesce(t.niet_reden, 'De stickers van deze kar hoeven niet geprint te worden.')
+      WHEN v.regels = 0 THEN 'Deze kar heeft geen regels.'
+      WHEN v.met_sticker = 0 THEN 'Geen regel op deze kar vraagt om een sticker.'
+      ELSE 'Er vraagt een regel om een sticker, maar die is nog niet klaargezet. De stickerronde pakt dit automatisch op.'
+    END)
+  FROM t, vraag v;
+$function$;
+
+-- Layouts 1.69.11: benodigde stickermaten per dag en printplek.
+CREATE OR REPLACE FUNCTION public.logistics_sticker_maten_per_dag(p_van date, p_tot date)
+RETURNS TABLE(dag date, print_plek_id text, breedte_mm numeric, hoogte_mm numeric, aantal integer)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_sticker_maten_per_dag');
+  IF p_van IS NULL OR p_tot IS NULL OR p_tot < p_van THEN
+    RAISE EXCEPTION 'Geef een geldige periode op (van t/m tot).' USING ERRCODE = '22023';
+  END IF;
+  RETURN QUERY
+  SELECT coalesce(c.departure_at::date, o.delivery_date) AS dag,
+         s.print_plek_id,
+         s.breedte_mm,   -- leeg = maat onbekend (apart geteld)
+         s.hoogte_mm,
+         sum(greatest(coalesce(s.kopieen, 1), 1))::integer AS aantal
+    FROM public.logistics_sticker_prints s
+    LEFT JOIN public.order_carts c ON c.id = s.cart_id
+    LEFT JOIN public.orders o ON o.id = s.order_id
+   WHERE s.status NOT IN ('niet_printen', 'afgemeld')
+     AND coalesce(c.departure_at::date, o.delivery_date) BETWEEN p_van AND p_tot
+   GROUP BY 1, 2, 3, 4
+   ORDER BY 1, 2, 3, 4;
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_sticker_maten_per_dag(date, date) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_sticker_maten_per_dag(date, date) TO authenticated, service_role;
+
+-- C: wat wacht op bevestiging van de belading (per order en verpakking).
+CREATE OR REPLACE FUNCTION public.logistics_belading_wacht(p_order_id uuid DEFAULT NULL)
+RETURNS TABLE(order_id uuid, order_ref text, product text, sleutel text, redenen text[], sinds timestamptz)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_belading_wacht');
+  RETURN QUERY
+  SELECT DISTINCT ON (x.oid, x.sleutel)
+         x.oid, o.order_number::text, x.product, x.sleutel, x.redenen, x.sinds
+    FROM (
+      SELECT public.logistics_try_uuid(c->>'order_id') AS oid,
+             c->>'product' AS product,
+             c->>'sleutel' AS sleutel,
+             ARRAY(SELECT jsonb_array_elements_text(coalesce(c->'redenen', '[]'::jsonb))) AS redenen,
+             e.created_at AS sinds
+        FROM public.logistics_events e,
+             LATERAL jsonb_path_query(e.payload, '$.**.bevestigen[*]') c
+       WHERE e.event_type = 'plan.blocked'
+         AND e.created_at > now() - interval '14 days'
+    ) x
+    JOIN public.orders o ON o.id = x.oid
+   WHERE x.oid IS NOT NULL AND coalesce(x.sleutel, '') <> ''
+     AND (p_order_id IS NULL OR x.oid = p_order_id)
+     AND EXISTS (SELECT 1 FROM public.logistics_plan_queue q
+                  WHERE q.order_id = x.oid AND q.status = 'geblokkeerd'
+                    AND q.reason_code = 'belading_onwaarschijnlijk')
+     AND NOT EXISTS (SELECT 1 FROM public.logistics_belading_bevestigingen b
+                      WHERE b.order_id = x.oid AND b.verpakking_sleutel = x.sleutel)
+   ORDER BY x.oid, x.sleutel, x.sinds DESC;
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_belading_wacht(uuid) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_belading_wacht(uuid) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_check_190()
+RETURNS TABLE(onderdeel text, ok boolean, toelichting text)
+LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+  SELECT 'functie:' || f, to_regprocedure(f) IS NOT NULL,
+         CASE WHEN to_regprocedure(f) IS NOT NULL THEN 'aanwezig' ELSE 'ontbreekt (schemasync controleren)' END
+    FROM unnest(ARRAY[
+      'public.logistics_sticker_maten_per_dag(date,date)',
+      'public.logistics_belading_wacht(uuid)',
+      'public.logistics_overload_check()',
+      'public.logistics_cart_sticker_state(uuid)']) f;
+$function$;
+REVOKE ALL ON FUNCTION public.logistics_check_190() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_check_190() TO authenticated, service_role;
+
+DO $ic190b$
+DECLARE v_def text;
+BEGIN
+  v_def := pg_get_functiondef('public.logistics_install_check()'::regprocedure);
+  IF v_def NOT LIKE '%logistics_check_190()%' THEN
+    v_def := regexp_replace(v_def, 'END \$function\$\s*$', E'  RETURN QUERY SELECT * FROM public.logistics_check_190();\nEND $function$');
+    EXECUTE v_def;
+  END IF;
+END $ic190b$;
+
+-- ===== 1.0.190 deel 3 =====
+-- Logistiek Engine 1.0.190 deel 3: plausibiliteit-waarschuwingen, lagen, opnieuw combineren,
+-- correctiefuncties, pickstation-voorbeeld, aanmeldmoment. Herhaalbaar; geen datacorrecties.
+
+ALTER TABLE public.order_cart_items ADD COLUMN IF NOT EXISTS lagen numeric;
+COMMENT ON COLUMN public.order_cart_items.layer_fraction IS 'Vulling van één laag (0–1).';
+COMMENT ON COLUMN public.order_cart_items.lagen IS 'Aantal lagen = fusten ÷ fusten per laag (mag groter zijn dan 1).';
+
+CREATE TABLE IF NOT EXISTS public.logistics_belading_waarschuwingen (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  order_id uuid NOT NULL,
+  sleutel text NOT NULL,
+  tekst text NOT NULL,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now(),
+  UNIQUE (order_id, sleutel)
+);
+GRANT SELECT ON public.logistics_belading_waarschuwingen TO authenticated;
+GRANT ALL ON public.logistics_belading_waarschuwingen TO service_role;
+ALTER TABLE public.logistics_belading_waarschuwingen ENABLE ROW LEVEL SECURITY;
+DROP POLICY IF EXISTS "Ingelogd mag beladingwaarschuwingen lezen" ON public.logistics_belading_waarschuwingen;
+CREATE POLICY "Ingelogd mag beladingwaarschuwingen lezen" ON public.logistics_belading_waarschuwingen
+  FOR SELECT TO authenticated USING (true);
+
+CREATE OR REPLACE FUNCTION public.logistics_belading_waarschuwingen_zet(p_order_ids uuid[], p_items jsonb)
+RETURNS integer LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_n integer := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_belading_waarschuwingen_zet');
+  IF p_order_ids IS NULL OR array_length(p_order_ids, 1) IS NULL THEN RETURN 0; END IF;
+  DELETE FROM public.logistics_belading_waarschuwingen w
+   WHERE w.order_id = ANY(p_order_ids)
+     AND NOT EXISTS (SELECT 1 FROM jsonb_array_elements(coalesce(p_items, '[]'::jsonb)) i
+                      WHERE (i.value->>'order_id')::uuid = w.order_id AND i.value->>'sleutel' = w.sleutel);
+  INSERT INTO public.logistics_belading_waarschuwingen (order_id, sleutel, tekst)
+  SELECT DISTINCT ON ((i.value->>'order_id')::uuid, i.value->>'sleutel')
+         (i.value->>'order_id')::uuid, i.value->>'sleutel', left(i.value->>'tekst', 500)
+    FROM jsonb_array_elements(coalesce(p_items, '[]'::jsonb)) i
+   WHERE (i.value->>'order_id') IS NOT NULL AND (i.value->>'order_id')::uuid = ANY(p_order_ids)
+  ON CONFLICT (order_id, sleutel) DO UPDATE SET tekst = EXCLUDED.tekst, updated_at = now()
+   WHERE public.logistics_belading_waarschuwingen.tekst IS DISTINCT FROM EXCLUDED.tekst;
+  GET DIAGNOSTICS v_n = ROW_COUNT;
+  RETURN v_n;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_belading_waarschuwingen_zet(uuid[], jsonb) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_belading_waarschuwingen_zet(uuid[], jsonb) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_apply_cart_swap(p_delete_ids uuid[], p_new_carts jsonb)
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_del uuid[] := COALESCE(p_delete_ids, ARRAY[]::uuid[]);
+  v_cart jsonb; v_row jsonb; v_id uuid; v_map jsonb := '[]'::jsonb;
+  v_jobs int := 0; v_carts int := 0; v_items int := 0; v_locked int;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_apply_cart_swap');
+  IF jsonb_typeof(COALESCE(p_new_carts, '[]'::jsonb)) <> 'array' THEN
+    RAISE EXCEPTION 'Nieuwe karren ontbreken of zijn ongeldig.';
+  END IF;
+  IF EXISTS (
+    SELECT 1 FROM jsonb_array_elements(COALESCE(p_new_carts, '[]'::jsonb)) c,
+                  jsonb_array_elements(COALESCE(c.value->'items', '[]'::jsonb)) i
+     WHERE coalesce((i.value->>'plants_per_crate')::numeric, 0) <= 0
+        OR coalesce((i.value->>'crates')::numeric, 0) < 0) THEN
+    RAISE EXCEPTION 'Karwissel geweigerd: een karregel mist planten per fust (belading_onvolledig).';
+  END IF;
+  IF EXISTS (SELECT 1 FROM jsonb_array_elements(COALESCE(p_new_carts, '[]'::jsonb)) c
+              WHERE nullif(btrim(coalesce(c.value->'row'->>'carrier_type', '')), '') IS NULL) THEN
+    RAISE EXCEPTION 'Karwissel geweigerd: een kar heeft geen ladingdrager (Ladingdrager onbekend). Er is niets gewijzigd.';
+  END IF;
+  IF EXISTS (
+    SELECT 1 FROM jsonb_array_elements(COALESCE(p_new_carts, '[]'::jsonb)) c,
+                  jsonb_array_elements(COALESCE(c.value->'items', '[]'::jsonb)) i
+     WHERE coalesce((i.value->>'crates_per_layer')::numeric, 0) <= 0
+        OR coalesce((i.value->>'layers_per_cart')::numeric, 0) <= 0) THEN
+    RAISE EXCEPTION 'Karwissel geweigerd: een karregel mist fusten per laag of lagen (belading_onvolledig). Er is niets gewijzigd.';
+  END IF;
+
+  IF array_length(v_del, 1) IS NOT NULL THEN
+    PERFORM 1 FROM public.order_carts WHERE id = ANY(v_del) ORDER BY id FOR UPDATE;
+    SELECT count(*) INTO v_locked FROM public.order_carts WHERE id = ANY(v_del) AND COALESCE(pickup_locked, false);
+    IF v_locked > 0 THEN
+      RAISE EXCEPTION 'Karwissel geweigerd: % kar(ren) zijn al vastgezet (opgehaald). Er is niets gewijzigd.', v_locked;
+    END IF;
+    UPDATE public.print_jobs
+       SET status = 'geannuleerd'::print_job_status,
+           foutmelding = 'Vervallen: kar verwijderd bij herindeling',
+           updated_at = now()
+     WHERE status IN ('wachtend'::print_job_status, 'bezig'::print_job_status)
+       AND (payload->>'cart_id') = ANY(SELECT id::text FROM unnest(v_del) AS id);
+    GET DIAGNOSTICS v_jobs = ROW_COUNT;
+    DELETE FROM public.pakbon_barcode_inhoud WHERE cart_id = ANY(SELECT id::text FROM unnest(v_del) AS id);
+    DELETE FROM public.order_cart_layer_positions WHERE cart_id = ANY(v_del);
+    DELETE FROM public.order_cart_items WHERE cart_id = ANY(v_del);
+    DELETE FROM public.order_carts WHERE id = ANY(v_del);
+    GET DIAGNOSTICS v_carts = ROW_COUNT;
+  END IF;
+
+  FOR v_cart IN SELECT value FROM jsonb_array_elements(COALESCE(p_new_carts, '[]'::jsonb)) LOOP
+    v_row := v_cart->'row';
+    v_id := gen_random_uuid();
+    INSERT INTO public.order_carts (id, order_id, buffer_id, cart_number, total_carts, is_auto, is_complete, source,
+      occupancy_pct, total_layers_used, carrier_type, carrier_type_id, max_layers, weight_kg, algorithm_version, layout_method)
+    SELECT v_id, r.order_id, r.buffer_id, r.cart_number, r.total_carts, COALESCE(r.is_auto, true), COALESCE(r.is_complete, false),
+           COALESCE(r.source, 'auto'), COALESCE(r.occupancy_pct, 0), COALESCE(r.total_layers_used, 0),
+           r.carrier_type, r.carrier_type_id, r.max_layers, r.weight_kg, COALESCE(r.algorithm_version, 1), r.layout_method
+      FROM jsonb_to_record(v_row) AS r(order_id uuid, buffer_id uuid, cart_number integer, total_carts integer, is_auto boolean,
+           is_complete boolean, source text, occupancy_pct numeric, total_layers_used numeric, carrier_type text, carrier_type_id uuid,
+           max_layers integer, weight_kg numeric, algorithm_version integer, layout_method text);
+
+    INSERT INTO public.order_cart_items (cart_id, order_item_id, product_id, product_name, crates, boxes, weight_kg,
+      plants_per_crate, crates_per_layer, layers_per_cart, layer_fraction, lagen, layer_share_pct, layer_index, crates_in_layer, components)
+    SELECT v_id, i.order_item_id, i.product_id, i.product_name, i.crates, i.boxes, i.weight_kg,
+           i.plants_per_crate, i.crates_per_layer, i.layers_per_cart,
+           least(1, greatest(0, COALESCE(i.layer_fraction, 0))),
+           COALESCE(i.lagen, round(i.crates::numeric / nullif(i.crates_per_layer, 0), 3)),
+           COALESCE(i.layer_share_pct, 0), i.layer_index, i.crates_in_layer,
+           CASE WHEN jsonb_typeof(i.components) = 'array' THEN i.components END
+      FROM jsonb_to_recordset(COALESCE(v_cart->'items', '[]'::jsonb)) AS i(order_item_id uuid, product_id uuid, product_name text,
+           crates integer, boxes integer, weight_kg numeric, plants_per_crate integer, crates_per_layer integer, layers_per_cart integer,
+           layer_fraction numeric, lagen numeric, layer_share_pct numeric, layer_index integer, crates_in_layer integer, components jsonb);
+    v_items := v_items + jsonb_array_length(COALESCE(v_cart->'items', '[]'::jsonb));
+    v_map := v_map || jsonb_build_object('planIndex', (v_cart->>'planIndex')::integer, 'id', v_id);
+  END LOOP;
+
+  RETURN jsonb_build_object('karren', v_map, 'verwijderd', v_carts, 'printopdrachtenGeannuleerd', v_jobs, 'regels', v_items);
+END;
+$function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_rebuffer_aan()
+RETURNS boolean LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_settings jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_rebuffer_aan');
+  SELECT settings INTO v_settings FROM public.logistics_rule_configs
+   WHERE is_active ORDER BY updated_at DESC LIMIT 1;
+  RETURN public.logistics_rule_bool(coalesce(v_settings, '{}'::jsonb), 'order_verwerking', 'rebuffer_on_change', true);
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_rebuffer_aan() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_rebuffer_aan() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_ensure_rebuffer_setting()
+RETURNS integer LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_n integer := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_ensure_rebuffer_setting');
+  UPDATE public.logistics_rule_configs c
+     SET settings = jsonb_set(coalesce(c.settings, '{}'::jsonb), '{order_verwerking}',
+           coalesce(c.settings->'order_verwerking', '{}'::jsonb)
+             || jsonb_build_object('fields', coalesce(c.settings->'order_verwerking'->'fields', '{}'::jsonb)
+                                            || jsonb_build_object('rebuffer_on_change', true)), true)
+   WHERE c.id IS NOT NULL
+     AND NOT coalesce(c.settings->'order_verwerking'->'fields' ? 'rebuffer_on_change', false)
+     AND NOT coalesce(c.settings->'order_verwerking' ? 'rebuffer_on_change', false);
+  GET DIAGNOSTICS v_n = ROW_COUNT;
+  RETURN v_n;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_ensure_rebuffer_setting() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_ensure_rebuffer_setting() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_rebuffer_orders(p_days integer DEFAULT 30)
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_mode text; v_checked int := 0; v_updated int := 0; v_would int := 0; v_vast int := 0;
+  v_start timestamptz := clock_timestamp(); v_ms int; r record; v_after uuid; v_report jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_rebuffer_orders');
+  v_mode := CASE WHEN public.logistics_rebuffer_aan() THEN 'apply' ELSE 'report' END;
+  BEGIN
+    CREATE TEMP TABLE _rb_sim ON COMMIT DROP AS SELECT * FROM public.logistics_rebuffer_simulate_open();
+  EXCEPTION WHEN OTHERS THEN
+    UPDATE public.logistics_rebuffer_state SET pending = false, last_run_at = now(),
+           last_error = left(SQLERRM, 300), updated_at = now() WHERE id;
+    RAISE;
+  END;
+  SELECT count(*), count(*) FILTER (WHERE changed),
+         coalesce(jsonb_agg(jsonb_build_object('orderId', s.id, 'orderNumber', s.order_number, 'deliveryDate', s.delivery_date,
+           'huidig', s.cur_label, 'nieuw', s.new_label, 'wijzigt', s.changed, 'reden', s.reason) ORDER BY s.delivery_date, s.order_number), '[]'::jsonb)
+    INTO v_checked, v_would, v_report FROM _rb_sim s;
+  IF v_mode = 'apply' THEN
+    FOR r IN SELECT s.id, s.buffer_id, s.order_number FROM _rb_sim s WHERE s.changed LOOP
+      IF coalesce(public.logistics_order_released(r.order_number), false)
+         OR EXISTS (SELECT 1 FROM public.pick_queue q
+                     WHERE q.order_number = r.order_number AND q.cancelled_at IS NULL AND q.completed_at IS NULL)
+         OR coalesce(public.logistics_buffer_frozen_order(r.id), false) THEN
+        v_vast := v_vast + 1;
+        CONTINUE;
+      END IF;
+      v_after := public.logistics_apply_buffer_decision(r.id);
+      IF v_after IS DISTINCT FROM r.buffer_id THEN v_updated := v_updated + 1; END IF;
+    END LOOP;
+  END IF;
+  DROP TABLE IF EXISTS _rb_sim;
+  v_ms := greatest(0, (extract(epoch from (clock_timestamp() - v_start)) * 1000)::int);
+  UPDATE public.logistics_rebuffer_state
+     SET pending = false, last_run_at = now(), last_checked = v_checked, last_updated = v_updated,
+         last_would_change = v_would, last_mode = v_mode, last_duration_ms = v_ms,
+         last_error = NULL, last_report = v_report, updated_at = now()
+   WHERE id;
+  RETURN jsonb_build_object('checked', v_checked, 'updated', v_updated, 'durationMs', v_ms,
+                            'mode', v_mode, 'wouldChange', v_would, 'vastgezet', v_vast,
+                            'scope', 'leverdag_vanaf_vandaag_open');
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.trg_logistics_rule_config_rebuffer()
+ RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+BEGIN
+  UPDATE public.logistics_rebuffer_state
+     SET pending = true, requested_at = now(), updated_at = now()
+   WHERE id;
+  BEGIN
+    PERFORM public.logistics_rebuffer_orders(30);
+  EXCEPTION WHEN others THEN
+    UPDATE public.logistics_rebuffer_state
+       SET last_error = left('Opnieuw combineren mislukt: ' || SQLERRM, 300), updated_at = now()
+     WHERE id;
+    RAISE WARNING 'logistics_rebuffer_orders mislukt: %', SQLERRM;
+  END;
+  RETURN NEW;
+END;
+$function$;
+
+CREATE TABLE IF NOT EXISTS public.logistics_correctie_log (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  correctie text NOT NULL,
+  object_id uuid,
+  omschrijving text,
+  oud jsonb,
+  nieuw jsonb,
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+GRANT SELECT ON public.logistics_correctie_log TO authenticated;
+GRANT ALL ON public.logistics_correctie_log TO service_role;
+ALTER TABLE public.logistics_correctie_log ENABLE ROW LEVEL SECURITY;
+DROP POLICY IF EXISTS "Beheer mag correctielog lezen" ON public.logistics_correctie_log;
+CREATE POLICY "Beheer mag correctielog lezen" ON public.logistics_correctie_log
+  FOR SELECT TO authenticated USING (public.logistics_is_beheer());
+
+CREATE OR REPLACE FUNCTION public.logistics_correctie_buffers_geannuleerd(p_uitvoeren boolean DEFAULT false)
+RETURNS TABLE(order_id uuid, order_number text, reden text, buffer_id uuid, actieve_karren integer,
+              andere_open_orders text, uitgevoerd boolean)
+LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+#variable_conflict use_column
+DECLARE r record;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_correctie_buffers_geannuleerd');
+  FOR r IN
+    SELECT o.id, o.order_number, o.buffer_id,
+           CASE WHEN o.deleted_at IS NOT NULL THEN 'verwijderd' ELSE 'geannuleerd' END AS reden,
+           (SELECT count(*)::int FROM public.order_carts c WHERE c.order_id = o.id AND c.archived_at IS NULL) AS karren,
+           (SELECT string_agg(x.order_number, ' ' ORDER BY x.order_number) FROM public.orders x
+             WHERE x.buffer_id = o.buffer_id AND x.id <> o.id AND x.deleted_at IS NULL AND x.cancelled_at IS NULL) AS anderen
+      FROM public.orders o
+     WHERE o.buffer_id IS NOT NULL AND (o.deleted_at IS NOT NULL OR o.cancelled_at IS NOT NULL)
+     ORDER BY o.order_number
+  LOOP
+    order_id := r.id; order_number := r.order_number; reden := r.reden; buffer_id := r.buffer_id;
+    actieve_karren := r.karren; andere_open_orders := r.anderen; uitgevoerd := false;
+    IF p_uitvoeren AND r.karren = 0 THEN
+      PERFORM set_config('logistics.buffer_writer', 'engine', true);
+      UPDATE public.orders SET buffer_id = NULL WHERE id = r.id AND buffer_id = r.buffer_id;
+      INSERT INTO public.logistics_correctie_log (correctie, object_id, omschrijving, oud, nieuw)
+      VALUES ('buffers_geannuleerd', r.id, r.order_number || ' (' || r.reden || ') losgemaakt uit buffer',
+              jsonb_build_object('buffer_id', r.buffer_id), jsonb_build_object('buffer_id', NULL));
+      IF r.anderen IS NOT NULL THEN
+        BEGIN
+          PERFORM public.logistics_plan_enqueue(p_order_id => x.id, p_reason => 'correctie_buffers_geannuleerd')
+             FROM public.orders x WHERE x.buffer_id = r.buffer_id AND x.deleted_at IS NULL AND x.cancelled_at IS NULL;
+        EXCEPTION WHEN undefined_function THEN NULL;
+        END;
+      END IF;
+      uitgevoerd := true;
+    END IF;
+    RETURN NEXT;
+  END LOOP;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_correctie_buffers_geannuleerd(boolean) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_correctie_buffers_geannuleerd(boolean) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_correctie_laagaandeel(p_uitvoeren boolean DEFAULT false)
+RETURNS TABLE(item_id uuid, cart_id uuid, orders text, fusten integer, fusten_per_laag integer,
+              huidig numeric, nieuw_layer_fraction numeric, nieuw_lagen numeric, uitgevoerd boolean)
+LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE r record;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_correctie_laagaandeel');
+  FOR r IN
+    SELECT ci.id, ci.cart_id, ci.crates, ci.crates_per_layer, ci.layer_fraction, ci.lagen,
+           least(1, round(ci.crates::numeric / ci.crates_per_layer, 3)) AS nf,
+           round(ci.crates::numeric / ci.crates_per_layer, 3) AS nl,
+           (SELECT string_agg(DISTINCT o.order_number, ' ') FROM public.order_cart_items x
+              JOIN public.order_items oi ON oi.id = x.order_item_id JOIN public.orders o ON o.id = oi.order_id
+             WHERE x.cart_id = ci.cart_id) AS ords
+      FROM public.order_cart_items ci
+      JOIN public.order_carts c ON c.id = ci.cart_id
+     WHERE c.archived_at IS NULL AND NOT coalesce(c.pickup_locked, false)
+       AND ci.crates_per_layer > 0 AND ci.layer_index IS NULL
+       AND (ci.layer_fraction IS DISTINCT FROM least(1, round(ci.crates::numeric / ci.crates_per_layer, 3))
+            OR ci.lagen IS DISTINCT FROM round(ci.crates::numeric / ci.crates_per_layer, 3))
+       AND NOT EXISTS (SELECT 1 FROM public.print_jobs j WHERE j.status = 'voltooid' AND j.payload->>'cart_id' = c.id::text)
+       AND NOT EXISTS (SELECT 1 FROM public.logistics_control_scan s WHERE s.cart_id = c.id AND s.status <> 'geannuleerd')
+     ORDER BY ci.cart_id, ci.id
+  LOOP
+    item_id := r.id; cart_id := r.cart_id; orders := r.ords; fusten := r.crates; fusten_per_laag := r.crates_per_layer;
+    huidig := r.layer_fraction; nieuw_layer_fraction := r.nf; nieuw_lagen := r.nl; uitgevoerd := false;
+    IF p_uitvoeren THEN
+      UPDATE public.order_cart_items SET layer_fraction = r.nf, lagen = r.nl WHERE id = r.id;
+      INSERT INTO public.logistics_correctie_log (correctie, object_id, omschrijving, oud, nieuw)
+      VALUES ('laagaandeel', r.id, 'karregel van kar ' || r.cart_id,
+              jsonb_build_object('layer_fraction', r.layer_fraction, 'lagen', r.lagen),
+              jsonb_build_object('layer_fraction', r.nf, 'lagen', r.nl));
+      uitgevoerd := true;
+    END IF;
+    RETURN NEXT;
+  END LOOP;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_correctie_laagaandeel(boolean) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_correctie_laagaandeel(boolean) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_pick_voorbeeld_layout(p_queue_ids uuid[])
+RETURNS TABLE(queue_id uuid, documentsoort text, layout_id uuid, layout_naam text, breedte_mm numeric,
+              hoogte_mm numeric, ok boolean, reden text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE r record; v_res jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_pick_voorbeeld_layout');
+  FOR r IN
+    SELECT q.id, t.code, (SELECT o.id FROM public.orders o WHERE o.order_number = q.order_number AND o.deleted_at IS NULL LIMIT 1) AS oid
+      FROM public.pick_queue q LEFT JOIN public.pick_document_types t ON t.id = q.document_type_id
+     WHERE q.id = ANY(coalesce(p_queue_ids, '{}'))
+  LOOP
+    queue_id := r.id; layout_id := NULL; layout_naam := NULL; breedte_mm := NULL; hoogte_mm := NULL;
+    IF r.oid IS NULL OR r.code IS NULL THEN
+      documentsoort := r.code; ok := false;
+      reden := CASE WHEN r.code IS NULL THEN 'Documentsoort van deze regel is onbekend.' ELSE 'Order van deze regel is niet gevonden.' END;
+    ELSE
+      v_res := public.logistics_document_for_order(p_order_id => r.oid, p_documenttype => r.code);
+      documentsoort := coalesce(v_res->>'documenttype', r.code);
+      ok := coalesce((v_res->>'ok')::boolean, false);
+      reden := v_res->>'reden';
+      layout_id := nullif(v_res->>'layout_id', '')::uuid;
+      breedte_mm := nullif(v_res->>'breedte_mm', '')::numeric;
+      hoogte_mm := nullif(v_res->>'hoogte_mm', '')::numeric;
+      IF layout_id IS NOT NULL THEN
+        SELECT l.naam INTO layout_naam FROM public.document_layouts l WHERE l.id = layout_id;
+      END IF;
+    END IF;
+    RETURN NEXT;
+  END LOOP;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_pick_voorbeeld_layout(uuid[]) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_pick_voorbeeld_layout(uuid[]) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_aanmeldmoment(p_order_ids uuid[])
+RETURNS TABLE(order_id uuid, aanmeld_at timestamptz, bron text, tekst text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_tz text; r record; v_fout text;
+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
+        order_id := r.order_id; aanmeld_at := r.aanmeld_at; bron := r.bron;
+        tekst := CASE WHEN r.aanmeld_at IS NOT NULL AND v_tz IS NOT NULL AND r.bron IN ('verstuurd', 'gepland')
+                      THEN 'Verzendbrief komt vrij na de transportaanmelding om ' || to_char(r.aanmeld_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 $$;
+REVOKE ALL ON FUNCTION public.logistics_aanmeldmoment(uuid[]) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_aanmeldmoment(uuid[]) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_check_190()
+ RETURNS TABLE(onderdeel text, ok boolean, toelichting text)
+ LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+  SELECT 'functie:' || f, to_regprocedure(f) IS NOT NULL,
+         CASE WHEN to_regprocedure(f) IS NOT NULL THEN 'aanwezig' ELSE 'ontbreekt (schemasync controleren)' END
+    FROM unnest(ARRAY[
+      'public.logistics_sticker_maten_per_dag(date,date)',
+      'public.logistics_belading_wacht(uuid)',
+      'public.logistics_overload_check()',
+      'public.logistics_cart_sticker_state(uuid)',
+      'public.logistics_belading_waarschuwingen_zet(uuid[],jsonb)',
+      'public.logistics_rebuffer_aan()',
+      'public.logistics_ensure_rebuffer_setting()',
+      'public.logistics_correctie_buffers_geannuleerd(boolean)',
+      'public.logistics_correctie_laagaandeel(boolean)',
+      'public.logistics_pick_voorbeeld_layout(uuid[])',
+      'public.logistics_aanmeldmoment(uuid[])']) f
+  UNION ALL
+  SELECT 'kolom:order_cart_items.lagen',
+         EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema = 'public' AND table_name = 'order_cart_items' AND column_name = 'lagen'),
+         'nieuw veld lagen'
+  UNION ALL
+  SELECT 'tabel:' || t, to_regclass('public.' || t) IS NOT NULL, 'nieuw in 1.0.190'
+    FROM unnest(ARRAY['logistics_belading_waarschuwingen', 'logistics_correctie_log']) t
+  UNION ALL
+  SELECT 'afhandeling:afh_signup_moment_for_orders(uuid[])',
+         to_regprocedure('public.afh_signup_moment_for_orders(uuid[])') IS NOT NULL,
+         'optioneel: ontbreekt = tekst "nog niet bekend", niets geblokkeerd';
+$function$;CREATE OR REPLACE FUNCTION public.logistics_shipping_note_status(p_slip_job_id uuid DEFAULT NULL::uuid, p_cart_id uuid DEFAULT NULL::uuid)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_note public.logistics_slip_shipping_note;
+  v_slip public.print_jobs;
+  v_job public.print_jobs;
+  v_state text; v_message text; v_cart uuid;
+  v_vrijgave boolean := false; v_scan_ok boolean;
+  v_aanmeld_at timestamptz; v_aanmeld_tekst text; v_order uuid;
+BEGIN
+  IF p_slip_job_id IS NULL AND p_cart_id IS NULL THEN
+    RETURN jsonb_build_object('status','mislukt','message',
+      'De pakbon of kar ontbreekt; de verzendbriefstatus kan niet worden opgehaald.','attempts',0,'nextAttemptAt',NULL);
+  END IF;
+  IF p_slip_job_id IS NOT NULL THEN
+    SELECT * INTO v_slip FROM public.print_jobs WHERE id = p_slip_job_id;
+  ELSE
+    SELECT * INTO v_slip FROM public.print_jobs p
+     WHERE lower(coalesce(p.payload->>'document_type_code', p.payload->>'documentType', p.documenttype::text, '')) LIKE '%pakbon%'
+       AND nullif(coalesce(p.payload->>'cart_id', p.payload->'cart'->>'cartId'), '') = p_cart_id::text
+     ORDER BY p.created_at DESC LIMIT 1;
+  END IF;
+  IF v_slip.id IS NULL THEN
+    RETURN jsonb_build_object('status','mislukt','message','De bijbehorende pakbon is niet gevonden.',
+      'attempts',0,'nextAttemptAt',NULL,'cartId',p_cart_id);
+  END IF;
+  BEGIN
+    v_cart := coalesce(nullif(v_slip.payload->>'cart_id','')::uuid, nullif(v_slip.payload->'cart'->>'cartId','')::uuid, p_cart_id);
+  EXCEPTION WHEN invalid_text_representation THEN v_cart := p_cart_id;
+  END;
+  SELECT * INTO v_note FROM public.logistics_slip_shipping_note s
+   WHERE s.slip_job_id = v_slip.id ORDER BY s.created_at DESC LIMIT 1;
+
+  IF v_note.id IS NULL THEN
+    SELECT * INTO v_job FROM public.print_jobs p
+     WHERE p.idempotentie_sleutel = 'verzendbrief-bij-pakbon:' || v_slip.id::text
+        OR (p.payload->>'packing_slip_job_id' = v_slip.id::text
+            AND lower(coalesce(p.payload->>'document_type_code', p.documenttype::text, '')) ~ '(verzend|aflever)')
+     ORDER BY p.created_at DESC LIMIT 1;
+    IF v_job.id IS NULL THEN
+      IF v_slip.created_at < now() - interval '15 minutes' THEN
+        v_state := 'mislukt';
+        v_message := 'Er is geen verzendbrief bij deze pakbon aangemaakt. Controleer de printwachtrij of print de pakbon opnieuw.';
+      ELSE
+        v_state := 'klaar_voor_print'; v_message := 'Verzendbrief wordt klaargezet.';
+      END IF;
+    ELSIF v_job.status = 'voltooid' THEN
+      v_state := 'geprint'; v_message := 'Pakbon en verzendbrief zijn naar de printer gestuurd.';
+    ELSIF v_job.status IN ('wachtend','bezig') THEN
+      v_state := 'klaar_voor_print'; v_message := 'Verzendbrief wordt klaargezet.';
+    ELSE
+      v_state := 'mislukt'; v_message := 'De verzendbrief kon niet worden geprint. Controleer de printwachtrij.';
+    END IF;
+    RETURN jsonb_build_object('status',v_state,'message',v_message,
+      'attempts',coalesce(v_job.pogingen,0),'nextAttemptAt',v_job.volgende_poging,
+      'slipJobId',v_slip.id,'shippingNoteJobId',v_job.id,'cartId',v_cart,
+      'orderNumber',coalesce(v_slip.payload->>'order_number', v_slip.payload->'data'->>'orderNumber'));
+  END IF;
+
+  IF v_note.print_job_id IS NOT NULL THEN
+    SELECT * INTO v_job FROM public.print_jobs WHERE id = v_note.print_job_id;
+  END IF;
+  v_scan_ok := EXISTS (SELECT 1 FROM public.logistics_control_scan cs
+                        WHERE cs.cart_id = coalesce(v_note.cart_id, v_cart) AND cs.approved_at IS NOT NULL);
+
+  IF NOT v_scan_ok OR v_note.status IN ('wacht_op_vrijgave','wachtend') THEN
+    BEGIN
+      v_order := v_note.order_id;
+      IF v_order IS NOT NULL THEN
+        SELECT a.aanmeld_at, a.tekst INTO v_aanmeld_at, v_aanmeld_tekst
+          FROM public.logistics_aanmeldmoment(p_order_ids => ARRAY[v_order]) a LIMIT 1;
+      END IF;
+    EXCEPTION WHEN others THEN v_aanmeld_at := NULL; v_aanmeld_tekst := NULL;
+    END;
+  END IF;
+
+  IF v_note.status = 'mislukt' THEN
+    v_state := 'mislukt'; v_message := 'De officiële Floriday-afleverbrief kon niet worden klaargezet. Controleer de verzendbriefwachtrij.';
+  ELSIF v_note.status = 'wacht_op_vrijgave'
+     OR (v_note.status = 'wachtend' AND v_note.retry_class IN ('wacht_op_vrijgave','wacht_op_kenmerk'))
+     OR (v_note.status = 'wachtend' AND v_note.retry_class IS NULL AND coalesce(v_note.attempts,0) = 0 AND NOT v_scan_ok) THEN
+    v_state := 'wacht_op_floriday'; v_vrijgave := true;
+    v_message := CASE WHEN v_scan_ok
+      THEN 'Pakbon geprint — ' || coalesce(v_aanmeld_tekst, 'Tijdstip van de transportaanmelding is nog niet bekend') || '.'
+      ELSE 'Pakbon geprint — verzendbrief wacht: ' || coalesce(nullif(btrim(v_note.error), ''), 'op een goedgekeurde controlescan.') END;
+  ELSIF v_note.status = 'wachtend' AND v_note.retry_class = 'nog_niet_beschikbaar' THEN
+    v_state := 'wacht_op_floriday'; v_message := 'Pakbon geprint — wachten op officiële Floriday-afleverbrief.';
+  ELSIF v_note.status = 'wachtend' AND v_note.retry_class = 'tijdelijk' AND coalesce(v_note.attempts,0) > 0
+        AND coalesce(v_note.error,'') ~* '(5\d\d|429|time-?out|netwerk|verbinding|niet bereikbaar)' THEN
+    v_state := 'klaar_voor_print'; v_message := 'Floriday is tijdelijk niet bereikbaar. De verzendbrief wordt automatisch opnieuw geprobeerd.';
+  ELSIF v_note.status = 'wachtend' AND v_note.retry_class = 'limiet_bereikt' THEN
+    v_state := 'mislukt'; v_message := 'Het maximale aantal pogingen voor de verzendbrief is bereikt. Controleer de verzendbriefwachtrij.';
+  ELSIF v_note.status = 'wachtend' THEN
+    v_state := 'klaar_voor_print'; v_message := 'Verzendbrief wordt klaargezet.';
+  ELSIF v_job.status = 'voltooid' THEN
+    v_state := 'geprint'; v_message := 'Pakbon en verzendbrief zijn naar de printer gestuurd.';
+  ELSIF v_job.status IN ('mislukt','geannuleerd') THEN
+    v_state := 'mislukt'; v_message := 'De verzendbrief kon niet worden geprint. Controleer de printwachtrij.';
+  ELSE
+    v_state := 'klaar_voor_print'; v_message := 'De officiële Floriday-afleverbrief wordt naar dezelfde printer gestuurd.';
+  END IF;
+
+  RETURN jsonb_build_object('status',v_state,'message',v_message,
+    'attempts',coalesce(v_note.attempts,0),'nextAttemptAt',v_note.next_attempt_at,
+    'slipJobId',v_slip.id,'shippingNoteJobId',v_note.print_job_id,
+    'cartId',coalesce(v_note.cart_id, v_cart),'orderNumber',v_note.order_number,
+    'wachtOpVrijgave', v_vrijgave,
+    'wachtReden', CASE WHEN v_vrijgave THEN CASE WHEN v_scan_ok THEN v_message ELSE coalesce(nullif(btrim(v_note.error), ''), v_message) END END,
+    'wachtCode', CASE WHEN v_vrijgave THEN coalesce(v_note.retry_class, v_note.status) END,
+    'verwachtOm', CASE WHEN v_vrijgave THEN v_aanmeld_at END,
+    'aanmeldTekst', CASE WHEN v_vrijgave AND v_scan_ok THEN coalesce(v_aanmeld_tekst, 'Tijdstip van de transportaanmelding is nog niet bekend') END);
+END;
+$function$;
+-- ===== 1.0.190 deel 4 =====
+-- Logistiek Engine 1.0.190 deel 4: rebuffer zonder 'volle kar = vast', bewaking open orders zonder kar, stickermaten-datum. Herhaalbaar; geen datacorrecties.
+CREATE OR REPLACE FUNCTION public.logistics_rebuffer_vastgezet(p_order_id uuid)
+RETURNS boolean LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+  SELECT public.logistics_acc_guard('server', 'logistics_rebuffer_vastgezet');
+  SELECT EXISTS (SELECT 1 FROM public.orders o WHERE o.id = p_order_id AND o.plan_locked_at IS NOT NULL)
+    OR EXISTS (SELECT 1 FROM public.orders o WHERE o.id = p_order_id
+                 AND coalesce(public.logistics_order_released(o.order_number), false))
+    OR EXISTS (SELECT 1 FROM public.orders o JOIN public.pick_queue q ON q.order_number = o.order_number
+                WHERE o.id = p_order_id AND q.cancelled_at IS NULL AND q.completed_at IS NULL)
+    OR EXISTS (
+      SELECT 1 FROM public.orders o
+        JOIN logistics_active.order_carts oc
+          ON oc.buffer_id = o.buffer_id AND (oc.order_id = o.id OR oc.order_id IS NULL)
+       WHERE o.id = p_order_id
+         AND (oc.pickup_locked IS TRUE
+              OR public.logistics_cart_handled(COALESCE(o.order_number, o.id::text), oc.cart_number)
+              OR public.logistics_cart_is_frozen(oc.id)));
+$$;
+REVOKE ALL ON FUNCTION public.logistics_rebuffer_vastgezet(uuid) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_rebuffer_vastgezet(uuid) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_rebuffer_orders(p_days integer DEFAULT 30)
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_mode text; v_checked int := 0; v_updated int := 0; v_would int := 0; v_vast int := 0;
+  v_start timestamptz := clock_timestamp(); v_ms int; r record; v_after uuid; v_report jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_rebuffer_orders');
+  v_mode := CASE WHEN public.logistics_rebuffer_aan() THEN 'apply' ELSE 'report' END;
+  BEGIN
+    CREATE TEMP TABLE _rb_sim ON COMMIT DROP AS SELECT * FROM public.logistics_rebuffer_simulate_open();
+  EXCEPTION WHEN OTHERS THEN
+    UPDATE public.logistics_rebuffer_state SET pending = false, last_run_at = now(),
+           last_error = left(SQLERRM, 300), updated_at = now() WHERE id;
+    RAISE;
+  END;
+  SELECT count(*), count(*) FILTER (WHERE changed),
+         coalesce(jsonb_agg(jsonb_build_object('orderId', s.id, 'orderNumber', s.order_number, 'deliveryDate', s.delivery_date,
+           'huidig', s.cur_label, 'nieuw', s.new_label, 'wijzigt', s.changed, 'reden', s.reason) ORDER BY s.delivery_date, s.order_number), '[]'::jsonb)
+    INTO v_checked, v_would, v_report FROM _rb_sim s;
+  IF v_mode = 'apply' THEN
+    FOR r IN SELECT s.id, s.buffer_id, s.order_number FROM _rb_sim s WHERE s.changed LOOP
+      IF public.logistics_rebuffer_vastgezet(r.id) THEN
+        v_vast := v_vast + 1;
+        CONTINUE;
+      END IF;
+      v_after := public.logistics_apply_buffer_decision(r.id);
+      IF v_after IS DISTINCT FROM r.buffer_id THEN v_updated := v_updated + 1; END IF;
+    END LOOP;
+  END IF;
+  DROP TABLE IF EXISTS _rb_sim;
+  v_ms := greatest(0, (extract(epoch from (clock_timestamp() - v_start)) * 1000)::int);
+  UPDATE public.logistics_rebuffer_state
+     SET pending = false, last_run_at = now(), last_checked = v_checked, last_updated = v_updated,
+         last_would_change = v_would, last_mode = v_mode, last_duration_ms = v_ms,
+         last_error = CASE WHEN v_vast > 0 THEN v_vast || ' order(s) niet verplaatst: vrijgegeven, in de pickrij of geprinte/gescande kar.' END,
+         last_report = v_report, updated_at = now()
+   WHERE id;
+  RETURN jsonb_build_object('checked', v_checked, 'updated', v_updated, 'durationMs', v_ms,
+                            'mode', v_mode, 'wouldChange', v_would, 'vastgezet', v_vast,
+                            'scope', 'leverdag_vanaf_vandaag_open');
+END $function$;CREATE TABLE IF NOT EXISTS public.logistics_zonder_kar_pogingen (
+  order_id uuid PRIMARY KEY,
+  order_number text,
+  pogingen integer NOT NULL DEFAULT 0,
+  laatste_poging_at timestamptz,
+  gemeld_at timestamptz,
+  opgelost_at timestamptz,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+GRANT SELECT ON public.logistics_zonder_kar_pogingen TO authenticated;
+GRANT ALL ON public.logistics_zonder_kar_pogingen TO service_role;
+ALTER TABLE public.logistics_zonder_kar_pogingen ENABLE ROW LEVEL SECURITY;
+DROP POLICY IF EXISTS "Ingelogd mag zonder-kar-pogingen lezen" ON public.logistics_zonder_kar_pogingen;
+CREATE POLICY "Ingelogd mag zonder-kar-pogingen lezen" ON public.logistics_zonder_kar_pogingen
+  FOR SELECT TO authenticated USING (true);
+
+CREATE OR REPLACE FUNCTION public.logistics_open_orders_zonder_kar()
+RETURNS TABLE(order_id uuid, order_number text, delivery_date text, laatste_reden text)
+LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+  SELECT public.logistics_acc_guard('ingelogd', 'logistics_open_orders_zonder_kar');
+  WITH lq AS (
+    SELECT DISTINCT ON (q.order_id) q.order_id, q.status, q.reason_code, q.error
+      FROM public.logistics_plan_queue q ORDER BY q.order_id, q.updated_at DESC
+  )
+  SELECT o.id, o.order_number, o.delivery_date, lq.error
+    FROM public.orders o
+    LEFT JOIN lq ON lq.order_id = o.id
+   WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL
+     AND lower(coalesce(o.status,'')) NOT IN ('cancelled','geannuleerd','deleted','verwijderd','afgehandeld','completed','delivered','geleverd')
+     AND o.delivery_date ~ '^\d{4}-\d{2}-\d{2}' AND left(o.delivery_date,10)::date >= public.logistics_local_today()
+     AND EXISTS (SELECT 1 FROM public.order_items oi WHERE oi.order_id = o.id)
+     AND NOT coalesce(public.logistics_order_buffer_excluded(o.id), false)
+     AND NOT (coalesce(lq.status,'') IN ('geblokkeerd','pending','running'))
+     AND NOT (coalesce(lq.reason_code,'') IN ('belading_onwaarschijnlijk','belading_onvolledig','belading_onbekend','artikel_kiezen','ladingdrager_onbekend'))
+     AND NOT EXISTS (SELECT 1 FROM logistics_active.order_carts c WHERE c.order_id = o.id)
+     AND NOT EXISTS (SELECT 1 FROM public.order_items oi
+                       JOIN logistics_active.order_cart_items ci ON ci.order_item_id = oi.id
+                       JOIN logistics_active.order_carts c ON c.id = ci.cart_id
+                      WHERE oi.order_id = o.id);
+$$;
+REVOKE ALL ON FUNCTION public.logistics_open_orders_zonder_kar() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_open_orders_zonder_kar() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_bewaak_zonder_kar()
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE r record; v_nieuw int := 0; v_gemeld int := 0; v_p int;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_bewaak_zonder_kar');
+  -- Opgelost: weer een kar of niet meer in de lijst.
+  UPDATE public.logistics_zonder_kar_pogingen p SET opgelost_at = now(), updated_at = now()
+   WHERE p.opgelost_at IS NULL
+     AND NOT EXISTS (SELECT 1 FROM public.logistics_open_orders_zonder_kar() z WHERE z.order_id = p.order_id);
+  FOR r IN SELECT * FROM public.logistics_open_orders_zonder_kar() LOOP
+    INSERT INTO public.logistics_zonder_kar_pogingen(order_id, order_number) VALUES (r.order_id, r.order_number)
+    ON CONFLICT (order_id) DO UPDATE SET opgelost_at = NULL,
+      pogingen = CASE WHEN logistics_zonder_kar_pogingen.opgelost_at IS NOT NULL THEN 0 ELSE logistics_zonder_kar_pogingen.pogingen END,
+      gemeld_at = CASE WHEN logistics_zonder_kar_pogingen.opgelost_at IS NOT NULL THEN NULL ELSE logistics_zonder_kar_pogingen.gemeld_at END
+    RETURNING pogingen INTO v_p;
+    IF v_p < 3 THEN
+      -- Niet vaker dan eens per 10 minuten.
+      IF EXISTS (SELECT 1 FROM public.logistics_zonder_kar_pogingen p WHERE p.order_id = r.order_id
+                  AND (p.laatste_poging_at IS NULL OR p.laatste_poging_at < now() - interval '10 minutes')) THEN
+        PERFORM public.logistics_plan_enqueue(p_order_id => r.order_id, p_reason => 'bewaking: open order zonder kar');
+        UPDATE public.logistics_zonder_kar_pogingen SET pogingen = pogingen + 1, laatste_poging_at = now(), updated_at = now()
+         WHERE order_id = r.order_id;
+        v_nieuw := v_nieuw + 1;
+      END IF;
+    ELSE
+      UPDATE public.logistics_zonder_kar_pogingen SET gemeld_at = coalesce(gemeld_at, now()), updated_at = now()
+       WHERE order_id = r.order_id;
+      v_gemeld := v_gemeld + 1;
+    END IF;
+  END LOOP;
+  RETURN jsonb_build_object('opnieuwIngepland', v_nieuw, 'gemeld', v_gemeld);
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_bewaak_zonder_kar() FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_bewaak_zonder_kar() TO service_role;CREATE OR REPLACE FUNCTION public.logistics_open_orders_zonder_kar()
+RETURNS TABLE(order_id uuid, order_number text, delivery_date text, laatste_reden text)
+LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+  SELECT public.logistics_acc_guard('ingelogd', 'logistics_open_orders_zonder_kar');
+  WITH lq AS (
+    SELECT DISTINCT ON (q.order_id) q.order_id, q.status, q.reason_code, q.error
+      FROM public.logistics_plan_queue q ORDER BY q.order_id, q.updated_at DESC
+  )
+  SELECT o.id, o.order_number, o.delivery_date, lq.error
+    FROM public.orders o
+    LEFT JOIN lq ON lq.order_id = o.id
+   WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL
+     AND lower(coalesce(o.status,'')) NOT IN ('cancelled','geannuleerd','deleted','verwijderd','afgehandeld','completed','delivered','geleverd')
+     AND o.delivery_date ~ '^\d{4}-\d{2}-\d{2}' AND left(o.delivery_date,10)::date >= public.logistics_local_today()
+     AND EXISTS (SELECT 1 FROM public.order_items oi WHERE oi.order_id = o.id)
+     AND NOT coalesce(public.logistics_order_buffer_excluded(o.id), false)
+     AND NOT (coalesce(lq.status,'') IN ('geblokkeerd','pending','running'))
+     AND NOT (coalesce(lq.status,'') = 'gearchiveerd'
+              AND coalesce(lq.reason_code,'') IN ('belading_onwaarschijnlijk','belading_onvolledig','belading_onbekend','artikel_kiezen','ladingdrager_onbekend'))
+     AND NOT EXISTS (SELECT 1 FROM logistics_active.order_carts c WHERE c.order_id = o.id)
+     AND NOT EXISTS (SELECT 1 FROM public.order_items oi
+                       JOIN logistics_active.order_cart_items ci ON ci.order_item_id = oi.id
+                       JOIN logistics_active.order_carts c ON c.id = ci.cart_id
+                      WHERE oi.order_id = o.id);
+$$;CREATE OR REPLACE FUNCTION public.logistics_sticker_maten_per_dag(p_van date, p_tot date)
+ RETURNS TABLE(dag date, print_plek_id text, breedte_mm numeric, hoogte_mm numeric, aantal integer)
+ LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_sticker_maten_per_dag');
+  IF p_van IS NULL OR p_tot IS NULL OR p_tot < p_van THEN
+    RAISE EXCEPTION 'Geef een geldige periode op (van t/m tot).' USING ERRCODE = '22023';
+  END IF;
+  RETURN QUERY
+  WITH b AS (
+    SELECT coalesce(c.departure_at::date,
+                    CASE WHEN o.delivery_date ~ '^\d{4}-\d{2}-\d{2}' THEN left(o.delivery_date, 10)::date END) AS d,
+           s.print_plek_id, s.breedte_mm, s.hoogte_mm, s.kopieen
+      FROM public.logistics_sticker_prints s
+      LEFT JOIN public.order_carts c ON c.id = s.cart_id
+      LEFT JOIN public.orders o ON o.id = s.order_id
+     WHERE s.status NOT IN ('niet_printen', 'afgemeld'))
+  SELECT b.d, b.print_plek_id, b.breedte_mm, b.hoogte_mm, sum(greatest(coalesce(b.kopieen, 1), 1))::integer
+    FROM b WHERE b.d BETWEEN p_van AND p_tot
+   GROUP BY 1, 2, 3, 4 ORDER BY 1, 2, 3, 4;
+END $function$;
+-- ===== 1.0.192: inplannen in porties (db/migrations/20261023190000) =====
+-- Logistiek Engine 1.0.192: taken opnieuw inplannen in porties met vingerafdruk per order.
+-- Herhaalbaar. Geen datacorrecties, geen deletes. Bestaande functies (o.a. logistics_schedule_tasks)
+-- blijven ongewijzigd, zodat gepubliceerde 1.0.190 blijft werken.
+
+CREATE TABLE IF NOT EXISTS public.logistics_schedule_fp (
+  order_ref text PRIMARY KEY,
+  fp text NOT NULL,
+  ingepland_at timestamptz NOT NULL DEFAULT now()
+);
+GRANT SELECT ON public.logistics_schedule_fp TO authenticated;
+GRANT ALL ON public.logistics_schedule_fp TO service_role;
+ALTER TABLE public.logistics_schedule_fp ENABLE ROW LEVEL SECURITY;
+DROP POLICY IF EXISTS "Ingelogd mag inplan-vingerafdruk lezen" ON public.logistics_schedule_fp;
+CREATE POLICY "Ingelogd mag inplan-vingerafdruk lezen" ON public.logistics_schedule_fp
+  FOR SELECT TO authenticated USING (true);
+
+CREATE TABLE IF NOT EXISTS public.logistics_schedule_werklijst (
+  run_id uuid NOT NULL,
+  order_ref text NOT NULL,
+  verwerkt_at timestamptz,
+  uitkomst text,
+  PRIMARY KEY (run_id, order_ref)
+);
+GRANT SELECT ON public.logistics_schedule_werklijst TO authenticated;
+GRANT ALL ON public.logistics_schedule_werklijst TO service_role;
+ALTER TABLE public.logistics_schedule_werklijst ENABLE ROW LEVEL SECURITY;
+DROP POLICY IF EXISTS "Ingelogd mag inplan-werklijst lezen" ON public.logistics_schedule_werklijst;
+CREATE POLICY "Ingelogd mag inplan-werklijst lezen" ON public.logistics_schedule_werklijst
+  FOR SELECT TO authenticated USING (true);
+
+CREATE TABLE IF NOT EXISTS public.logistics_schedule_voortgang (
+  id boolean PRIMARY KEY DEFAULT true CHECK (id),
+  run_id uuid,
+  gestart_at timestamptz,
+  bijgewerkt_at timestamptz,
+  totaal integer NOT NULL DEFAULT 0,
+  verwerkt integer NOT NULL DEFAULT 0,
+  ingepland integer NOT NULL DEFAULT 0,
+  overgeslagen integer NOT NULL DEFAULT 0,
+  fouten integer NOT NULL DEFAULT 0,
+  laatste_fout text,
+  klaar boolean NOT NULL DEFAULT true,
+  duur_ms integer
+);
+GRANT SELECT ON public.logistics_schedule_voortgang TO authenticated;
+GRANT ALL ON public.logistics_schedule_voortgang TO service_role;
+ALTER TABLE public.logistics_schedule_voortgang ENABLE ROW LEVEL SECURITY;
+DROP POLICY IF EXISTS "Ingelogd mag inplan-voortgang lezen" ON public.logistics_schedule_voortgang;
+CREATE POLICY "Ingelogd mag inplan-voortgang lezen" ON public.logistics_schedule_voortgang
+  FOR SELECT TO authenticated USING (true);
+
+CREATE TABLE IF NOT EXISTS public.logistics_index_log (
+  index_naam text PRIMARY KEY,
+  tabel text NOT NULL,
+  rijen bigint,
+  duur_ms integer,
+  aangemaakt_at timestamptz NOT NULL DEFAULT now()
+);
+GRANT SELECT ON public.logistics_index_log TO authenticated;
+GRANT ALL ON public.logistics_index_log TO service_role;
+ALTER TABLE public.logistics_index_log ENABLE ROW LEVEL SECURITY;
+DROP POLICY IF EXISTS "Ingelogd mag indexlog lezen" ON public.logistics_index_log;
+CREATE POLICY "Ingelogd mag indexlog lezen" ON public.logistics_index_log
+  FOR SELECT TO authenticated USING (true);
+
+-- Index voor "open taken per order", met gemeten duur (schrijfblokkade op logistics_tasks zolang hij loopt).
+DO $idx$
+DECLARE t0 timestamptz; n bigint;
+BEGIN
+  IF to_regclass('public.idx_logistics_tasks_open_order') IS NULL THEN
+    SELECT count(*) INTO n FROM public.logistics_tasks;
+    t0 := clock_timestamp();
+    CREATE INDEX idx_logistics_tasks_open_order ON public.logistics_tasks (order_ref)
+      WHERE status IN ('planned', 'ready') AND order_ref IS NOT NULL;
+    INSERT INTO public.logistics_index_log (index_naam, tabel, rijen, duur_ms)
+    VALUES ('idx_logistics_tasks_open_order', 'logistics_tasks', n,
+            (extract(epoch FROM clock_timestamp() - t0) * 1000)::int)
+    ON CONFLICT (index_naam) DO NOTHING;
+  END IF;
+END $idx$;
+
+-- Algemene invoer van het inplannen: werkwijze, werktijden, afwijkende dagen, capaciteit,
+-- ladingdragers, ophaalmomenten (vervoerders) en het lopende uur (taken mogen niet in het verleden starten).
+CREATE OR REPLACE FUNCTION public.logistics_schedule_global_fp()
+RETURNS text LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE
+  v_tab text; v_h text; v_all text := '';
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_schedule_global_fp');
+  FOREACH v_tab IN ARRAY ARRAY['logistics_time_settings','logistics_opening_hours','logistics_opening_exceptions',
+    'logistics_rule_configs','cart_planning_settings','cart_planning_pick_times','cart_types','carriers'] LOOP
+    IF to_regclass('public.' || v_tab) IS NOT NULL THEN
+      EXECUTE format('SELECT md5(coalesce(string_agg(x, ''|'' ORDER BY x), '''')) FROM (SELECT to_jsonb(t)::text AS x FROM public.%I t) s', v_tab)
+        INTO v_h;
+      v_all := v_all || v_tab || ':' || coalesce(v_h, '') || ';';
+    END IF;
+  END LOOP;
+  v_all := v_all || 'uur:' || to_char(now() AT TIME ZONE coalesce(public.logistics_tz(), 'UTC'), 'YYYY-MM-DD HH24');
+  RETURN md5(v_all);
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_schedule_global_fp() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_schedule_global_fp() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_schedule_order_fp(p_order_ref text, p_global text)
+RETURNS text LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_o text; v_t text; v_c text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_schedule_order_fp');
+  SELECT (to_jsonb(o) - 'updated_at')::text, array_to_string(public.logistics_order_cart_ids(o.id), ',')
+    INTO v_o, v_c FROM public.orders o WHERE o.order_number = p_order_ref;
+  SELECT string_agg(t.id::text || t.task_type || t.status, ',' ORDER BY t.id) INTO v_t
+    FROM public.logistics_tasks t WHERE t.order_ref = p_order_ref AND t.status IN ('planned', 'ready');
+  RETURN md5(coalesce(p_global, '') || '#' || coalesce(v_o, '') || '#' || coalesce(v_t, '') || '#' || coalesce(v_c, ''));
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_schedule_order_fp(text, text) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_schedule_order_fp(text, text) TO authenticated, service_role;
+
+-- Portie-inplanner. Opties (jsonb): start (bool), run_id (uuid), max_orders (int, 25), budget_ms (int, 20000), force (bool).
+-- Per order een eigen subtransactie: lukt het niet, dan blijft de oude planning staan.
+CREATE OR REPLACE FUNCTION public.logistics_schedule_tasks_batch(p_opties jsonb)
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE
+  v_start timestamptz := clock_timestamp();
+  v_run uuid := nullif(p_opties->>'run_id', '')::uuid;
+  v_max int := greatest(1, least(coalesce((p_opties->>'max_orders')::int, 25), 500));
+  v_budget int := greatest(1000, least(coalesce((p_opties->>'budget_ms')::int, 20000), 120000));
+  v_force boolean := coalesce((p_opties->>'force')::boolean, false);
+  v_since timestamptz; v_160 timestamptz;
+  v_global text; v_fp text; v_old text; r record;
+  v_done int := 0; v_plan int := 0; v_skip int := 0; v_err int := 0; v_fouten jsonb := '[]'::jsonb;
+  v_totaal int; v_rest int;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_schedule_tasks_batch');
+  IF v_run IS NULL OR coalesce((p_opties->>'start')::boolean, false) THEN
+    v_run := gen_random_uuid();
+    SELECT departure_rule_since, rule_160_since INTO v_since, v_160
+      FROM public.logistics_time_settings ORDER BY updated_at DESC NULLS LAST LIMIT 1;
+    INSERT INTO public.logistics_schedule_werklijst (run_id, order_ref)
+    SELECT v_run, o.order_number FROM public.orders o
+     WHERE o.deleted_at IS NULL AND o.order_number IS NOT NULL
+       AND EXISTS (SELECT 1 FROM public.logistics_tasks t WHERE t.order_ref = o.order_number AND t.status IN ('planned','ready'))
+       AND NOT (v_since IS NOT NULL AND v_160 IS NOT NULL AND o.created_at >= v_since AND o.created_at < v_160)
+    ON CONFLICT DO NOTHING;
+    GET DIAGNOSTICS v_totaal = ROW_COUNT;
+    INSERT INTO public.logistics_schedule_voortgang (id, run_id, gestart_at, bijgewerkt_at, totaal, verwerkt, ingepland, overgeslagen, fouten, laatste_fout, klaar, duur_ms)
+    VALUES (true, v_run, now(), now(), v_totaal, 0, 0, 0, 0, NULL, v_totaal = 0, NULL)
+    ON CONFLICT (id) DO UPDATE SET run_id = EXCLUDED.run_id, gestart_at = EXCLUDED.gestart_at, bijgewerkt_at = EXCLUDED.bijgewerkt_at,
+      totaal = EXCLUDED.totaal, verwerkt = 0, ingepland = 0, overgeslagen = 0, fouten = 0, laatste_fout = NULL,
+      klaar = EXCLUDED.klaar, duur_ms = NULL;
+  END IF;
+
+  v_global := public.logistics_schedule_global_fp();
+  FOR r IN SELECT w.order_ref FROM public.logistics_schedule_werklijst w
+            WHERE w.run_id = v_run AND w.verwerkt_at IS NULL ORDER BY w.order_ref LIMIT v_max LOOP
+    EXIT WHEN (extract(epoch FROM clock_timestamp() - v_start) * 1000) > v_budget;
+    v_fp := public.logistics_schedule_order_fp(r.order_ref, v_global);
+    SELECT f.fp INTO v_old FROM public.logistics_schedule_fp f WHERE f.order_ref = r.order_ref;
+    IF NOT v_force AND v_old IS NOT DISTINCT FROM v_fp THEN
+      v_skip := v_skip + 1;
+      UPDATE public.logistics_schedule_werklijst SET verwerkt_at = now(), uitkomst = 'ongewijzigd'
+       WHERE run_id = v_run AND order_ref = r.order_ref;
+    ELSE
+      BEGIN
+        PERFORM public.logistics_schedule_tasks(p_order_ref => r.order_ref);
+        INSERT INTO public.logistics_schedule_fp (order_ref, fp, ingepland_at) VALUES (r.order_ref, v_fp, now())
+        ON CONFLICT (order_ref) DO UPDATE SET fp = EXCLUDED.fp, ingepland_at = EXCLUDED.ingepland_at;
+        v_plan := v_plan + 1;
+        UPDATE public.logistics_schedule_werklijst SET verwerkt_at = now(), uitkomst = 'ingepland'
+         WHERE run_id = v_run AND order_ref = r.order_ref;
+      EXCEPTION WHEN OTHERS THEN
+        v_err := v_err + 1;
+        v_fouten := v_fouten || jsonb_build_object('order', r.order_ref, 'fout', left(SQLERRM, 300));
+        UPDATE public.logistics_schedule_werklijst SET verwerkt_at = now(), uitkomst = 'fout: ' || left(SQLERRM, 300)
+         WHERE run_id = v_run AND order_ref = r.order_ref;
+      END;
+    END IF;
+    v_done := v_done + 1;
+  END LOOP;
+
+  SELECT count(*) FILTER (WHERE verwerkt_at IS NULL), count(*) INTO v_rest, v_totaal
+    FROM public.logistics_schedule_werklijst WHERE run_id = v_run;
+  UPDATE public.logistics_schedule_voortgang
+     SET bijgewerkt_at = now(), verwerkt = v_totaal - v_rest, ingepland = ingepland + v_plan,
+         overgeslagen = overgeslagen + v_skip, fouten = fouten + v_err,
+         laatste_fout = CASE WHEN v_err > 0 THEN (v_fouten->0->>'order') || ': ' || (v_fouten->0->>'fout') ELSE laatste_fout END,
+         klaar = (v_rest = 0),
+         duur_ms = CASE WHEN v_rest = 0 THEN (extract(epoch FROM now() - gestart_at) * 1000)::int ELSE duur_ms END
+   WHERE id AND run_id = v_run;
+  RETURN jsonb_build_object('runId', v_run, 'totaal', v_totaal, 'verwerkt', v_totaal - v_rest, 'resterend', v_rest,
+    'ingepland', v_plan, 'overgeslagen', v_skip, 'fouten', v_fouten,
+    'durationMs', (extract(epoch FROM clock_timestamp() - v_start) * 1000)::int);
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_schedule_tasks_batch(jsonb) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_schedule_tasks_batch(jsonb) TO authenticated, service_role;