@flowselections/floriday-voorraad 1.0.66 → 1.0.68

package/dist-lib/lib/inventory-settings.functions.d.ts

@@ -5,7 +5,7 @@ export declare const saveInventorySettings: import("@tanstack/start-client-core"
 }, undefined, undefined, undefined>], (data: unknown) => {
     connectionId: string;
     productIds: string[];
-    stockMode?: "FOLLOW_ERP" | "MAXIMUM" | "FIXED_REFILL" | "MANUAL" | "DISABLED" | undefined;
+    stockMode?: "DISABLED" | "FOLLOW_ERP" | "MAXIMUM" | "FIXED_REFILL" | "MANUAL" | undefined;
     bufferQuantity?: number | undefined;
     maximumQuantity?: number | null | undefined;
     fixedQuantity?: number | null | undefined;

package/dist-lib/server-hooks/floriday-base-supply.d.ts

@@ -0,0 +1,3 @@
+/** Shell-handler voor /api/public/hooks/floriday-base-supply. Schakelaar: voorraad_hook_enabled.floriday_base_supply. */
+export declare function handleFloridayBaseSupply(request: Request): Promise<Response>;
+//# sourceMappingURL=floriday-base-supply.d.ts.map

package/dist-lib/server-hooks/floriday-base-supply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floriday-base-supply.d.ts","sourceRoot":"","sources":["../../src/server-hooks/floriday-base-supply.ts"],"names":[],"mappings":"AA2EA,yHAAyH;AACzH,wBAAsB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAElF"}

package/dist-lib/server-hooks/floriday-base-supply.js

@@ -0,0 +1,73 @@
+/**
+ * Verwerker "weekaanbod aanmaken" (M15b). Gewekt door de database zodra een
+ * wachtrijregel needs_base_supply wordt (en door een herhaaltaak die alleen
+ * bestaat zolang er regels op een nieuwe poging wachten).
+ *
+ * Authenticatie: apikey-header, vergeleken met de publieke databasesleutel
+ * (zelfde als de andere Voorraad-hooks). Open punt: naar een gedeeld geheim.
+ * De route verwerkt alleen bestaande regels en geeft geen gegevens terug.
+ */
+import { runGuardedHook } from "./guard";
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function handle(request) {
+    const json = (b, status = 200) => new Response(JSON.stringify(b), { status, headers: { "Content-Type": "application/json" } });
+    const apikey = request.headers.get("apikey") ??
+        request.headers.get("x-api-key") ??
+        request.headers.get("authorization")?.replace(/^Bearer\s+/i, "");
+    const expected = process.env.SUPABASE_PUBLISHABLE_KEY ?? process.env.SUPABASE_ANON_KEY ?? "";
+    if (!expected || !apikey || apikey !== expected)
+        return json({ error: "Unauthorized" }, 401);
+    const { stockPublishAllowed } = await import("../lib/floriday-write-gate.server.js");
+    const permission = await stockPublishAllowed();
+    if (!permission.allowed)
+        return json({ processed: 0, waiting: true, reason: permission.reason });
+    const { getAdminClient } = await import("../lib/supabase-admin.server.js");
+    const admin = getAdminClient();
+    const { resolveActiveFloridayConnection } = await import("../lib/floriday-env.server.js");
+    const { gatewaySupplyLineWeek } = await import("../lib/floriday-gateway.server.js");
+    const { priceForRow, buildRequest, decide } = await import("../lib/floriday-base-supply.js");
+    const conn = await resolveActiveFloridayConnection(admin);
+    const { data: rows, error } = await admin.rpc("claim_floriday_base_supply", {
+        p_worker: "voorraad-base-supply",
+    });
+    if (error)
+        return json({ error: `claim: ${error.message}` }, 500);
+    const summary = { processed: 0, done: 0, retry: 0, stop: 0, week_past: 0, no_price: 0 };
+    let first = true;
+    for (const row of (rows ?? [])) {
+        summary.processed++;
+        const price = priceForRow(row);
+        if (!price.ok) {
+            await admin.rpc("complete_floriday_base_supply", { p_id: row.id, p_kind: "no_price", p_label: price.label });
+            summary.no_price++;
+            continue;
+        }
+        if (!first)
+            await sleep(1000); // max 1 aanvraag per seconde
+        first = false;
+        let d;
+        try {
+            const { httpStatus, body } = await gatewaySupplyLineWeek(buildRequest(row, price.price, conn.environment));
+            d = decide(httpStatus, body, row.target_week);
+        }
+        catch (e) {
+            d = { kind: "retry", label: "Floriday tijdelijk niet bereikbaar", error: String(e?.message ?? e) };
+        }
+        await admin.rpc("complete_floriday_base_supply", {
+            p_id: row.id,
+            p_kind: d.kind,
+            p_label: d.label,
+            p_error: d.error ?? null,
+            p_attempt_id: d.attemptId ?? null,
+            p_outcome: d.outcome ?? null,
+            p_price_status: d.priceStatus ?? null,
+            p_price: price.price,
+        });
+        summary[d.kind]++;
+    }
+    return json({ ok: true, ...summary });
+}
+/** Shell-handler voor /api/public/hooks/floriday-base-supply. Schakelaar: voorraad_hook_enabled.floriday_base_supply. */
+export async function handleFloridayBaseSupply(request) {
+    return runGuardedHook(request, "floriday_base_supply", handle, "floriday-base-supply");
+}

package/dist-lib/server-hooks/floriday-continuous-stock-pull.d.ts

@@ -0,0 +1,3 @@
+/** Shell-handler voor /api/public/hooks/floriday-continuous-stock-pull. Schakelaar: voorraad_hook_enabled.continuous_stock_pull. */
+export declare function handleFloridayContinuousStockPull(request: Request): Promise<Response>;
+//# sourceMappingURL=floriday-continuous-stock-pull.d.ts.map

package/dist-lib/server-hooks/floriday-continuous-stock-pull.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floriday-continuous-stock-pull.d.ts","sourceRoot":"","sources":["../../src/server-hooks/floriday-continuous-stock-pull.ts"],"names":[],"mappings":"AAoNA,oIAAoI;AACpI,wBAAsB,iCAAiC,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAE3F"}

package/dist-lib/server-hooks/floriday-continuous-stock-pull.js

@@ -0,0 +1,168 @@
+/**
+ * Cron-endpoint (elke minuut vanuit pg_cron): haalt per actieve Floriday-
+ * connectie voor elk gepubliceerd trade-item de actuele voorraad op via
+ * `GET /trade-items/{tradeItemId}/continuous-stock` en cachet het aantal
+ * in `floriday_continuous_stock_cache`.
+ *
+ * Auth: apikey-header met de Supabase publishable key (identiek aan de
+ * bestaande push-hook).
+ *
+ * Rate limits en CPU-tijd op Cloudflare Workers: max 200 items per run,
+ * oudste `fetched_at` eerst; parallel 5 tegelijk per connectie.
+ */
+import { runGuardedHook } from "./guard";
+const MAX_ITEMS_PER_RUN = 200;
+const PARALLEL = 5;
+async function pMapLimited(items, limit, worker) {
+    const results = new Array(items.length);
+    let i = 0;
+    const runners = Array.from({ length: Math.min(limit, items.length) }, async () => {
+        while (i < items.length) {
+            const idx = i++;
+            results[idx] = await worker(items[idx]);
+        }
+    });
+    await Promise.all(runners);
+    return results;
+}
+async function handle(request) {
+    {
+        void 0;
+        const apikey = request.headers.get("apikey") ??
+            request.headers.get("x-api-key") ??
+            request.headers.get("authorization")?.replace(/^Bearer\s+/i, "");
+        const expected = process.env.SUPABASE_PUBLISHABLE_KEY ??
+            process.env.SUPABASE_ANON_KEY ??
+            "";
+        if (!expected || !apikey || apikey !== expected) {
+            return new Response(JSON.stringify({ error: "Unauthorized" }), { status: 401, headers: { "Content-Type": "application/json" } });
+        }
+        const { getAdminClient } = await import("../lib/supabase-admin.server.js");
+        const supabaseAdmin = getAdminClient();
+        const { gatewayRead } = await import("../lib/floriday-gateway.server.js");
+        const { resolveActiveFloridayConnection } = await import("../lib/floriday-env.server.js");
+        const activeConnection = await resolveActiveFloridayConnection(supabaseAdmin);
+        const connections = [activeConnection];
+        let totalOk = 0;
+        let totalFail = 0;
+        const perConnection = [];
+        for (const conn of connections ?? []) {
+            const environment = conn.environment;
+            // Kandidaat-trade-items voor deze connectie (gepubliceerd, niet
+            // verwijderd), oudste cache-entry eerst zodat we alles cyclisch
+            // verversen binnen een aantal runs.
+            const { data: items, error: itemsErr } = await supabaseAdmin
+                .from("floriday_trade_items_cache")
+                .select("floriday_id")
+                .eq("connection_id", conn.id)
+                .eq("is_deleted", false)
+                .limit(2000);
+            if (itemsErr) {
+                console.error(`[continuous-stock-pull] items ${conn.id}:`, itemsErr.message);
+                continue;
+            }
+            const ids = (items ?? [])
+                .map((r) => r.floriday_id)
+                .filter((v) => !!v);
+            if (!ids.length)
+                continue;
+            // Sorteer op fetched_at (oudste eerst); ontbrekende cache-entries
+            // hebben voorrang.
+            const { data: existing } = await supabaseAdmin
+                .from("floriday_continuous_stock_cache")
+                .select("trade_item_id, fetched_at")
+                .eq("connection_id", conn.id)
+                .in("trade_item_id", ids);
+            const fetchedMap = new Map();
+            for (const r of existing ?? []) {
+                fetchedMap.set(r.trade_item_id, r.fetched_at);
+            }
+            const sorted = ids.slice().sort((a, b) => {
+                const ta = fetchedMap.get(a);
+                const tb = fetchedMap.get(b);
+                if (!ta && !tb)
+                    return 0;
+                if (!ta)
+                    return -1;
+                if (!tb)
+                    return 1;
+                return ta.localeCompare(tb);
+            });
+            const batch = sorted.slice(0, MAX_ITEMS_PER_RUN);
+            let ok = 0;
+            let fail = 0;
+            const upserts = [];
+            await pMapLimited(batch, PARALLEL, async (tradeItemId) => {
+                try {
+                    const res = await gatewayRead({
+                        environment,
+                        path: `/suppliers-api-2026v1/trade-items/${tradeItemId}/continuous-stock`,
+                    });
+                    if (!res.ok) {
+                        // 404 = geen beschikbaarheid ingesteld → niet beschikbaar.
+                        if (res.status === 404) {
+                            upserts.push({
+                                connection_id: conn.id,
+                                trade_item_id: tradeItemId,
+                                number_of_pieces: 0,
+                                fetched_at: new Date().toISOString(),
+                            });
+                            ok++;
+                            return;
+                        }
+                        console.error(`[continuous-stock-pull] ${tradeItemId}: HTTP ${res.status}`);
+                        fail++;
+                        return;
+                    }
+                    // Floriday `ContinuousStock` is een beschikbaarheids-toggle:
+                    // { available: boolean }. We cachen dat als 1 (beschikbaar) of
+                    // 0 (niet beschikbaar).
+                    const data = res.data ?? {};
+                    const pieces = typeof data.numberOfPieces === "number"
+                        ? data.numberOfPieces
+                        : data.available === true
+                            ? 1
+                            : 0;
+                    upserts.push({
+                        connection_id: conn.id,
+                        trade_item_id: tradeItemId,
+                        number_of_pieces: pieces,
+                        fetched_at: new Date().toISOString(),
+                    });
+                    ok++;
+                }
+                catch (e) {
+                    console.error(`[continuous-stock-pull] ${tradeItemId}:`, e?.message ?? e);
+                    fail++;
+                }
+            });
+            if (upserts.length) {
+                const { error: upErr } = await supabaseAdmin
+                    .from("floriday_continuous_stock_cache")
+                    .upsert(upserts, {
+                    onConflict: "connection_id,trade_item_id",
+                });
+                if (upErr) {
+                    console.error(`[continuous-stock-pull] upsert ${conn.id}:`, upErr.message);
+                }
+            }
+            totalOk += ok;
+            totalFail += fail;
+            perConnection.push({
+                connection_id: conn.id,
+                items: batch.length,
+                ok,
+                fail,
+            });
+        }
+        return new Response(JSON.stringify({
+            ok: totalOk,
+            failed: totalFail,
+            connections: perConnection,
+        }), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+}
+/** Shell-handler voor /api/public/hooks/floriday-continuous-stock-pull. Schakelaar: voorraad_hook_enabled.continuous_stock_pull. */
+export async function handleFloridayContinuousStockPull(request) {
+    return runGuardedHook(request, "continuous_stock_pull", handle, "floriday-continuous-stock-pull");
+}

package/dist-lib/server-hooks/floriday-continuous-stock.d.ts

@@ -0,0 +1,3 @@
+/** Shell-handler voor /api/public/hooks/floriday-continuous-stock. Schakelaar: voorraad_hook_enabled.continuous_stock. */
+export declare function handleFloridayContinuousStock(request: Request): Promise<Response>;
+//# sourceMappingURL=floriday-continuous-stock.d.ts.map

package/dist-lib/server-hooks/floriday-continuous-stock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floriday-continuous-stock.d.ts","sourceRoot":"","sources":["../../src/server-hooks/floriday-continuous-stock.ts"],"names":[],"mappings":"AA8IA,0HAA0H;AAC1H,wBAAsB,6BAA6B,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAEvF"}

package/dist-lib/server-hooks/floriday-continuous-stock.js

@@ -0,0 +1,111 @@
+/**
+ * Verwerker voor de voorraad-wachtrij (`floriday_continuous_stock_queue`).
+ *
+ * Dit endpoint is de *terugvalweg*: de vaste verwerker is de Floriday-
+ * Authenticatie-module, die dezelfde database deelt en dezelfde twee
+ * database-functies gebruikt (`claim_floriday_stock_queue` en
+ * `complete_floriday_stock_queue`). Doordat claimen atomair gebeurt, kunnen
+ * beide verwerkers naast elkaar draaien zonder dubbele pushes.
+ *
+ * Authenticatie: apikey-header met de anon key (dit endpoint zit onder
+ * `/api/public/*`, dus platform-auth wordt overgeslagen; wij verifiëren
+ * de apikey zelf om misbruik te voorkomen).
+ */
+import { runGuardedHook } from "./guard";
+/** Vaste maximale batch per ronde: beschermt de Floriday-snelheidslimiet. */
+const BATCH_SIZE = 25;
+/** Wachttijd voordat de terugvalweg een blijven liggen regel zelf oppakt. */
+const STALE_AFTER_MS = 5 * 60000;
+async function handle(request) {
+    const apikey = request.headers.get("apikey") ??
+        request.headers.get("x-api-key") ??
+        request.headers.get("authorization")?.replace(/^Bearer\s+/i, "");
+    const expected = process.env.SUPABASE_PUBLISHABLE_KEY ?? process.env.SUPABASE_ANON_KEY ?? "";
+    if (!expected || !apikey || apikey !== expected) {
+        return new Response(JSON.stringify({ error: "Unauthorized" }), {
+            status: 401,
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    // Fail-closed poort: elke ronde opnieuw toestemming vragen. Zonder
+    // toestemming blijft de wachtrij simpelweg wachten; er wordt niets geclaimd,
+    // niets weggegooid en niets stiekem opnieuw geprobeerd.
+    const { stockPublishAllowed } = await import("../lib/floriday-write-gate.server.js");
+    const permission = await stockPublishAllowed();
+    if (!permission.allowed) {
+        return new Response(JSON.stringify({ processed: 0, ok: 0, failed: 0, waiting: true, reason: permission.reason }), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    const { getAdminClient } = await import("../lib/supabase-admin.server.js");
+    const supabaseAdmin = getAdminClient();
+    const { resolveActiveFloridayConnection } = await import("../lib/floriday-env.server.js");
+    const { pushStockRow, isRateLimited } = await import("../lib/floriday-stock-supply.server.js");
+    const activeConnection = await resolveActiveFloridayConnection(supabaseAdmin);
+    const admin = supabaseAdmin;
+    // Zelfherstel: regels van een oude koppeling worden omgezet naar de
+    // actieve koppeling in plaats van definitief afgekeurd.
+    await admin
+        .from("floriday_continuous_stock_queue")
+        .update({ connection_id: activeConnection.id })
+        .eq("status", "pending")
+        .neq("connection_id", activeConnection.id);
+    // De authenticatiemodule is de vaste verwerker. Deze terugvalweg pakt alleen
+    // regels op die daar al enkele minuten zijn blijven liggen, zodat beide
+    // verwerkers elkaar niet voor de voeten lopen.
+    const graceCutoff = new Date(Date.now() - STALE_AFTER_MS).toISOString();
+    const { count: staleCount } = await admin
+        .from("floriday_continuous_stock_queue")
+        .select("id", { count: "exact", head: true })
+        .eq("status", "pending")
+        .lt("created_at", graceCutoff);
+    if (!staleCount) {
+        return new Response(JSON.stringify({ processed: 0, ok: 0, failed: 0, idle: true, owner: "auth-module" }), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    const { data: claimed, error: claimError } = await admin.rpc("claim_floriday_stock_queue", { p_limit: BATCH_SIZE, p_worker: "voorraadmodule-fallback" });
+    if (claimError) {
+        return new Response(JSON.stringify({ error: `queue claim: ${claimError.message}` }), { status: 500, headers: { "Content-Type": "application/json" } });
+    }
+    const rows = (claimed ?? []);
+    let ok = 0;
+    let failed = 0;
+    let rateLimited = false;
+    for (const row of rows) {
+        if (rateLimited) {
+            // Ronde afbreken: de rest blijft geclaimd en valt na de lock-time-out
+            // vanzelf terug in de wachtrij.
+            await admin.rpc("complete_floriday_stock_queue", {
+                p_id: row.id,
+                p_ok: false,
+                p_error: "Snelheidslimiet van Floriday bereikt; automatisch opnieuw geprobeerd.",
+                p_permanent: false,
+                p_attempt_id: null,
+            });
+            failed++;
+            continue;
+        }
+        const outcome = await pushStockRow({
+            supabaseAdmin,
+            environment: activeConnection.environment,
+            row,
+        });
+        if (outcome.ok) {
+            ok++;
+        }
+        else {
+            failed++;
+            if (outcome.error && isRateLimited(outcome.error))
+                rateLimited = true;
+        }
+        await admin.rpc("complete_floriday_stock_queue", {
+            p_id: row.id,
+            p_ok: outcome.ok,
+            p_error: outcome.ok ? outcome.quantitySkipped ?? null : outcome.error ?? null,
+            p_permanent: outcome.permanent ?? false,
+            p_attempt_id: outcome.attemptId ?? null,
+        });
+    }
+    return new Response(JSON.stringify({ processed: rows.length, ok, failed, rateLimited }), { status: 200, headers: { "Content-Type": "application/json" } });
+}
+/** Shell-handler voor /api/public/hooks/floriday-continuous-stock. Schakelaar: voorraad_hook_enabled.continuous_stock. */
+export async function handleFloridayContinuousStock(request) {
+    return runGuardedHook(request, "continuous_stock", handle, "floriday-continuous-stock");
+}

package/dist-lib/server-hooks/floriday-stock-reconcile.d.ts

@@ -0,0 +1,3 @@
+/** Shell-handler voor /api/public/hooks/floriday-stock-reconcile. Schakelaar: voorraad_hook_enabled.stock_reconcile. */
+export declare function handleFloridayStockReconcile(request: Request): Promise<Response>;
+//# sourceMappingURL=floriday-stock-reconcile.d.ts.map

package/dist-lib/server-hooks/floriday-stock-reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floriday-stock-reconcile.d.ts","sourceRoot":"","sources":["../../src/server-hooks/floriday-stock-reconcile.ts"],"names":[],"mappings":"AAwPA,wHAAwH;AACxH,wBAAsB,4BAA4B,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAEtF"}

package/dist-lib/server-hooks/floriday-stock-reconcile.js

@@ -0,0 +1,235 @@
+/**
+ * Reconciliatie: leest de werkelijke standen bij Floriday terug en vergelijkt
+ * ze met wat wij gewenst hebben.
+ *
+ * Bewust langzaam: lezen van `base-supply` is bij Floriday begrensd op één
+ * call per seconde. Per ronde wordt daarom een beperkt aantal weken gelezen
+ * (de lopende week plus de horizon), nooit per artikel.
+ *
+ * Bij een verschil zonder openstaande wachtrijregel wordt het artikel als
+ * DRIFT gemarkeerd en één correctie ingepland.
+ */
+import { runGuardedHook } from "./guard";
+const MAX_WEEKS_PER_RUN = 5;
+async function handle(request) {
+    const apikey = request.headers.get("apikey") ??
+        request.headers.get("x-api-key") ??
+        request.headers.get("authorization")?.replace(/^Bearer\s+/i, "");
+    const expected = process.env.SUPABASE_PUBLISHABLE_KEY ?? process.env.SUPABASE_ANON_KEY ?? "";
+    if (!expected || !apikey || apikey !== expected) {
+        return new Response(JSON.stringify({ error: "Unauthorized" }), {
+            status: 401,
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    const { getAdminClient } = await import("../lib/supabase-admin.server.js");
+    const admin = getAdminClient();
+    const { resolveActiveFloridayConnection } = await import("../lib/floriday-env.server.js");
+    const { isoWeekOf } = await import("../lib/floriday-2026v1.server.js");
+    const connection = await resolveActiveFloridayConnection(admin);
+    const remote = new Map();
+    const errors = [];
+    let reads = 0;
+    let readErrors = 0;
+    let rateLimited = 0;
+    let lastHttpStatus = null;
+    let currentWeekRead = false;
+    const { data: runRow, error: runErr } = await admin
+        .from("floriday_reconcile_runs")
+        .insert({ connection_id: connection.id })
+        .select("id")
+        .single();
+    if (runErr)
+        throw new Error(`Run-log kon niet worden aangemaakt: ${runErr.message}`);
+    const runId = runRow.id;
+    // Lezen via /api/public/gateway/floriday-get van de authenticatiemodule;
+    // per week één verzoek, minimaal 1 s ertussen.
+    const { readBaseSupplyWeeks } = await import("../lib/base-supply-reader.server.js");
+    const weeks = [];
+    for (let offset = 0; offset < MAX_WEEKS_PER_RUN; offset++) {
+        const date = new Date();
+        date.setUTCDate(date.getUTCDate() + offset * 7);
+        weeks.push(isoWeekOf(date));
+    }
+    let endpoint = "";
+    let environment = null;
+    let missingScope = false;
+    const weekLog = [];
+    try {
+        const out = await readBaseSupplyWeeks(weeks);
+        endpoint = out.endpoint;
+        environment = out.environment;
+        lastHttpStatus = out.httpStatus;
+        missingScope = out.missingScope;
+        out.results.forEach((r, i) => {
+            reads++;
+            if (r.rateLimited)
+                rateLimited++;
+            weekLog.push({ year: r.year, week: r.week, ok: r.ok, status: r.httpStatus, rows: r.rows.length,
+                error: r.error, retryAfterMs: r.retryAfterMs, rateLimited: r.rateLimited, missingScope: r.missingScope });
+            if (!r.ok) {
+                readErrors++;
+                errors.push(`week ${r.year}-${r.week}: ${r.error ?? "onbekende fout"} (status ${r.httpStatus ?? "?"})`);
+                return;
+            }
+            if (i === 0) {
+                currentWeekRead = true;
+                for (const row of r.rows) {
+                    remote.set(row.tradeItemId, { pieces: row.numberOfPieces, available: row.isAvailable });
+                }
+            }
+        });
+        const unread = weeks.length - out.results.length;
+        if (unread > 0) {
+            readErrors += unread;
+            if (out.error && !errors.includes(out.error))
+                errors.unshift(out.error);
+        }
+    }
+    catch (e) {
+        readErrors = weeks.length;
+        errors.push(`leesroute niet bereikbaar: ${e?.message ?? e}`);
+    }
+    if (missingScope) {
+        errors.unshift("MISSING_SCOPE_SUPPLY_READ: Floriday heeft het leesrecht supply:read nog niet vrijgegeven");
+    }
+    // Beschikbaarheid uit Floriday voor artikelen zonder weekaanbod.
+    let availability = null;
+    let availMap = new Map();
+    if (currentWeekRead && !missingScope) {
+        await new Promise((r) => setTimeout(r, 1000));
+        try {
+            const { readAvailabilities } = await import("../lib/base-supply-reader.server.js");
+            const av = await readAvailabilities();
+            reads++;
+            if (av.rateLimited)
+                rateLimited++;
+            availMap = av.map;
+            availability = { path: "/trade-items/availabilities", ok: av.ok, status: av.httpStatus, rows: av.rows,
+                matched: av.map.size, error: av.error, retryAfterMs: av.retryAfterMs, rateLimited: av.rateLimited };
+            if (!av.ok)
+                errors.push(`availabilities: ${av.error} (status ${av.httpStatus ?? "?"})`);
+        }
+        catch (e) {
+            availability = { path: "/trade-items/availabilities", ok: false, error: String(e?.message ?? e) };
+            errors.push(`availabilities niet bereikbaar: ${e?.message ?? e}`);
+        }
+    }
+    const { data: settings, error: setErr } = await admin
+        .from("floriday_inventory_settings")
+        .select("id, connection_id, product_id, floriday_trade_item_id, desired_quantity, desired_availability, stock_mode, sync_status")
+        .eq("connection_id", connection.id)
+        .not("floriday_trade_item_id", "is", null);
+    if (setErr)
+        throw new Error(setErr.message);
+    const { data: pendingRows } = await admin
+        .from("floriday_continuous_stock_queue")
+        .select("trade_item_id")
+        .eq("connection_id", connection.id)
+        .in("status", ["pending", "processing"]);
+    const pending = new Set((pendingRows ?? []).map((r) => String(r.trade_item_id)));
+    let drift = 0;
+    let inSync = 0;
+    let noSupply = 0;
+    const noSupplyItems = [];
+    const nowIso = new Date().toISOString();
+    for (const s of settings ?? []) {
+        const key = String(s.floriday_trade_item_id);
+        const actual = remote.get(key);
+        if (missingScope && !actual)
+            continue;
+        if (!actual) {
+            // Alleen als de lopende week echt gelezen is mogen we "geen aanbod" concluderen.
+            if (!currentWeekRead || s.stock_mode === "DISABLED" || s.sync_status === "ACTION_REQUIRED")
+                continue;
+            noSupply++;
+            noSupplyItems.push(key);
+            await admin
+                .from("floriday_inventory_settings")
+                .update({
+                remote_quantity: null,
+                remote_available: availMap.has(key) ? availMap.get(key) : null,
+                remote_checked_at: nowIso,
+                sync_status: "NO_REMOTE_SUPPLY",
+                last_sync_error: "geen aanbod in Floriday, prijs ontbreekt",
+                updated_at: nowIso,
+            })
+                .eq("id", s.id);
+            continue;
+        }
+        const matches = actual.pieces === Number(s.desired_quantity ?? 0) &&
+            actual.available === Boolean(s.desired_availability);
+        const hasPending = pending.has(key);
+        const status = s.stock_mode === "DISABLED"
+            ? "DISABLED"
+            : matches
+                ? "IN_SYNC"
+                : hasPending
+                    ? "PENDING"
+                    : "DRIFT";
+        await admin
+            .from("floriday_inventory_settings")
+            .update({
+            remote_quantity: actual.pieces,
+            remote_available: actual.available,
+            remote_checked_at: nowIso,
+            sync_status: status,
+            last_confirmed_at: matches ? nowIso : undefined,
+            updated_at: nowIso,
+        })
+            .eq("id", s.id);
+        if (status === "DRIFT") {
+            drift++;
+            await admin.rpc("floriday_recompute_inventory", {
+                p_connection_id: s.connection_id,
+                p_product_id: s.product_id,
+                p_force: true,
+            });
+        }
+        else if (status === "IN_SYNC") {
+            inSync++;
+        }
+    }
+    await admin
+        .from("floriday_sync_cursors")
+        .upsert({
+        connection_id: connection.id,
+        resource_type: "base-supply-reconcile",
+        sequence_number: 0,
+        last_sync_at: nowIso,
+        last_error: errors.length ? errors.join("; ") : null,
+        updated_at: nowIso,
+    }, { onConflict: "connection_id,resource_type" });
+    const runStatus = readErrors === 0 ? "ok" : currentWeekRead ? "partial" : "failed";
+    const response = {
+        runId, status: runStatus, endpoint, environment, reason: missingScope ? "MISSING_SCOPE_SUPPLY_READ" : null,
+        weeks: weekLog, availability, reads, readErrors, rateLimited,
+        checked: remote.size, inSync, drift, noSupply, noSupplyItems, errors,
+    };
+    const { error: finErr } = await admin
+        .from("floriday_reconcile_runs")
+        .update({
+        finished_at: new Date().toISOString(),
+        status: runStatus,
+        reads,
+        read_errors: readErrors,
+        rate_limited: rateLimited,
+        last_http_status: lastHttpStatus,
+        first_error: errors[0] ?? null,
+        items_checked: remote.size,
+        items_no_supply: noSupply,
+        items_drift: drift,
+        response,
+    })
+        .eq("id", runId);
+    if (finErr)
+        console.error("[stock-reconcile] run-log afronden mislukt:", finErr.message);
+    return new Response(JSON.stringify(response), {
+        status: runStatus === "failed" ? 502 : 200,
+        headers: { "Content-Type": "application/json" },
+    });
+}
+/** Shell-handler voor /api/public/hooks/floriday-stock-reconcile. Schakelaar: voorraad_hook_enabled.stock_reconcile. */
+export async function handleFloridayStockReconcile(request) {
+    return runGuardedHook(request, "stock_reconcile", handle, "floriday-stock-reconcile");
+}

package/dist-lib/server-hooks/guard.d.ts

@@ -0,0 +1,3 @@
+export declare function hookEnabled(name: string): Promise<boolean>;
+export declare function runGuardedHook(request: Request, name: string, handle: (request: Request) => Promise<Response>, label: string): Promise<Response>;
+//# sourceMappingURL=guard.d.ts.map

package/dist-lib/server-hooks/guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../../src/server-hooks/guard.ts"],"names":[],"mappings":"AAuCA,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAUhE;AAED,wBAAsB,cAAc,CAClC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,EAC/C,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,QAAQ,CAAC,CAUnB"}