@flowselections/floriday-voorraad 1.0.40 → 1.0.41

package/dist-lib/lib/logistics-buffer-events.server.d.ts

@@ -0,0 +1,13 @@
+type Admin = any;
+export interface BufferEventSummary {
+    events: number;
+    closed: number;
+    detached: number;
+    recalculated: number;
+    errors: string[];
+}
+export declare function runBufferEvents(): Promise<BufferEventSummary>;
+/** True wanneer een taak niet meer uitgevoerd mag worden (buffer dicht/af). */
+export declare function isBufferClosed(admin: Admin, bufferRef: string | null): Promise<boolean>;
+export {};
+//# sourceMappingURL=logistics-buffer-events.server.d.ts.map

package/dist-lib/lib/logistics-buffer-events.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logistics-buffer-events.server.d.ts","sourceRoot":"","sources":["../../src/lib/logistics-buffer-events.server.ts"],"names":[],"mappings":"AA0BA,KAAK,KAAK,GAAG,GAAG,CAAC;AAEjB,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAqUD,wBAAsB,eAAe,IAAI,OAAO,CAAC,kBAAkB,CAAC,CA6EnE;AAED,+EAA+E;AAC/E,wBAAsB,cAAc,CAClC,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,MAAM,GAAG,IAAI,GACvB,OAAO,CAAC,OAAO,CAAC,CAQlB"}

package/dist-lib/lib/logistics-buffer-events.server.js

@@ -0,0 +1,365 @@
+/**
+ * Verwerkt de seintjes van de Logistics Engine over orderbuffers.
+ *
+ * De Engine sluit een buffer zodra alle karren afgehandeld zijn
+ * (`buffer.closed`) en koppelt orders die er nog aan hingen los
+ * (`buffer.order_detached`). Deze module beslist niets over buffers: ze
+ * herberekent alleen reserveringen en beschikbare voorraad.
+ *
+ * Eigenschappen:
+ *  - Idempotent: elk seintje wordt hoogstens één keer doorgerekend
+ *    (`voorraad_logistics_event_log`, primaire sleutel = event-id).
+ *  - Nooit terugboeken: `physical_stock` wordt niet aangeraakt; al afgeboekte
+ *    voorraad van afgehandelde karren blijft staan.
+ *  - Reserveringen worden absoluut gezet uit de nog openstaande taken, dus een
+ *    herhaalde run kan niet dubbeltellen.
+ *  - Gesloten of afgehandelde buffers krijgen niets meer toegewezen.
+ *
+ * Server-only: nooit importeren vanuit componenten.
+ */
+import { OWNER_MODULE, parseStockReservePlan } from "./logistics-engine";
+const BUFFER_EVENT_TYPES = ["buffer.closed", "buffer.order_detached"];
+const LOOKBACK_DAYS = 7;
+const EVENT_BATCH = 50;
+const ACTIVE_TASK_STATUSES = ["planned", "ready", "in_progress"];
+function str(value) {
+    const s = String(value ?? "").trim();
+    return s ? s : null;
+}
+/** Alle manieren waarop een buffer in `logistics_tasks.buffer_ref` kan staan. */
+function bufferRefsFrom(payload, prefix) {
+    const pick = (base) => {
+        if (prefix === "")
+            return payload?.[base];
+        const key = prefix + base.charAt(0).toUpperCase() + base.slice(1);
+        return payload?.[key];
+    };
+    return [str(pick("bufferId")), str(pick("bufferKey")), str(pick("bufferRef"))].filter((v) => Boolean(v));
+}
+/**
+ * Verwijzingen die als "dicht" gelden.
+ *
+ * Een buffer-id is uniek, dus die telt altijd. Een buffersleutel wordt door
+ * meerdere buffers gedeeld: die telt alleen mee wanneer er geen enkele nog
+ * open buffer met dezelfde sleutel bekend is. Zo blokkeert het sluiten van
+ * één buffer nooit de andere buffers met dezelfde sleutel.
+ */
+async function closedBufferRefs(admin) {
+    const { data } = await admin
+        .from("voorraad_buffer_state")
+        .select("buffer_id,buffer_key,closed_at");
+    const rows = (data ?? []);
+    const set = new Set();
+    const openKeys = new Set();
+    for (const row of rows) {
+        if (row.closed_at)
+            set.add(String(row.buffer_id));
+        else if (row.buffer_key)
+            openKeys.add(row.buffer_key);
+    }
+    for (const row of rows) {
+        if (row.closed_at && row.buffer_key && !openKeys.has(row.buffer_key)) {
+            set.add(row.buffer_key);
+        }
+    }
+    return set;
+}
+/**
+ * Toets bij de Engine of een buffer echt afgehandeld is. Deze module bepaalt
+ * dat nooit zelf; bij twijfel behandelen we de buffer als open.
+ */
+async function bufferHandled(admin, bufferId) {
+    if (!bufferId)
+        return false;
+    try {
+        const { data, error } = await admin.rpc("logistics_buffer_handled", { p_buffer: bufferId });
+        if (error)
+            return false;
+        return data === true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Artikelsleutels uit alle taken van een buffer (ongeacht status). */
+async function keysForBuffer(admin, refs) {
+    if (refs.length === 0)
+        return [];
+    const { data } = await admin
+        .from("logistics_tasks")
+        .select("payload")
+        .eq("owner_module", OWNER_MODULE)
+        .in("buffer_ref", refs);
+    const keys = new Set();
+    for (const row of (data ?? [])) {
+        for (const line of parseStockReservePlan(row.payload).lines)
+            keys.add(line.tradeItemKey);
+    }
+    return [...keys];
+}
+/** Artikelsleutels uit alle taken van één order. */
+async function keysForOrder(admin, orderRef) {
+    const { data } = await admin
+        .from("logistics_tasks")
+        .select("payload")
+        .eq("owner_module", OWNER_MODULE)
+        .eq("order_ref", orderRef);
+    const keys = new Set();
+    for (const row of (data ?? [])) {
+        for (const line of parseStockReservePlan(row.payload).lines)
+            keys.add(line.tradeItemKey);
+    }
+    return [...keys];
+}
+/**
+ * Zet de reservering van de opgegeven artikelen opnieuw op de som van de nog
+ * openstaande taken. Taken die klaar (`done`) zijn horen bij afgehandelde
+ * karren: die voorraad is al geboekt en telt hier bewust niet mee, zodat er
+ * niets wordt teruggedraaid of dubbel geteld. Taken op een gesloten buffer
+ * tellen evenmin mee.
+ */
+async function recalculateReservations(admin, keys, closed, connectionId) {
+    if (keys.length === 0)
+        return [];
+    const { data: tasks } = await admin
+        .from("logistics_tasks")
+        .select("order_ref,buffer_ref,payload,status")
+        .eq("owner_module", OWNER_MODULE)
+        .in("status", ACTIVE_TASK_STATUSES);
+    const totals = new Map();
+    const orderRefs = new Map();
+    for (const key of keys) {
+        totals.set(key, 0);
+        orderRefs.set(key, new Set());
+    }
+    for (const task of (tasks ?? [])) {
+        if (task.buffer_ref && closed.has(task.buffer_ref))
+            continue;
+        for (const line of parseStockReservePlan(task.payload).lines) {
+            if (!totals.has(line.tradeItemKey))
+                continue;
+            totals.set(line.tradeItemKey, (totals.get(line.tradeItemKey) ?? 0) + line.quantity);
+            orderRefs.get(line.tradeItemKey).add(task.order_ref);
+        }
+    }
+    let query = admin
+        .from("trade_item_stock")
+        .select("connection_id,trade_item_key,physical_stock,reserved_stock")
+        .in("trade_item_key", keys);
+    if (connectionId)
+        query = query.eq("connection_id", connectionId);
+    const { data: rows } = await query;
+    const result = [];
+    for (const row of (rows ?? [])) {
+        const target = totals.get(row.trade_item_key) ?? 0;
+        if (target !== row.reserved_stock) {
+            // Absolute waarde: idempotent, en `physical_stock` blijft ongemoeid.
+            await admin
+                .from("trade_item_stock")
+                .update({ reserved_stock: target })
+                .eq("connection_id", row.connection_id)
+                .eq("trade_item_key", row.trade_item_key);
+        }
+        result.push({
+            tradeItemKey: row.trade_item_key,
+            reserved: target,
+            physical: row.physical_stock,
+            orderRefs: [...(orderRefs.get(row.trade_item_key) ?? [])],
+        });
+    }
+    return result;
+}
+/** Terugmelden aan de Engine met het ordernummer van de (losgekoppelde) order. */
+async function emitStockChanged(admin, orderRef, bufferRef, lines) {
+    if (!orderRef || lines.length === 0)
+        return;
+    const rows = lines.map((line) => ({
+        source_module: OWNER_MODULE,
+        event_type: "stock.changed",
+        order_ref: orderRef,
+        shadow: false,
+        payload: {
+            tradeItemKey: line.tradeItemKey,
+            physicalStock: line.physical,
+            reservedStock: line.reserved,
+            availableStock: Math.max(0, line.physical - line.reserved),
+            bufferRef,
+            reason: "buffer_recalculated",
+        },
+    }));
+    await admin.from("logistics_events").insert(rows);
+}
+async function handleBufferClosed(admin, event, closed, connectionId) {
+    const payload = event.payload ?? {};
+    const bufferId = str(payload.bufferId);
+    const refs = bufferRefsFrom(payload, "");
+    if (bufferId) {
+        await admin.from("voorraad_buffer_state").upsert({
+            buffer_id: bufferId,
+            buffer_key: str(payload.bufferKey) ?? str(payload.bufferRef),
+            closed_at: event.created_at ?? new Date().toISOString(),
+            reason: str(payload.reason) ?? "buffer_closed",
+            updated_at: new Date().toISOString(),
+        }, { onConflict: "buffer_id" });
+    }
+    // Alleen verwijzingen die écht dicht zijn tellen mee: het buffer-id altijd,
+    // een gedeelde buffersleutel pas wanneer er geen open buffer meer op staat.
+    const fresh = await closedBufferRefs(admin);
+    for (const ref of fresh)
+        closed.add(ref);
+    const closedRefs = refs.filter((r) => closed.has(r));
+    const keys = await keysForBuffer(admin, refs);
+    // Nog niet gestarte reserveringen voor deze buffer worden niet meer
+    // uitgevoerd: een gesloten buffer krijgt geen voorraad meer toegewezen.
+    if (closedRefs.length > 0) {
+        await admin
+            .from("logistics_tasks")
+            .update({
+            status: "skipped",
+            claimed_by: null,
+            claimed_at: null,
+            next_attempt_at: null,
+            completed_at: new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+            result: { reason: "buffer_closed", bufferId },
+        })
+            .eq("owner_module", OWNER_MODULE)
+            .in("buffer_ref", closedRefs)
+            .in("status", ["planned", "ready"]);
+    }
+    const lines = await recalculateReservations(admin, keys, closed, connectionId);
+    const orderRef = str(event.order_ref);
+    if (orderRef)
+        await emitStockChanged(admin, orderRef, refs[0] ?? null, lines);
+    return { keys: keys.length, lines: lines.length };
+}
+async function handleOrderDetached(admin, event, closed, connectionId) {
+    const payload = event.payload ?? {};
+    const orderRef = str(payload.orderRef) ?? str(event.order_ref);
+    if (!orderRef)
+        return { keys: 0, lines: 0 };
+    const newRefs = bufferRefsFrom(payload, "new");
+    const previousRefs = bufferRefsFrom(payload, "previous");
+    for (const ref of previousRefs) {
+        if (await bufferHandled(admin, str(payload.previousBufferId)))
+            closed.add(ref);
+    }
+    const newBufferId = str(payload.newBufferId);
+    const newBufferRef = newRefs[0] ?? null;
+    // De order staat vanaf nu op zichzelf (of in de nieuwe buffer): openstaande
+    // taken volgen mee, zodat de reservering onder het eigen ordernummer hangt.
+    await admin
+        .from("logistics_tasks")
+        .update({ buffer_ref: newBufferRef, updated_at: new Date().toISOString() })
+        .eq("owner_module", OWNER_MODULE)
+        .eq("order_ref", orderRef)
+        .in("status", ACTIVE_TASK_STATUSES);
+    if (newBufferId) {
+        await admin.from("voorraad_buffer_state").upsert({
+            buffer_id: newBufferId,
+            buffer_key: str(payload.newBufferKey),
+            updated_at: new Date().toISOString(),
+        }, { onConflict: "buffer_id" });
+    }
+    const previousBufferId = str(payload.previousBufferId);
+    if (previousBufferId) {
+        const { data: state } = await admin
+            .from("voorraad_buffer_state")
+            .select("detached_orders")
+            .eq("buffer_id", previousBufferId)
+            .maybeSingle();
+        const list = new Set(Array.isArray(state?.detached_orders) ? state.detached_orders.map(String) : []);
+        list.add(orderRef);
+        await admin.from("voorraad_buffer_state").upsert({
+            buffer_id: previousBufferId,
+            buffer_key: str(payload.previousBufferKey),
+            detached_orders: [...list],
+            updated_at: new Date().toISOString(),
+        }, { onConflict: "buffer_id" });
+    }
+    const keys = await keysForOrder(admin, orderRef);
+    const lines = await recalculateReservations(admin, keys, closed, connectionId);
+    await emitStockChanged(admin, orderRef, newBufferRef, lines);
+    return { keys: keys.length, lines: lines.length };
+}
+export async function runBufferEvents() {
+    const summary = {
+        events: 0,
+        closed: 0,
+        detached: 0,
+        recalculated: 0,
+        errors: [],
+    };
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    const admin = supabaseAdmin;
+    const since = new Date(Date.now() - LOOKBACK_DAYS * 86400000).toISOString();
+    const { data: events, error } = await admin
+        .from("logistics_events")
+        .select("id,event_type,order_ref,payload,created_at")
+        .in("event_type", BUFFER_EVENT_TYPES)
+        .gte("created_at", since)
+        .order("created_at", { ascending: true })
+        .limit(EVENT_BATCH * 4);
+    if (error)
+        throw new Error(`seintjes lezen: ${error.message}`);
+    const all = (events ?? []);
+    if (all.length === 0)
+        return summary;
+    const { data: seenRows } = await admin
+        .from("voorraad_logistics_event_log")
+        .select("event_id")
+        .in("event_id", all.map((e) => e.id));
+    const seen = new Set((seenRows ?? []).map((r) => String(r.event_id)));
+    const todo = all.filter((e) => !seen.has(String(e.id))).slice(0, EVENT_BATCH);
+    if (todo.length === 0)
+        return summary;
+    let connectionId = null;
+    try {
+        const { resolveActiveFloridayConnection } = await import("./floriday-env.server");
+        connectionId = (await resolveActiveFloridayConnection(admin)).id;
+    }
+    catch {
+        connectionId = null;
+    }
+    const closed = await closedBufferRefs(admin);
+    for (const event of todo) {
+        try {
+            const result = event.event_type === "buffer.closed"
+                ? await handleBufferClosed(admin, event, closed, connectionId)
+                : await handleOrderDetached(admin, event, closed, connectionId);
+            if (event.event_type === "buffer.closed")
+                summary.closed++;
+            else
+                summary.detached++;
+            summary.recalculated += result.lines;
+            summary.events++;
+            await admin.from("voorraad_logistics_event_log").upsert({
+                event_id: event.id,
+                event_type: event.event_type,
+                order_ref: event.order_ref ?? null,
+                result,
+                processed_at: new Date().toISOString(),
+            }, { onConflict: "event_id" });
+        }
+        catch (e) {
+            const message = String(e?.message ?? e).slice(0, 500);
+            summary.errors.push(`${event.id}: ${message}`);
+            console.warn(`[voorraad] bufferseintje ${event.id} mislukt: ${message}`);
+            // Niet loggen als verwerkt: de volgende ronde probeert het opnieuw.
+        }
+    }
+    return summary;
+}
+/** True wanneer een taak niet meer uitgevoerd mag worden (buffer dicht/af). */
+export async function isBufferClosed(admin, bufferRef) {
+    if (!bufferRef)
+        return false;
+    const closed = await closedBufferRefs(admin);
+    if (closed.has(bufferRef))
+        return true;
+    // Onbekend bij ons? Dan heeft de Engine het laatste woord.
+    const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(bufferRef);
+    if (isUuid)
+        return await bufferHandled(admin, bufferRef);
+    return false;
+}

package/dist-lib/lib/logistics-events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logistics-events.d.ts","sourceRoot":"","sources":["../../src/lib/logistics-events.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,gBAAgB,GAAG,eAAe,GAAG,eAAe,GAAG,MAAM,CAAC;IACzE,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC/B;AAED,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,mBAAmB,iBAUpE;AAED,UAAU,iBAAiB;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AA6BD,6CAA6C;AAC7C,wBAAsB,qBAAqB,CAAC,KAAK,EAAE,iBAAiB,iBAmBnE"}
+{"version":3,"file":"logistics-events.d.ts","sourceRoot":"","sources":["../../src/lib/logistics-events.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,gBAAgB,GAAG,eAAe,GAAG,eAAe,GAAG,MAAM,CAAC;IACzE,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC/B;AAED,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,mBAAmB,iBAUpE;AAED,UAAU,iBAAiB;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AA6DD,6CAA6C;AAC7C,wBAAsB,qBAAqB,CAAC,KAAK,EAAE,iBAAiB,iBAmBnE"}

package/dist-lib/lib/logistics-events.js

@@ -19,18 +19,47 @@ export async function insertLogisticsEvent(input) {
     if (error)
         throw new Error(error.message);
 }
+/**
+ * Buffers die door de Engine gesloten zijn; die krijgen niets meer. Een
+ * gedeelde buffersleutel telt pas mee als er geen open buffer meer op staat.
+ */
+async function closedBufferRefs() {
+    const { data } = await supabase
+        .from("voorraad_buffer_state")
+        .select("buffer_id,buffer_key,closed_at");
+    const rows = (data ?? []);
+    const set = new Set();
+    const openKeys = new Set();
+    for (const row of rows) {
+        if (row.closed_at)
+            set.add(String(row.buffer_id));
+        else if (row.buffer_key)
+            openKeys.add(row.buffer_key);
+    }
+    for (const row of rows) {
+        if (row.closed_at && row.buffer_key && !openKeys.has(row.buffer_key))
+            set.add(row.buffer_key);
+    }
+    return set;
+}
 /**
  * Zoekt de openstaande Engine-taak die dit artikel raakt, zodat het
- * stock.changed-event dezelfde order_ref (en context) draagt.
+ * stock.changed-event dezelfde order_ref (en context) draagt. Taken op een
+ * gesloten buffer tellen niet mee.
  */
 async function findOpenTaskFor(tradeItemKey) {
-    const { data } = await supabase
-        .from("logistics_tasks")
-        .select("order_ref,strategy_id,shadow,payload,buffer_ref")
-        .eq("owner_module", OWNER_MODULE)
-        .in("status", ["planned", "ready", "in_progress"])
-        .order("planned_start", { ascending: true });
+    const [{ data }, closed] = await Promise.all([
+        supabase
+            .from("logistics_tasks")
+            .select("order_ref,strategy_id,shadow,payload,buffer_ref")
+            .eq("owner_module", OWNER_MODULE)
+            .in("status", ["planned", "ready", "in_progress"])
+            .order("planned_start", { ascending: true }),
+        closedBufferRefs(),
+    ]);
     for (const task of (data ?? [])) {
+        if (task.buffer_ref && closed.has(task.buffer_ref))
+            continue;
         const plan = parseStockReservePlan(task.payload);
         if (plan.lines.some((l) => l.tradeItemKey === tradeItemKey)) {
             return { task, loadCarriers: plan.loadCarriers };

package/dist-lib/lib/logistics-tasks.server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logistics-tasks.server.d.ts","sourceRoot":"","sources":["../../src/lib/logistics-tasks.server.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,SAAS,kBAAkB,CAAC;AACzC,eAAO,MAAM,YAAY,IAAI,CAAC;AAQ9B,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,SAAS,QAAQ;CAC3B;AA0BD,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AA0FD,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,UAAU,CAAC,CAuJ7D;AAgBD,wBAAgB,uBAAuB,IAAI,IAAI,CA2B9C"}
+{"version":3,"file":"logistics-tasks.server.d.ts","sourceRoot":"","sources":["../../src/lib/logistics-tasks.server.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,SAAS,kBAAkB,CAAC;AACzC,eAAO,MAAM,YAAY,IAAI,CAAC;AAQ9B,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,SAAS,QAAQ;CAC3B;AA0BD,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAuGD,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,UAAU,CAAC,CA2K7D;AAgBD,wBAAgB,uBAAuB,IAAI,IAAI,CAiC9C"}

package/dist-lib/lib/logistics-tasks.server.js

@@ -63,6 +63,17 @@ function appendAttempt(task, entry) {
  * of er opnieuw geprobeerd wordt.
  */
 async function executeTask(supabaseAdmin, task, connectionId) {
+    // Een gesloten of volledig afgehandelde buffer krijgt geen voorraad meer
+    // toegewezen; de taak wordt overgeslagen in plaats van uitgevoerd.
+    const { isBufferClosed } = await import("./logistics-buffer-events.server");
+    if (await isBufferClosed(supabaseAdmin, task.buffer_ref)) {
+        return {
+            applied: false,
+            skipped: true,
+            diff: [],
+            message: "Buffer is gesloten of afgehandeld; reservering overgeslagen.",
+        };
+    }
     const plan = parseStockReservePlan(task.payload);
     if (plan.lines.length === 0) {
         return {
@@ -130,6 +141,18 @@ export async function runLogisticsTasks() {
         durationMs: 0,
     };
     const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    // Eerst de seintjes over gesloten en losgekoppelde buffers verwerken, zodat
+    // taken op een dichte buffer daarna niet meer worden uitgevoerd.
+    try {
+        const { runBufferEvents } = await import("./logistics-buffer-events.server");
+        const buffers = await runBufferEvents();
+        if (buffers.events > 0) {
+            console.info(`[voorraad] bufferseintjes verwerkt: ${buffers.closed} gesloten, ${buffers.detached} losgekoppeld, ${buffers.recalculated} artikel(en) herberekend`);
+        }
+    }
+    catch (e) {
+        console.warn("[voorraad] bufferseintjes verwerken mislukt:", e?.message ?? e);
+    }
     // Actieve koppeling is optioneel: zonder koppeling reserveren we op alle
     // rijen van het artikel. Faalt de resolutie, dan blokkeren we niet.
     let connectionId = null;
@@ -181,7 +204,7 @@ export async function runLogisticsTasks() {
             await supabaseAdmin
                 .from("logistics_tasks")
                 .update({
-                status: "done",
+                status: result.skipped ? "skipped" : "done",
                 attempts: attempt,
                 attempt_log: log,
                 last_error: null,
@@ -200,9 +223,14 @@ export async function runLogisticsTasks() {
                 updated_at: nowIso,
             })
                 .eq("id", task.id);
-            if (task.shadow)
-                summary.shadow++;
-            summary.done++;
+            if (result.skipped) {
+                summary.skipped++;
+            }
+            else {
+                if (task.shadow)
+                    summary.shadow++;
+                summary.done++;
+            }
         }
         catch (e) {
             const message = errorMessage(e);
@@ -289,9 +317,13 @@ export function maybeTickLogisticsTasks() {
                 .or(`next_attempt_at.is.null,next_attempt_at.lte.${new Date().toISOString()}`);
             if (error)
                 throw new Error(error.message);
-            if (!count)
+            if (count) {
+                await runLogisticsTasks(); // verwerkt zelf ook de bufferseintjes
                 return;
-            await runLogisticsTasks();
+            }
+            // Geen openstaande taken, maar er kunnen wel nieuwe bufferseintjes zijn.
+            const { runBufferEvents } = await import("./logistics-buffer-events.server");
+            await runBufferEvents();
         }
         catch (e) {
             console.warn("[voorraad] achtergrond-tick mislukt:", e?.message ?? e);