@cardinali-studio/adminkit 1.0.0

package/dist/form/prose/ProseField.js

@@ -0,0 +1,152 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/* Il campo in cui si scrive la prosa del sito: testo formattato, non markdown.
+ *
+ * ── Cosa è cambiato, e perché ──────────────────────────────────────────────────────────────
+ * Era una `<textarea>` che mostrava `**parola**`. Chi usa il pannello non scrive markdown e non
+ * ha ragione di imparare cosa significhino quegli asterischi: adesso una parola in grassetto si
+ * vede in grassetto, un link si vede come un link. Il FILE resta markdown — è il formato dei
+ * contenuti, lo legge Hugo — e la conversione nei due sensi vive in `prose.ts`, provata sui
+ * testi veri del sito (`test/prose-roundtrip.test.js`).
+ *
+ * Il prezzo, dichiarato: un `contenteditable` è un pezzo di DOM che l'utente modifica
+ * direttamente, quindi il testo deve essere riletto da lì a ogni battuta e ritradotto. È la cosa
+ * che questo componente fa, e l'unica ragione per cui esiste.
+ *
+ * ── Il valore fuori e il DOM dentro ────────────────────────────────────────────────────────
+ * Il DOM NON si riscrive a ogni render: si tocca solo quando il valore che arriva da fuori dice
+ * qualcosa di diverso da quello che c'è dentro (confronto fra markdown, non fra HTML). Scrivere
+ * `innerHTML` a ogni battuta rimonterebbe i nodi sotto il cursore, che salterebbe alla fine del
+ * campo a ogni lettera — il difetto classico di questo tipo di editor.
+ *
+ * ── Le decisioni ───────────────────────────────────────────────────────────────────────────
+ * - **Si incolla come testo semplice.** Copiando da un elaboratore di testi arriverebbe HTML
+ *   con font, colori e classi: `htmlToMd` lo attraverserebbe comunque, ma tanto vale non farlo
+ *   entrare. Quello che si vuole incollando è il testo.
+ * - **I comandi li esegue il browser** (`execCommand`), non il nostro codice. È un'API
+ *   deprecata e lo sappiamo; è anche l'unica che spezza e ricuce i nodi di una selezione
+ *   qualunque senza che si debba scrivere un editor. Il risultato passa comunque da `htmlToMd`,
+ *   che accetta sia `<b>` sia `<strong>` proprio perché i browser non concordano su quale usare.
+ * - **`maxLength` si applica prima dell'inserimento** (`beforeinput`), non tagliando dopo:
+ *   troncare un testo già scritto è il modo di far sparire una frase senza dirlo.
+ */
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
+import { htmlToMd, mdToHtml } from "../../prose.js";
+import { ProseBar } from "./ProseBar.js";
+function linkAt(node, root) {
+    for (let cursor = node; cursor && cursor !== root; cursor = cursor.parentNode) {
+        if (cursor.tagName === "A")
+            return cursor.getAttribute("href");
+    }
+    return null;
+}
+export function ProseField({ value, onChange, className, rows = 6, placeholder, maxLength }) {
+    const ref = useRef(null);
+    const [spot, setSpot] = useState(null);
+    const [marks, setMarks] = useState({ bold: false, italic: false, href: null });
+    /* Mentre il dialogo del collegamento è aperto il campo NON ha il fuoco: la selezione va
+       tenuta in vita, altrimenti al momento di scrivere il link non c'è più niente di selezionato. */
+    const holding = useRef(false);
+    const held = useRef(null);
+    /* Il DOM si riallinea al valore esterno solo quando i due dicono cose diverse. Il confronto è
+       fra MARKDOWN: `mdToHtml(value)` e l'HTML attuale differiscono quasi sempre per dettagli che
+       non cambiano il testo (un `<b>` invece di `<strong>`, un `<div>` invece di un `<p>`), e
+       confrontare quelli vorrebbe dire riscrivere il campo di continuo. */
+    useLayoutEffect(() => {
+        const field = ref.current;
+        if (!field)
+            return;
+        if (htmlToMd(field.innerHTML) === value)
+            return;
+        field.innerHTML = mdToHtml(value);
+    }, [value]);
+    const readSelection = useCallback(() => {
+        const field = ref.current;
+        if (!field || holding.current)
+            return;
+        const selection = document.getSelection();
+        if (!selection || !selection.rangeCount || !field.contains(selection.anchorNode)) {
+            setSpot(null);
+            return;
+        }
+        const range = selection.getRangeAt(0);
+        if (range.collapsed) {
+            // Niente di selezionato: niente barra. Lo stato dei comandi serve solo quando c'è.
+            setSpot(null);
+            return;
+        }
+        /* Il PRIMO rettangolo: una selezione su tre righe ne ha tre, e la barra va sopra la prima
+           riga — non sopra la media delle tre. */
+        const rects = range.getClientRects();
+        const first = rects[0] ?? range.getBoundingClientRect();
+        const box = field.getBoundingClientRect();
+        if (first.bottom < box.top || first.top > box.bottom) {
+            setSpot(null); // selezione scorsa fuori dal campo: non c'è niente da sormontare
+            return;
+        }
+        setSpot({
+            x: first.left + first.width / 2,
+            top: Math.max(first.top, box.top),
+            bottom: Math.min(first.bottom, box.bottom),
+        });
+        setMarks({
+            bold: document.queryCommandState("bold"),
+            italic: document.queryCommandState("italic"),
+            href: linkAt(selection.anchorNode, field),
+        });
+    }, []);
+    /* `selectionchange` sta sul documento — non esiste un evento di selezione sull'elemento — e
+       scorrendo la barra segue la selezione o sparisce con lei. */
+    useEffect(() => {
+        const update = () => readSelection();
+        document.addEventListener("selectionchange", update);
+        addEventListener("scroll", update, true);
+        addEventListener("resize", update);
+        return () => {
+            document.removeEventListener("selectionchange", update);
+            removeEventListener("scroll", update, true);
+            removeEventListener("resize", update);
+        };
+    }, [readSelection]);
+    const publish = () => {
+        const field = ref.current;
+        if (!field)
+            return;
+        onChange(htmlToMd(field.innerHTML));
+    };
+    /* Il comando agisce sulla selezione che c'era prima che il dialogo prendesse il fuoco: la si
+       rimette prima di eseguirlo, altrimenti `execCommand` non trova niente su cui lavorare. */
+    const restore = () => {
+        const field = ref.current;
+        const range = held.current;
+        if (!field || !range)
+            return;
+        field.focus();
+        const selection = document.getSelection();
+        selection?.removeAllRanges();
+        selection?.addRange(range);
+    };
+    const run = (command, argument) => {
+        restore();
+        document.execCommand(command, false, argument);
+        publish();
+        readSelection();
+    };
+    const empty = !value.trim();
+    return (_jsxs(_Fragment, { children: [_jsx("div", { ref: ref, className: [className, "ak-prose-field", empty ? "is-empty" : ""].filter(Boolean).join(" "), contentEditable: true, suppressContentEditableWarning: true, role: "textbox", "aria-multiline": "true", "data-placeholder": placeholder, style: { minHeight: `${rows * 1.75}em` }, onInput: publish, onBlur: () => { if (!holding.current)
+                    setSpot(null); }, onPaste: (event) => {
+                    event.preventDefault();
+                    const text = event.clipboardData.getData("text/plain");
+                    if (text)
+                        document.execCommand("insertText", false, text);
+                }, onBeforeInput: (event) => {
+                    if (!maxLength || !ref.current)
+                        return;
+                    const inserting = !String(event.inputType ?? "").startsWith("delete");
+                    if (inserting && htmlToMd(ref.current.innerHTML).length >= maxLength)
+                        event.preventDefault();
+                } }), spot && (_jsx(ProseBar, { spot: spot, bold: marks.bold, italic: marks.italic, href: marks.href, onBold: () => run("bold"), onItalic: () => run("italic"), onLink: (href) => run("createLink", href), onUnlink: () => run("unlink"), onHold: (value_) => {
+                    holding.current = value_;
+                    const selection = document.getSelection();
+                    held.current = value_ && selection?.rangeCount ? selection.getRangeAt(0).cloneRange() : null;
+                } }))] }));
+}

package/dist/form/prose/pages.d.ts

@@ -0,0 +1,6 @@
+/** Una destinazione interna: come si chiama e dove porta. */
+export interface ProsePageLink {
+    label: string;
+    href: string;
+}
+export declare const ProsePages: import("react").Context<ProsePageLink[]>;

package/dist/form/prose/pages.js

@@ -0,0 +1,13 @@
+/* Le pagine a cui un link può puntare.
+ *
+ * Un contesto e non una prop: la barra di formattazione compare dentro widget annidati anche di
+ * tre livelli (le card di un lavoro, i blocchi di un'edizione), e farsi passare l'elenco di mano
+ * in mano vorrebbe dire aggiungere un parametro a ogni componente attraversato — compresi quelli
+ * che con i link non c'entrano niente.
+ *
+ * Il valore predefinito è l'elenco vuoto, e non è un ripiego: significa che la scheda «Pagina»
+ * dice che non ci sono pagine invece di rompersi. Un form montato fuori dal pannello (un test,
+ * un altro contesto) continua a funzionare, senza link interni.
+ */
+import { createContext } from "react";
+export const ProsePages = createContext([]);

package/dist/form/registry.d.ts

@@ -0,0 +1,20 @@
+import type { UiMeta } from "../registries.js";
+import type { AssetFile } from "../api.js";
+export interface FieldProps {
+    name: string;
+    meta: UiMeta;
+    value: unknown;
+    onChange: (v: unknown) => void;
+    error?: string;
+    /** Aperto dai widget che scelgono media e vogliono solo il percorso (r2Image, r2Gallery). */
+    pickMedia?: (opts: {
+        multiple: boolean;
+    }) => Promise<string[] | null>;
+    pickMediaFiles?: (opts: {
+        multiple: boolean;
+    }) => Promise<AssetFile[] | null>;
+}
+export type FieldComponent = (props: FieldProps) => React.ReactElement | null;
+export declare function registerField(widget: string, comp: FieldComponent): void;
+export declare function fieldFor(widget: string): FieldComponent;
+export declare function knownWidgets(): string[];

package/dist/form/registry.js

@@ -0,0 +1,15 @@
+const REGISTRY = new Map();
+export function registerField(widget, comp) {
+    REGISTRY.set(widget, comp);
+}
+export function fieldFor(widget) {
+    const c = REGISTRY.get(widget);
+    if (!c) {
+        throw new Error(`Widget "${widget}" non registrato. I widget disponibili sono: ${[...REGISTRY.keys()].join(", ")}. ` +
+            `Se ne serve uno nuovo va aggiunto a adminkit — così lo ottengono tutti i siti.`);
+    }
+    return c;
+}
+export function knownWidgets() {
+    return [...REGISTRY.keys()].sort();
+}

package/dist/frontmatter.d.ts

@@ -0,0 +1,20 @@
+/** Un blocco = una chiave di primo livello con tutte le righe che le appartengono:
+ *  i commenti che la precedono, la riga stessa, e le righe indentate o di lista che seguono. */
+export type FmBlock = {
+    key: string;
+    lines: string[];
+};
+/** Separa front matter e corpo. `fm` è null se il file non ne ha uno. */
+export declare function splitFrontMatter(md: string | null | undefined): {
+    fm: string | null;
+    body: string | null;
+};
+/** Spezza il front matter in blocchi, nell'ordine in cui compaiono. */
+export declare function parseBlocks(fm: string | null): FmBlock[];
+/** I blocchi che lo schema NON gestisce, da ricopiare tali e quali.
+ *  È l'invariante del merge: ciò che l'admin non conosce sopravvive per costruzione. */
+export declare function keptBlocks(fm: string | null, managed: ReadonlySet<string>): FmBlock[];
+export declare function trimTrailingBlank(lines: string[]): string[];
+export declare function replaceKeyLine(lines: string[], key: string, newLine: string): string[];
+export type RawFm = Record<string, unknown>;
+export declare function parseRawFm(fm: string | null): RawFm;

package/dist/frontmatter.js

@@ -0,0 +1,202 @@
+/* Lettura del front matter dei file di contenuto.
+ *
+ * NON è un parser YAML, ed è deliberato. Un parser vero perde due cose che qui contano più
+ * della correttezza formale: i COMMENTI e l'ORDINE delle chiavi. I file di contenuto sono
+ * scritti e riletti da persone, e un campo senza la riga che lo spiega è un campo che qualcuno
+ * romperà. Qui serve solo decidere quali righe tenere e quali rigenerare, e la struttura di
+ * questi file è piatta e la scriviamo noi.
+ *
+ * Il codice viene da functions/admin/api/pages.js, dove ha già retto due incidenti; è spostato
+ * con la stessa logica, non riscritto. L'unica differenza è che `keptFrontMatter` non chiude
+ * più su una costante di modulo ma riceve l'insieme delle chiavi gestite, che ora è DERIVATO
+ * dallo schema (vedi serialize.ts).
+ */
+const FM_RE = /^---\n([\s\S]*?)\n---/;
+/** Separa front matter e corpo. `fm` è null se il file non ne ha uno. */
+export function splitFrontMatter(md) {
+    if (!md)
+        return { fm: null, body: null };
+    const m = md.match(FM_RE);
+    if (!m)
+        return { fm: null, body: md };
+    const after = md.match(/^---\n[\s\S]*?\n---\n?([\s\S]*)$/);
+    return { fm: m[1], body: after ? after[1] : null };
+}
+/** Spezza il front matter in blocchi, nell'ordine in cui compaiono. */
+export function parseBlocks(fm) {
+    if (!fm)
+        return [];
+    const blocks = [];
+    let cur = null;
+    let pending = [];
+    for (const line of fm.split("\n")) {
+        if (/^\s*$/.test(line)) {
+            if (cur)
+                cur.lines.push(line);
+            else
+                pending.push(line);
+            continue;
+        }
+        // Un commento appartiene a ciò che SEGUE: è lì per spiegare la chiave sotto di sé.
+        if (/^\s*#/.test(line)) {
+            pending.push(line);
+            continue;
+        }
+        const top = line.match(/^([A-Za-z_][\w-]*)\s*:/);
+        if (top) {
+            cur = { key: top[1], lines: pending.concat([line]) };
+            pending = [];
+            blocks.push(cur);
+        }
+        else if (cur) {
+            cur.lines.push(line); // riga indentata o elemento di lista
+        }
+    }
+    return blocks;
+}
+/** I blocchi che lo schema NON gestisce, da ricopiare tali e quali.
+ *  È l'invariante del merge: ciò che l'admin non conosce sopravvive per costruzione. */
+export function keptBlocks(fm, managed) {
+    return parseBlocks(fm)
+        .filter((b) => !managed.has(b.key))
+        // via le righe vuote in coda, che altrimenti si accumulerebbero a ogni salvataggio
+        .map((b) => ({ key: b.key, lines: trimTrailingBlank(b.lines) }));
+}
+export function trimTrailingBlank(lines) {
+    const out = lines.slice();
+    while (out.length && /^\s*$/.test(out[out.length - 1]))
+        out.pop();
+    return out;
+}
+/* Sostituisce la riga della CHIAVE dentro un blocco, lasciando dov'erano i commenti che la
+ * precedono e le righe indentate che la seguono. Serve a cambiare un valore senza rimuovere la
+ * sua documentazione — saltare il blocco e riemettere la chiave altrove costava esattamente
+ * quei commenti, ed è stato un bug vero. */
+/* Sostituisce la RIGA di una chiave dentro il suo blocco, lasciando al loro posto i commenti
+ * che la precedono e le righe vuote che la seguono.
+ *
+ * Le righe INDENTATE subito sotto la chiave appartengono al suo vecchio valore e vanno via con
+ * esso. Non era così, e il caso si vedeva solo passando da un valore su più righe a uno su una
+ * riga sola — che succede la prima volta che si tolgono tutte le foto da una gallery:
+ *
+ *     images:                  ->   images: []
+ *       - src: "…"                    - src: "…"      <- orfane
+ *         w: 1708                       w: 1708
+ *
+ * cioè front matter rotto, scritto sul repo. Un valore scalare non ha righe indentate sotto di
+ * sé, quindi per tutti gli altri campi non cambia niente. */
+export function replaceKeyLine(lines, key, newLine) {
+    const re = new RegExp(`^${key}\\s*:`);
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (!re.test(lines[i])) {
+            out.push(lines[i]);
+            continue;
+        }
+        out.push(newLine);
+        // Le righe vuote NON si saltano: separano le sezioni e vanno conservate, o il file non si
+        // riprodurrebbe uguale e la guardia di fedeltà rifiuterebbe il salvataggio.
+        while (i + 1 < lines.length && /^\s+\S/.test(lines[i + 1]))
+            i++;
+    }
+    return out;
+}
+function tokenize(fm) {
+    const out = [];
+    for (const l of fm.split("\n")) {
+        if (/^\s*$/.test(l) || /^\s*#/.test(l))
+            continue; // vuote e commenti non portano dati
+        out.push({ indent: l.match(/^ */)[0].length, text: l.trim() });
+    }
+    return out;
+}
+const KV = /^([A-Za-z_][\w-]*)\s*:\s*(.*)$/;
+function parseMap(t, i, indent) {
+    const out = {};
+    while (i < t.length && t[i].indent >= indent) {
+        if (t[i].indent > indent) {
+            i++;
+            continue;
+        } // riga orfana: si salta
+        const m = t[i].text.match(KV);
+        if (!m)
+            break;
+        const key = m[1], inline = m[2].trim();
+        if (inline !== "") {
+            out[key] = scalar(inline);
+            i++;
+            continue;
+        }
+        i++; // il valore sta nel blocco indentato che segue
+        if (i < t.length && t[i].indent > indent) {
+            if (t[i].text.startsWith("-")) {
+                const [list, ni] = parseList(t, i, t[i].indent);
+                out[key] = list;
+                i = ni;
+            }
+            else {
+                const [map, ni] = parseMap(t, i, t[i].indent);
+                out[key] = map;
+                i = ni;
+            }
+        }
+        else {
+            out[key] = ""; // chiave senza valore né blocco
+        }
+    }
+    return [out, i];
+}
+function parseList(t, i, indent) {
+    const out = [];
+    while (i < t.length && t[i].indent === indent && t[i].text.startsWith("-")) {
+        const rest = t[i].text.replace(/^-\s*/, "");
+        const kv = rest.match(KV);
+        if (kv) {
+            // Elemento-mappa: la PRIMA chiave sta sulla riga del trattino, le altre sotto e più
+            // indentate. È la forma che emette toYamlLines.
+            const item = {};
+            item[kv[1]] = kv[2].trim() === "" ? "" : scalar(kv[2].trim());
+            i++;
+            if (i < t.length && t[i].indent > indent) {
+                const [more, ni] = parseMap(t, i, t[i].indent);
+                Object.assign(item, more);
+                i = ni;
+            }
+            out.push(item);
+        }
+        else {
+            out.push(scalar(rest));
+            i++;
+        }
+    }
+    return [out, i];
+}
+export function parseRawFm(fm) {
+    if (!fm)
+        return {};
+    return parseMap(tokenize(fm), 0, 0)[0];
+}
+function scalar(s) {
+    if (s === "[]")
+        return [];
+    if (s === "true")
+        return true;
+    if (s === "false")
+        return false;
+    if (s === "null" || s === "~")
+        return null;
+    if (/^-?\d+(\.\d+)?$/.test(s))
+        return Number(s);
+    const dq = s.match(/^"([\s\S]*)"$/);
+    if (dq) {
+        // Un solo passaggio da sinistra a destra, non due replace in fila: con `\\"` due passaggi
+        // sequenziali si scambiano l'ordine e restituiscono la stringa sbagliata. È il verso
+        // opposto di quello che fa yamlStr, e i due devono combaciare esattamente o un titolo con
+        // backslash e virgolette non sopravvive al giro.
+        return dq[1].replace(/\\(["\\])/g, "$1");
+    }
+    const sq = s.match(/^'([\s\S]*)'$/);
+    if (sq)
+        return sq[1].replace(/''/g, "'"); // in YAML gli apici singoli si raddoppiano
+    return s;
+}

package/dist/functions/_middleware.js

@@ -0,0 +1,101 @@
+/* Guardia di /admin/* — pagina E API.
+ *
+ * Prima non c'era: l'unico riferimento ad Access nel codice era la lettura dell'header
+ * `Cf-Access-Authenticated-User-Email` in api/pages.js, usata solo per firmare il commit. Un
+ * header si scrive a mano con curl, quindi tutta la sicurezza stava nella configurazione
+ * dell'edge: se una policy non copriva un hostname (ogni deploy di preview è un hostname
+ * nuovo), `/admin/api/*` era aperto a chiunque — cioè scrittura sul repo e cancellazione su R2.
+ *
+ * Qui il JWT di Access viene VERIFICATO davvero, contro le chiavi pubbliche del tenant. Access
+ * resta la prima linea, questa diventa la seconda: una policy sbagliata non è più sufficiente.
+ *
+ * Vale per tutto ciò che sta sotto /admin/, compresi gli asset statici del pannello: il file
+ * si chiama `_middleware` e sta in `functions/admin/`, quindi Pages lo applica all'intero
+ * sottoalbero della rotta.
+ */
+import cloudflareAccessPlugin from "@cloudflare/pages-plugin-cloudflare-access";
+
+export const adminAccess = async (context) => {
+  const { env, next, request } = context;
+
+  // Anteprima locale: qui Access non esiste, e senza questa via d'uscita il plugin manderebbe
+  // al login per `localhost` — che Access rifiuta ("Invalid redirect URL").
+  // Va valutata PER PRIMA. Annidarla dentro il ramo "variabili mancanti" (com'era) funziona
+  // solo finché quelle variabili sono vuote: riempite, il ramo diventa irraggiungibile e
+  // l'anteprima locale si rompe senza che in produzione si veda niente.
+  // DUE condizioni, non una: il flag E un hostname locale. Il flag lo passa il comando
+  // wrangler dichiarato in `regia.json` (--binding ADMIN_LOCAL=1) e non sta in wrangler.toml,
+  // ma essendo questo ora il primo controllo del middleware, non voglio che una riga copiata
+  // per sbaglio fra le vars di un progetto basti ad aprire l'admin sull'hostname vero.
+  // Effetto collaterale utile: quando Regia espone l'anteprima sulla rete locale, dal telefono
+  // si vede il sito ma NON il pannello, perche' 192.168.x.x e nome.local non sono hostname
+  // locali. E' voluto.
+  const host = new URL(request.url).hostname;
+  const isLocalHost = host === "localhost" || host === "127.0.0.1" || host.endsWith(".localhost");
+
+  /* Le credenziali di Access viaggiano in COOKIE, e un cookie il browser lo manda da solo —
+   * anche quando la richiesta parte da un'altra pagina. Senza questo controllo, un sito
+   * qualunque aperto in un'altra scheda può far partire una POST verso `/admin/api/*` e la
+   * sessione già aperta la autentica: cancellare foto, riscrivere pagine, pubblicare.
+   *
+   * Il controllo sta PRIMA della via d'uscita locale di proposito: in locale non c'è Access,
+   * ma non c'è neanche una ragione per cui una mutazione debba arrivare da un'altra origine, e
+   * un controllo che vale solo in produzione è un controllo che non si prova mai.
+   *
+   * `Sec-Fetch-Site` si verifica solo se presente: i browser che non lo mandano restano coperti
+   * dal confronto sull'`Origin`. */
+  const method = request.method.toUpperCase();
+  const isMutation = !["GET", "HEAD", "OPTIONS"].includes(method);
+  if (isMutation && new URL(request.url).pathname.startsWith("/admin/api/")) {
+    const origin = request.headers.get("Origin");
+    const fetchSite = request.headers.get("Sec-Fetch-Site");
+    if (origin !== new URL(request.url).origin || (fetchSite && fetchSite !== "same-origin")) {
+      return new Response(
+        JSON.stringify({ ok: false, error: "Origine della richiesta non valida.", code: "forbidden_origin" }),
+        { status: 403, headers: { "Content-Type": "application/json" } },
+      );
+    }
+  }
+
+  if (env.ADMIN_LOCAL === "1" && isLocalHost) return next();
+
+  // FALLIRE CHIUSO. La forma sbagliata, e la ragione per cui non è scritta così, è:
+  //     if (env.CF_ACCESS_AUD) proteggi(); else next();
+  // con quella, dimenticare una variabile su un progetto Pages non dà un errore: dà un admin
+  // pubblico, silenzioso e indistinguibile da uno funzionante. Meglio un 503 evidente.
+  if (!env.CF_ACCESS_AUD || !env.CF_ACCESS_DOMAIN) {
+    return new Response(
+      "Admin non configurato: mancano CF_ACCESS_DOMAIN e CF_ACCESS_AUD fra le [vars] di wrangler.toml.",
+      { status: 503, headers: { "Content-Type": "text/plain; charset=utf-8" } }
+    );
+  }
+
+  const res = await cloudflareAccessPlugin({
+    domain: env.CF_ACCESS_DOMAIN,
+    aud: env.CF_ACCESS_AUD,
+  })(context);
+
+  // Il plugin non risponde 403 come dice la sua documentazione: REINDIRIZZA al login di Access
+  // (302), e lo fa anche sulle chiamate API. Verificato, non dedotto.
+  // Per una pagina è il comportamento giusto — si finisce sulla schermata di login. Per
+  // `/admin/api/*` no: il `fetch()` dell'admin seguirebbe il redirect cross-origin verso
+  // cloudflareaccess.com e riceverebbe HTML, così una sessione SCADUTA si presenterebbe
+  // all'utente come "backend non collegato" — che è un'altra cosa e porta a cercare il guasto
+  // nel posto sbagliato. Qui SOLTANTO il redirect verso il tenant Access diventa un 401 JSON:
+  // i redirect applicativi (OAuth Google e ritorno al pannello) devono invece attraversare
+  // il middleware intatti.
+  const isApi = new URL(context.request.url).pathname.startsWith("/admin/api/");
+  const location = res.headers.get("Location") || "";
+  let accessRedirect = false;
+  try {
+    accessRedirect = !!location &&
+      new URL(location, context.request.url).hostname === new URL(env.CF_ACCESS_DOMAIN).hostname;
+  } catch { /* un Location malformato non è un redirect di Access affidabile */ }
+  if (isApi && res.status >= 300 && res.status < 400 && accessRedirect) {
+    return new Response(
+      JSON.stringify({ ok: false, error: "Sessione scaduta: ricarica la pagina per rientrare.", code: "unauthenticated" }),
+      { status: 401, headers: { "Content-Type": "application/json" } }
+    );
+  }
+  return res;
+};