@cardinali-studio/adminkit 1.0.0

package/dist/functions/_shared/exif.js

@@ -0,0 +1,53 @@
+/* Estrazione minimale della data di scatto (EXIF DateTimeOriginal, tag 0x9003)
+ * dai JPEG. Nessuna dipendenza. Ritorna una stringa ISO (senza timezone) o null.
+ * Usato all'upload per permettere l'ordinamento "Data scatto".
+ */
+export function extractCapturedAt(arrayBuffer) {
+  try {
+    const dv = new DataView(arrayBuffer);
+    if (dv.byteLength < 4 || dv.getUint16(0) !== 0xffd8) return null; // non JPEG
+    const len = dv.byteLength;
+    let offset = 2;
+    while (offset + 4 < len) {
+      if (dv.getUint8(offset) !== 0xff) break;
+      const marker = dv.getUint8(offset + 1);
+      const size = dv.getUint16(offset + 2);
+      if (marker === 0xe1) {
+        // APP1: verifica "Exif\0\0"
+        const app1 = offset + 4;
+        if (dv.getUint32(app1) !== 0x45786966) return null; // "Exif"
+        const tiff = app1 + 6;
+        const little = dv.getUint16(tiff) === 0x4949;
+        const g16 = (o) => dv.getUint16(o, little);
+        const g32 = (o) => dv.getUint32(o, little);
+        const ifd0 = tiff + g32(tiff + 4);
+        // ExifIFD pointer (0x8769) in IFD0
+        let exifIFD = 0;
+        const n0 = g16(ifd0);
+        for (let i = 0; i < n0; i++) {
+          const e = ifd0 + 2 + i * 12;
+          if (g16(e) === 0x8769) { exifIFD = tiff + g32(e + 8); break; }
+        }
+        if (!exifIFD) return null;
+        // DateTimeOriginal (0x9003) nell'Exif IFD
+        const n1 = g16(exifIFD);
+        for (let i = 0; i < n1; i++) {
+          const e = exifIFD + 2 + i * 12;
+          if (g16(e) === 0x9003) {
+            const valOff = tiff + g32(e + 8);
+            let s = "";
+            for (let j = 0; j < 19 && valOff + j < len; j++) s += String.fromCharCode(dv.getUint8(valOff + j));
+            const m = s.match(/^(\d{4}):(\d{2}):(\d{2}) (\d{2}):(\d{2}):(\d{2})/);
+            return m ? `${m[1]}-${m[2]}-${m[3]}T${m[4]}:${m[5]}:${m[6]}` : null;
+          }
+        }
+        return null;
+      }
+      if (marker === 0xda) break; // SOS: inizio dati immagine
+      offset += 2 + size;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}

package/dist/functions/_shared/github.js

@@ -0,0 +1,138 @@
+/* Helper GitHub API condivisi (lettura contenuti + commit atomico).
+ * Usati dagli endpoint Assets per l'avviso "in uso" e la pulizia riferimenti.
+ * Richiede env.GITHUB_TOKEN, env.GITHUB_REPO, env.GITHUB_BRANCH.
+ */
+const GH = "https://api.github.com";
+
+export function gh(env, path, init = {}) {
+  return fetch(GH + path, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${env.GITHUB_TOKEN}`,
+      Accept: "application/vnd.github+json",
+      "User-Agent": "adminkit",
+      "X-GitHub-Api-Version": "2022-11-28",
+      ...(init.headers || {}),
+    },
+  });
+}
+
+/* IL BRANCH SU CUI LAVORA L'ADMIN. Non è quello pubblicato: salvare dal pannello scrive qui e
+ * non fa partire nessuna build, mentre il sito online resta fermo finché non si preme
+ * «Pubblica». Vedi `functions/admin/api/publish.js`. */
+export function repoBranch(env) {
+  return { repo: env.GITHUB_REPO, branch: env.GITHUB_BRANCH || DRAFT };
+}
+
+/* I due nomi sono separati apposta: erano lo stesso letterale `"main"` usato con due
+ * significati — «dove scrive l'admin» e «cosa è online» — e finché coincidevano non c'era modo
+ * di accorgersi di quale dei due si stesse parlando. */
+export const DRAFT = "bozza";
+export const PROD = "main";
+
+/** Il branch PUBBLICATO: lo tocca solo la pubblicazione, mai un salvataggio. */
+export function prodBranch(env) {
+  return env.PROD_BRANCH || PROD;
+}
+
+export class GitHubConflictError extends Error {
+  constructor(message = "Il sito è stato modificato mentre salvavi. Riprova.") {
+    super(message);
+    this.name = "GitHubConflictError";
+    this.code = "conflict";
+  }
+}
+
+/** SHA del blob Git che conterrà esattamente questo testo. Evita di rileggere il branch dopo
+ * un commit: un'altra sessione potrebbe averlo già fatto avanzare. */
+export async function gitBlobSha(content) {
+  const bytes = new TextEncoder().encode(String(content));
+  const header = new TextEncoder().encode(`blob ${bytes.byteLength}\0`);
+  const input = new Uint8Array(header.byteLength + bytes.byteLength);
+  input.set(header, 0);
+  input.set(bytes, header.byteLength);
+  const digest = await crypto.subtle.digest("SHA-1", input);
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+async function responseJson(res, context) {
+  if (!res.ok) throw new Error(`${context} ${res.status}: ${await res.text()}`);
+  return res.json();
+}
+
+export async function getBase(env) {
+  const { repo, branch } = repoBranch(env);
+  const r = await gh(env, `/repos/${repo}/git/ref/heads/${branch}`);
+  const commitSha = (await responseJson(r, "ref")).object.sha;
+  const c = await gh(env, `/repos/${repo}/git/commits/${commitSha}`);
+  const treeSha = (await responseJson(c, "commit")).tree.sha;
+  return { commitSha, treeSha };
+}
+
+/** Snapshot coerente del branch: albero e file letti dopo useranno questo stesso commit. */
+export async function getRepoSnapshot(env) {
+  const { repo } = repoBranch(env);
+  const base = await getBase(env);
+  const { treeSha } = base;
+  const t = await gh(env, `/repos/${repo}/git/trees/${treeSha}?recursive=1`);
+  const body = await responseJson(t, "tree");
+  if (body.truncated) {
+    throw new Error("L'albero GitHub è troncato: non posso verificare tutti i riferimenti media.");
+  }
+  return { ...base, tree: body.tree || [] };
+}
+
+// Elenca i path dei file pagina (content/<slug>/index.md).
+export async function listIndexPaths(env) {
+  const snapshot = await getRepoSnapshot(env);
+  return snapshot.tree
+    .filter((x) => x.type === "blob" && /^content\/[^/]+\/index\.md$/.test(x.path))
+    .map((x) => x.path);
+}
+
+// Legge il testo di un file dal repo (o null).
+export async function getText(env, path, ref) {
+  const { repo, branch } = repoBranch(env);
+  const r = await gh(env, `/repos/${repo}/contents/${path}?ref=${encodeURIComponent(ref || branch)}`);
+  if (r.status === 404) return null;
+  const j = await responseJson(r, `file ${path}`);
+  if (j.encoding !== "base64" || typeof j.content !== "string") {
+    throw new Error(`file ${path}: contenuto GitHub non disponibile in base64`);
+  }
+  const raw = atob((j.content || "").replace(/\n/g, ""));
+  const bytes = Uint8Array.from(raw, (c) => c.charCodeAt(0));
+  try { return new TextDecoder("utf-8", { fatal: true }).decode(bytes); }
+  catch { throw new Error(`file ${path}: testo UTF-8 non valido`); }
+}
+
+// Legge in parallelo tutti i file pagina: [{ path, text }].
+export async function readAllPages(env) {
+  const snapshot = await getRepoSnapshot(env);
+  const paths = snapshot.tree
+    .filter((x) => x.type === "blob" && /^content\/[^/]+\/index\.md$/.test(x.path))
+    .map((x) => x.path);
+  const pages = await Promise.all(paths.map(async (p) => {
+    const text = await getText(env, p, snapshot.commitSha);
+    if (text == null) throw new Error(`file ${p}: presente nell'albero ma non leggibile`);
+    return { path: p, text };
+  }));
+  return pages;
+}
+
+// Commit atomico di più file (upsert) in un solo commit → un solo rebuild.
+export async function commitUpserts(env, message, files, options = {}) {
+  if (!files.length) return null;
+  const { repo, branch } = repoBranch(env);
+  const { commitSha, treeSha } = options.base || await getBase(env);
+  const tree = files.map((f) => ({ path: f.path, mode: "100644", type: "blob", content: f.content }));
+  const nt = await gh(env, `/repos/${repo}/git/trees`, { method: "POST", body: JSON.stringify({ base_tree: treeSha, tree }) });
+  if (!nt.ok) throw new Error(`tree ${nt.status}: ${await nt.text()}`);
+  const newTree = (await nt.json()).sha;
+  const nc = await gh(env, `/repos/${repo}/git/commits`, { method: "POST", body: JSON.stringify({ message, tree: newTree, parents: [commitSha] }) });
+  if (!nc.ok) throw new Error(`commit ${nc.status}: ${await nc.text()}`);
+  const newCommit = (await nc.json()).sha;
+  const pr = await gh(env, `/repos/${repo}/git/refs/heads/${branch}`, { method: "PATCH", body: JSON.stringify({ sha: newCommit }) });
+  if (pr.status === 422) throw new GitHubConflictError();
+  if (!pr.ok) throw new Error(`ref ${pr.status}: ${await pr.text()}`);
+  return newCommit;
+}

package/dist/functions/_shared/imagesize.js

@@ -0,0 +1,101 @@
+/* Larghezza e altezza di un'immagine, lette dall'INTESTAZIONE del file.
+ *
+ * Perché servono: la griglia delle gallery riserva l'ingombro esatto di ogni cella prima che
+ * l'immagine arrivi (--ar e --span in gallery.css). Senza le dimensioni le celle avrebbero
+ * proporzioni stimate e il layout si riassesterebbe man mano che le foto si caricano — su un
+ * centinaio di immagini è una griglia che balla sotto le dita mentre si scorre.
+ *
+ * Si legge solo l'inizio del file, non l'immagine intera: WebP e PNG tengono le dimensioni
+ * entro i primi 32 byte. JPEG no — vanno cercate scorrendo i marker, e con l'EXIF davanti
+ * possono stare parecchio più avanti, quindi per quelli si legge un blocco più grande.
+ *
+ * Se il formato non è fra quelli che sappiamo leggere si torna `null`: chi chiama ripiega
+ * sulle proporzioni di default invece di rompersi. Un file illeggibile non deve poter far
+ * fallire il caricamento o l'elenco di un'intera cartella.
+ *
+ * Questo codice viveva dentro functions/api/gallery/[section].js, che calcolava le dimensioni
+ * a OGNI richiesta. Ora si calcolano una volta sola, al caricamento, e finiscono nei metadati
+ * dell'oggetto R2 (vedi admin/api/assets/upload.js).
+ */
+
+/** Dimensioni da un buffer già in memoria (il caso del caricamento).
+ *  @returns {[number, number] | null} */
+export function sizeFromBuffer(buffer) {
+  try {
+    const u8 = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    return parseSize(u8, u8);
+  } catch {
+    return null;
+  }
+}
+
+/** Dimensioni di un oggetto già nel bucket, leggendone solo i primi byte.
+ *  @returns {Promise<[number, number] | null>} */
+export async function sizeFromBucket(bucket, key) {
+  try {
+    const head = await readRange(bucket, key, 0, 32);
+    if (!head) return null;
+    // Il JPEG è l'unico che può richiedere più dei 32 byte iniziali: glieli si dà solo se
+    // serve davvero, così per WebP e PNG resta una lettura sola e minuscola.
+    if (head[0] === 0xff && head[1] === 0xd8) {
+      const big = await readRange(bucket, key, 0, 65536);
+      return big ? parseSize(head, big) : null;
+    }
+    return parseSize(head, head);
+  } catch {
+    return null;
+  }
+}
+
+/* `head` sono i primi byte (bastano a PNG e WebP), `full` il blocco più grande che serve al
+ * JPEG. Nel caso del buffer in memoria sono lo stesso array. */
+function parseSize(head, full) {
+  if (head.length < 16) return null;
+
+  // PNG: firma + IHDR, larghezza e altezza a 16 e 20 (big-endian, 4 byte).
+  if (head[0] === 0x89 && head[1] === 0x50) {
+    const dv = view(head);
+    return [dv.getUint32(16), dv.getUint32(20)];
+  }
+
+  // WebP: contenitore RIFF, il tipo di chunk sta a 12. Tre varianti, tre posizioni.
+  if (head[8] === 0x57 && head[9] === 0x45 && head[10] === 0x42 && head[11] === 0x50) {
+    const chunk = String.fromCharCode(head[12], head[13], head[14], head[15]);
+    const dv = view(head);
+    if (chunk === "VP8X" && head.length >= 30) {   // esteso: 3 byte per lato, meno uno
+      return [1 + (head[24] | (head[25] << 8) | (head[26] << 16)),
+              1 + (head[27] | (head[28] << 8) | (head[29] << 16))];
+    }
+    if (chunk === "VP8L" && head.length >= 25) {   // lossless: 14 bit per lato, impacchettati
+      const n = dv.getUint32(21, true);
+      return [1 + (n & 0x3fff), 1 + ((n >> 14) & 0x3fff)];
+    }
+    if (chunk === "VP8 " && head.length >= 30) {   // lossy: 14 bit per lato dopo il sync code
+      return [dv.getUint16(26, true) & 0x3fff, dv.getUint16(28, true) & 0x3fff];
+    }
+    return null;
+  }
+
+  // JPEG: si scorrono i marker fino a un SOF (0xC0..0xCF, esclusi i tre che non lo sono).
+  if (head[0] === 0xff && head[1] === 0xd8) {
+    const dv = view(full);
+    let i = 2;
+    while (i + 9 < full.length) {
+      if (full[i] !== 0xff) { i++; continue; }
+      const m = full[i + 1];
+      if (m >= 0xc0 && m <= 0xcf && m !== 0xc4 && m !== 0xc8 && m !== 0xcc) {
+        return [dv.getUint16(i + 7), dv.getUint16(i + 5)];   // width, height
+      }
+      i += 2 + dv.getUint16(i + 2);   // salta al marker successivo
+    }
+  }
+  return null;
+}
+
+async function readRange(bucket, key, offset, length) {
+  const obj = await bucket.get(key, { range: { offset, length } });
+  if (!obj) return null;
+  return new Uint8Array(await obj.arrayBuffer());
+}
+
+function view(u8) { return new DataView(u8.buffer, u8.byteOffset, u8.byteLength); }

package/dist/functions/_shared/media-content.js

@@ -0,0 +1,200 @@
+/* Sorgenti del repo che possono contenere riferimenti a /media/.
+ *
+ * NON coincide con `isManagedPath`: quello stabilisce quali pagine la riconciliazione
+ * dell'admin può creare e cancellare. Qui la domanda è soltanto quali file vadano scanditi e,
+ * quando possibile, riscritti durante delete/move dei media.
+ */
+import { deserializeItem, checkFidelity } from "../../index.js";
+import { site } from "../site.js";
+import {
+  getRepoSnapshot, getText, commitUpserts, GitHubConflictError,
+} from "./github.js";
+import { removeImageRefs, replaceImageRefs, urlPresent } from "./refs.js";
+
+export const SITE_SETTINGS_PATH = "data/site.json";
+
+function issueText(issues) {
+  return issues.slice(0, 3)
+    .map((i) => `${i.path.join(".") || "?"}: ${i.message}`)
+    .join("; ");
+}
+
+function pageLabel(text, path, shape, extra) {
+  try {
+    const title = deserializeItem(text, shape, extra)?.title;
+    return typeof title === "string" && title.trim() ? title.trim() : path;
+  } catch {
+    return path;
+  }
+}
+
+function frontmatterSource(path, text, label, shape, object, extra = {}) {
+  return { kind: "frontmatter", path, text, label, shape, object, extra };
+}
+
+function jsonSource(path, text, label) {
+  return { kind: "settings", path, text, label };
+}
+
+/** Legge tutte le sorgenti dallo stesso commit, senza trasformare errori in file vuoti. */
+export async function readMediaSources(env) {
+  const snapshot = await getRepoSnapshot(env);
+  const pagePaths = snapshot.tree
+    .filter((x) => x.type === "blob" && site().isManagedPath(x.path))
+    .map((x) => x.path);
+  const existing = new Set(snapshot.tree.filter((x) => x.type === "blob").map((x) => x.path));
+  const fixedPaths = [site().homePath, SITE_SETTINGS_PATH].filter((p) => existing.has(p));
+  const paths = [...pagePaths, ...fixedPaths];
+  const texts = await Promise.all(paths.map(async (path) => {
+    const text = await getText(env, path, snapshot.commitSha);
+    if (text == null) throw new Error(`file ${path}: presente nell'albero ma non leggibile`);
+    return text;
+  }));
+
+  const sources = paths.map((path, i) => {
+    const text = texts[i];
+    if (path === site().homePath) {
+      return frontmatterSource(path, text, "Home", site().home, site().homeObject);
+    }
+    if (path === SITE_SETTINGS_PATH) {
+      return jsonSource(path, text, "Impostazioni sito");
+    }
+    const slug = path.split("/")[1] || "";
+    const extra = { slug };
+    return frontmatterSource(path, text, pageLabel(text, path, site().page, extra), site().page, site().pageObject, extra);
+  });
+  return { base: { commitSha: snapshot.commitSha, treeSha: snapshot.treeSha }, sources };
+}
+
+export function summarizeMediaUsage(sources, keys, mediaUrl) {
+  const usage = Object.create(null);
+  const labels = new Set();
+  for (const key of keys) {
+    const url = mediaUrl(key);
+    const used = sources.filter((s) => urlPresent(s.text, url)).map((s) => s.label);
+    if (!used.length) continue;
+    usage[key] = [...new Set(used)];
+    used.forEach((label) => labels.add(label));
+  }
+  return { usage, pages: [...labels], count: Object.keys(usage).length, selectedCount: keys.length };
+}
+
+function validateFrontmatter(source, text) {
+  const fidelity = checkFidelity(text, source.shape, source.extra);
+  if (!fidelity.ok) {
+    return `non riesco a riprodurre fedelmente ${source.path}`;
+  }
+  let model;
+  try {
+    model = deserializeItem(text, source.shape, source.extra);
+  } catch (error) {
+    return `${source.path} non è leggibile: ${error.message || String(error)}`;
+  }
+  const parsed = source.object.safeParse(model);
+  if (!parsed.success) {
+    return `${source.path} non sarebbe più valido (${issueText(parsed.error.issues)})`;
+  }
+  return null;
+}
+
+function rewriteSettings(text, operation) {
+  let data;
+  try { data = JSON.parse(text); }
+  catch { return { changed: false, text, error: `${SITE_SETTINGS_PATH} non contiene JSON valido` }; }
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    return { changed: false, text, error: `${SITE_SETTINGS_PATH} non contiene un oggetto JSON` };
+  }
+  const old = typeof data.favicon === "string" ? data.favicon : "";
+  let next = old;
+  if (operation.removeUrls?.includes(old)) next = "";
+  if (operation.map && Object.hasOwn(operation.map, old)) next = operation.map[old];
+  if (next === old) return { changed: false, text };
+  data.favicon = next;
+  return { changed: true, text: JSON.stringify(data, null, 2) + "\n" };
+}
+
+/** Funzione pura: prepara tutte le modifiche oppure restituisce i motivi per bloccarle. */
+export function planMediaRewrite(sources, operation) {
+  const oldUrls = operation.removeUrls || Object.keys(operation.map || {});
+  const changes = [];
+  const labels = [];
+  const blockers = [];
+
+  for (const source of sources) {
+    const present = oldUrls.filter((url) => urlPresent(source.text, url));
+    if (!present.length) continue;
+
+    let result;
+    if (source.kind === "settings") {
+      result = rewriteSettings(source.text, operation);
+    } else if (operation.removeUrls) {
+      result = removeImageRefs(source.text, present);
+    } else {
+      result = replaceImageRefs(source.text, operation.map || {});
+    }
+
+    if (result.error) {
+      blockers.push({ path: source.path, label: source.label, reason: result.error });
+      continue;
+    }
+    const remaining = present.filter((url) => urlPresent(result.text, url));
+    if (!result.changed || remaining.length) {
+      blockers.push({
+        path: source.path,
+        label: source.label,
+        reason: `non so aggiornare in sicurezza ${remaining.join(", ") || present.join(", ")}`,
+      });
+      continue;
+    }
+    if (source.kind === "frontmatter") {
+      const error = validateFrontmatter(source, result.text);
+      if (error) {
+        blockers.push({ path: source.path, label: source.label, reason: error });
+        continue;
+      }
+    }
+    changes.push({ path: source.path, content: result.text });
+    labels.push(source.label);
+  }
+  return { changes, labels: [...new Set(labels)], blockers };
+}
+
+export class MediaRewriteError extends Error {
+  constructor(blockers) {
+    const detail = blockers.map((b) => `${b.label}: ${b.reason}`).join("; ");
+    super(`Operazione annullata: ${detail}`);
+    this.name = "MediaRewriteError";
+    this.code = "media_refs_blocked";
+    this.blockers = blockers;
+  }
+}
+
+/** Rilegge e ricalcola una volta se il branch cambia durante il commit. */
+export async function rewriteMediaReferences(env, operation, message) {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const { base, sources } = await readMediaSources(env);
+    const plan = planMediaRewrite(sources, operation);
+    if (plan.blockers.length) throw new MediaRewriteError(plan.blockers);
+    if (!plan.changes.length) {
+      return {
+        commit: null,
+        verifiedCommit: base.commitSha,
+        filesUpdated: [],
+        labels: [],
+      };
+    }
+    try {
+      const commit = await commitUpserts(env, message, plan.changes, { base });
+      return {
+        commit,
+        verifiedCommit: commit,
+        filesUpdated: plan.changes.map((f) => f.path),
+        labels: plan.labels,
+      };
+    } catch (error) {
+      if (error instanceof GitHubConflictError && attempt === 0) continue;
+      throw error;
+    }
+  }
+  throw new GitHubConflictError();
+}

package/dist/functions/_shared/pending-media.js

@@ -0,0 +1,98 @@
+import { gh, repoBranch, prodBranch } from "./github.js";
+import { readMediaSources } from "./media-content.js";
+import { mediaUrl, urlPresent } from "./refs.js";
+import { moveToTrash } from "./assets.js";
+
+const PREFIX = "_pending-media/";
+
+async function readRecords(bucket) {
+  const records = [];
+  let cursor;
+  do {
+    const page = await bucket.list({ prefix: PREFIX, cursor, limit: 1000 });
+    for (const item of page.objects || []) {
+      try {
+        const object = await bucket.get(item.key);
+        if (!object) continue;
+        const value = JSON.parse(await object.text());
+        if (value && Array.isArray(value.entries)) records.push({ marker: item.key, ...value });
+      } catch { /* Un marker corrotto resta intatto: non si indovina cosa cancellare. */ }
+    }
+    cursor = page.truncated ? page.cursor : undefined;
+  } while (cursor);
+  return records;
+}
+
+export async function recordPendingMedia(bucket, kind, entries, commit) {
+  if (!entries.length) return null;
+  const marker = `${PREFIX}${Date.now()}-${crypto.randomUUID()}.json`;
+  await bucket.put(marker, JSON.stringify({ kind, entries, commit, createdAt: new Date().toISOString() }), {
+    httpMetadata: { contentType: "application/json" },
+  });
+  return marker;
+}
+
+export async function pendingSourceKeys(bucket) {
+  const keys = new Set();
+  for (const record of await readRecords(bucket)) {
+    for (const entry of record.entries) {
+      if (typeof entry?.oldKey === "string") keys.add(entry.oldKey);
+    }
+  }
+  return keys;
+}
+
+async function headSha(env, repo, branch) {
+  const response = await gh(env, `/repos/${repo}/git/ref/heads/${encodeURIComponent(branch)}`);
+  if (!response.ok) throw new Error(`ref ${branch} ${response.status}`);
+  return (await response.json()).object.sha;
+}
+
+/**
+ * Completa le operazioni R2 soltanto quando bozza e produzione puntano allo stesso commit e
+ * quel commit non contiene più nessuno degli URL vecchi. Fino ad allora gli originali restano
+ * disponibili al sito pubblicato.
+ */
+export async function finalizePendingMedia(env) {
+  if (!env.MEDIA || !env.GITHUB_TOKEN || !env.GITHUB_REPO) {
+    return { finalized: 0, pending: 0, skipped: "binding non configurati" };
+  }
+  const { repo, branch } = repoBranch(env);
+  const prod = prodBranch(env);
+  const [draftSha, prodSha] = await Promise.all([
+    headSha(env, repo, branch),
+    headSha(env, repo, prod),
+  ]);
+  const records = await readRecords(env.MEDIA);
+  if (draftSha !== prodSha) return { finalized: 0, pending: records.length, skipped: "branch non allineati" };
+
+  const { sources } = await readMediaSources(env);
+  let finalized = 0;
+  const failures = [];
+
+  for (const record of records) {
+    const oldKeys = record.entries.map((entry) => entry?.oldKey).filter((key) => typeof key === "string");
+    const stillReferenced = oldKeys.some((key) => {
+      const url = mediaUrl(key);
+      return sources.some((source) => urlPresent(source.text, url));
+    });
+    if (stillReferenced) continue;
+
+    let complete = true;
+    for (const key of oldKeys) {
+      try {
+        if (record.kind === "trash") await moveToTrash(env.MEDIA, key);
+        else await env.MEDIA.delete(key);
+      } catch (error) {
+        complete = false;
+        failures.push({ key, error: error?.message || String(error) });
+      }
+    }
+    if (complete) {
+      await env.MEDIA.delete(record.marker);
+      finalized++;
+    }
+  }
+
+  return { finalized, pending: records.length - finalized, failures };
+}