@cardinali-studio/adminkit 1.0.0

package/dist/functions/_shared/b2.js

@@ -0,0 +1,300 @@
+/* Client Backblaze B2 attraverso l'API S3-compatible.
+ *
+ * Le chiamate di controllo (create/complete/list/GET) sono firmate qui con SigV4.
+ * I byte grandi NON attraversano la Function: `b2PresignUploadPart` produce URL
+ * PUT a breve durata che il browser usa direttamente verso il bucket privato.
+ */
+
+const enc = new TextEncoder();
+
+export function b2Configured(env) {
+  return !!(env.B2_ENDPOINT && env.B2_REGION && env.B2_BUCKET &&
+    env.B2_APPLICATION_KEY_ID && env.B2_APPLICATION_KEY);
+}
+
+export function b2ObjectKey(prefix, filename) {
+  return `${String(prefix).replace(/^\/+|\/+$/g, "")}/${String(filename).replace(/^\/+/g, "")}`;
+}
+
+export async function b2Request(env, method, key, options = {}) {
+  assertConfig(env);
+  const url = objectUrl(env, key);
+  addQuery(url, options.query);
+  const body = options.body ?? null;
+  const payloadHash = await sha256Bytes(body == null ? new Uint8Array() : toBytes(body));
+  const now = new Date();
+  const amzDate = stamp(now);
+  const date = amzDate.slice(0, 8);
+  const headers = new Headers(options.headers || {});
+  headers.set("x-amz-date", amzDate);
+  headers.set("x-amz-content-sha256", payloadHash);
+
+  const signedNames = ["host", ...[...headers.keys()].map((h) => h.toLowerCase())]
+    .filter((v, i, a) => a.indexOf(v) === i).sort();
+  const canonicalHeaders = signedNames.map((name) =>
+    `${name}:${name === "host" ? url.host : cleanHeader(headers.get(name) || "")}\n`).join("");
+  const canonical = [
+    method.toUpperCase(),
+    canonicalPath(url.pathname),
+    canonicalQuery(url),
+    canonicalHeaders,
+    signedNames.join(";"),
+    payloadHash,
+  ].join("\n");
+  const scope = `${date}/${env.B2_REGION}/s3/aws4_request`;
+  const stringToSign = [
+    "AWS4-HMAC-SHA256", amzDate, scope, await sha256Bytes(enc.encode(canonical)),
+  ].join("\n");
+  const signature = hex(await hmac(await signingKey(env.B2_APPLICATION_KEY, date, env.B2_REGION), stringToSign));
+  headers.set("Authorization",
+    `AWS4-HMAC-SHA256 Credential=${env.B2_APPLICATION_KEY_ID}/${scope}, ` +
+    `SignedHeaders=${signedNames.join(";")}, Signature=${signature}`);
+
+  return fetch(url, { method, headers, body });
+}
+
+export async function b2PresignUploadPart(env, key, uploadId, partNumber, expires = 900) {
+  return presignObject(env, "PUT", key, { partNumber: String(partNumber), uploadId }, expires, 3600);
+}
+
+export async function b2PresignPutObject(env, key, expires = 900) {
+  return presignObject(env, "PUT", key, {}, expires, 3600);
+}
+
+export async function b2PresignGetObject(env, key, options = {}) {
+  const query = {};
+  if (options.contentDisposition) {
+    query["response-content-disposition"] = String(options.contentDisposition);
+  }
+  if (options.contentType) query["response-content-type"] = String(options.contentType);
+  return presignObject(env, "GET", key, query, options.expires ?? 86_400, 604_800);
+}
+
+async function presignObject(env, method, key, query, expires, maxExpires) {
+  assertConfig(env);
+  const url = objectUrl(env, key);
+  addQuery(url, query);
+  const now = new Date();
+  const amzDate = stamp(now);
+  const date = amzDate.slice(0, 8);
+  const scope = `${date}/${env.B2_REGION}/s3/aws4_request`;
+  url.searchParams.set("X-Amz-Algorithm", "AWS4-HMAC-SHA256");
+  url.searchParams.set("X-Amz-Credential", `${env.B2_APPLICATION_KEY_ID}/${scope}`);
+  url.searchParams.set("X-Amz-Date", amzDate);
+  url.searchParams.set("X-Amz-Expires", String(Math.min(maxExpires, Math.max(60, expires))));
+  url.searchParams.set("X-Amz-SignedHeaders", "host");
+  const canonical = [
+    method,
+    canonicalPath(url.pathname),
+    canonicalQuery(url),
+    `host:${url.host}\n`,
+    "host",
+    "UNSIGNED-PAYLOAD",
+  ].join("\n");
+  const stringToSign = [
+    "AWS4-HMAC-SHA256", amzDate, scope, await sha256Bytes(enc.encode(canonical)),
+  ].join("\n");
+  const signature = hex(await hmac(await signingKey(env.B2_APPLICATION_KEY, date, env.B2_REGION), stringToSign));
+  url.searchParams.set("X-Amz-Signature", signature);
+  return url.toString();
+}
+
+export async function b2CreateMultipart(env, key, contentType = "application/zip") {
+  const res = await b2Request(env, "POST", key, {
+    query: { uploads: "" },
+    headers: { "Content-Type": contentType },
+  });
+  const text = await res.text();
+  if (!res.ok) throw new Error(`B2 create multipart ${res.status}: ${text.slice(0, 300)}`);
+  const uploadId = xml(text, "UploadId");
+  if (!uploadId) throw new Error("B2 non ha restituito uploadId");
+  return uploadId;
+}
+
+export async function b2CompleteMultipart(env, key, uploadId, parts) {
+  const body = `<CompleteMultipartUpload>${parts.map((p) =>
+    `<Part><PartNumber>${p.partNumber}</PartNumber><ETag>${escapeXml(p.etag)}</ETag></Part>`
+  ).join("")}</CompleteMultipartUpload>`;
+  const res = await b2Request(env, "POST", key, {
+    query: { uploadId },
+    headers: { "Content-Type": "application/xml" },
+    body,
+  });
+  const text = await res.text();
+  if (!res.ok) throw new Error(`B2 complete multipart ${res.status}: ${text.slice(0, 300)}`);
+  return { etag: xml(text, "ETag"), versionId: xml(text, "VersionId") };
+}
+
+export async function b2AbortMultipart(env, key, uploadId) {
+  const res = await b2Request(env, "DELETE", key, { query: { uploadId } });
+  if (!res.ok && res.status !== 404) {
+    throw new Error(`B2 abort multipart ${res.status}: ${(await res.text()).slice(0, 300)}`);
+  }
+}
+
+export async function b2ListParts(env, key, uploadId) {
+  const parts = [];
+  let marker = "";
+  for (let page = 0; page < 10; page++) {
+    const query = { uploadId, "max-parts": "1000" };
+    if (marker) query["part-number-marker"] = marker;
+    const res = await b2Request(env, "GET", key, { query });
+    const text = await res.text();
+    if (!res.ok) throw new Error(`B2 list parts ${res.status}: ${text.slice(0, 300)}`);
+    for (const block of text.matchAll(/<Part>([\s\S]*?)<\/Part>/g)) {
+      parts.push({
+        partNumber: Number(xml(block[1], "PartNumber")),
+        etag: xml(block[1], "ETag"),
+        size: Number(xml(block[1], "Size")),
+      });
+    }
+    if (xml(text, "IsTruncated").toLowerCase() !== "true") break;
+    marker = xml(text, "NextPartNumberMarker");
+    if (!marker) throw new Error("B2 ListParts paginato senza marker");
+  }
+  return parts.filter((p) => Number.isInteger(p.partNumber) && p.partNumber > 0 && p.etag);
+}
+
+export async function b2PutSmall(env, key, body, contentType) {
+  let lastFailure = "";
+  for (let attempt = 0; attempt < 5; attempt++) {
+    let res;
+    try {
+      /* Ogni tentativo passa di nuovo da b2Request: data e firma SigV4 vengono
+         rigenerate. Il PUT è idempotente perché il manifest usa sempre la
+         stessa chiave immutabile del pacchetto. */
+      res = await b2Request(env, "PUT", key, {
+        headers: { "Content-Type": contentType },
+        body,
+      });
+    } catch (error) {
+      lastFailure = error instanceof Error ? error.message : String(error);
+      if (attempt === 4) throw new Error(`B2 put: ${lastFailure}`);
+      await retryDelay(null, attempt);
+      continue;
+    }
+    if (res.ok) return;
+    const detail = (await res.text()).replace(/\s+/g, " ").trim().slice(0, 300);
+    lastFailure = `${res.status}${detail ? `: ${detail}` : ""}`;
+    if (!transientStatus(res.status) || attempt === 4) {
+      throw new Error(`B2 put ${lastFailure}`);
+    }
+    await retryDelay(res, attempt);
+  }
+  throw new Error(`B2 put ${lastFailure || "non riuscito"}`);
+}
+
+export function b2Get(env, key, range) {
+  const headers = range ? { Range: range } : {};
+  return b2Request(env, "GET", key, { headers });
+}
+
+export async function b2Delete(env, key) {
+  const res = await b2Request(env, "DELETE", key);
+  if (!res.ok && res.status !== 404) {
+    throw new Error(`B2 delete ${res.status}: ${(await res.text()).slice(0, 300)}`);
+  }
+}
+
+function assertConfig(env) {
+  if (!b2Configured(env)) {
+    throw new Error("Backblaze B2 non configurato: servono endpoint, region, bucket e application key");
+  }
+}
+
+function transientStatus(status) {
+  return status === 408 || status === 429 || status === 500 ||
+    status === 502 || status === 503 || status === 504;
+}
+
+function retryDelay(response, attempt) {
+  const retryAfter = Number(response?.headers.get("retry-after"));
+  const delay = Number.isFinite(retryAfter) && retryAfter > 0
+    ? Math.min(10_000, retryAfter * 1000)
+    : Math.min(5_000, 400 * 2 ** attempt) + Math.floor(Math.random() * 150);
+  return new Promise((resolve) => setTimeout(resolve, delay));
+}
+
+function objectUrl(env, key) {
+  const endpoint = new URL(String(env.B2_ENDPOINT));
+  endpoint.hostname = `${env.B2_BUCKET}.${endpoint.hostname}`;
+  endpoint.pathname = "/" + String(key).split("/").map(rfc3986).join("/");
+  endpoint.search = "";
+  return endpoint;
+}
+
+function addQuery(url, query) {
+  for (const [key, value] of Object.entries(query || {})) {
+    if (value !== undefined && value !== null) url.searchParams.set(key, String(value));
+  }
+}
+
+function canonicalPath(path) {
+  return path.split("/").map((part) => rfc3986(decodeURIComponent(part))).join("/") || "/";
+}
+
+function canonicalQuery(url) {
+  return [...url.searchParams.entries()]
+    .map(([k, v]) => [rfc3986(k), rfc3986(v)])
+    /* SigV4 richiede ordine lessicografico sui byte UTF-8 già percent-encoded.
+       localeCompare applica regole linguistiche (e può mettere `partNumber`
+       prima di `X-Amz-*`), producendo una firma diversa da quella verificata da B2. */
+    .sort(([ak, av], [bk, bv]) => ak === bk ? asciiCompare(av, bv) : asciiCompare(ak, bk))
+    .map(([k, v]) => `${k}=${v}`).join("&");
+}
+
+function asciiCompare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+function rfc3986(value) {
+  return encodeURIComponent(value).replace(/[!'()*]/g, (c) =>
+    `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+
+function cleanHeader(value) {
+  return value.trim().replace(/\s+/g, " ");
+}
+
+function stamp(date) {
+  return date.toISOString().replace(/[:-]|\.\d{3}/g, "");
+}
+
+async function signingKey(secret, date, region) {
+  const kDate = await hmac(enc.encode("AWS4" + secret), date);
+  const kRegion = await hmac(kDate, region);
+  const kService = await hmac(kRegion, "s3");
+  return hmac(kService, "aws4_request");
+}
+
+async function hmac(rawKey, value) {
+  const key = await crypto.subtle.importKey(
+    "raw", rawKey, { name: "HMAC", hash: "SHA-256" }, false, ["sign"],
+  );
+  return new Uint8Array(await crypto.subtle.sign("HMAC", key, enc.encode(value)));
+}
+
+async function sha256Bytes(bytes) {
+  return hex(await crypto.subtle.digest("SHA-256", bytes));
+}
+
+function toBytes(value) {
+  if (typeof value === "string") return enc.encode(value);
+  if (value instanceof Uint8Array) return value;
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  throw new Error("body B2 non supportato");
+}
+
+function hex(buffer) {
+  return [...new Uint8Array(buffer)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+function xml(text, tag) {
+  const m = String(text).match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`));
+  return m ? m[1].replace(/&quot;/g, '"').replace(/&amp;/g, "&").trim() : "";
+}
+
+function escapeXml(value) {
+  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}

package/dist/functions/_shared/delivery-crypto.js

@@ -0,0 +1,99 @@
+/* Segreti recuperabili e firme brevi per Delivery.
+ *
+ * Token e PIN devono poter essere ricopiati dall'admin, quindi un hash non basta:
+ * in D1 teniamo hash(token) per il lookup e AES-GCM(token/PIN) per la lettura
+ * dietro Access. DELIVERY_SECRET è l'unica chiave e non entra mai nel repo.
+ */
+
+const enc = new TextEncoder();
+const dec = new TextDecoder();
+
+export function b64url(bytes) {
+  let s = "";
+  const a = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+  for (let i = 0; i < a.length; i += 0x8000) {
+    s += String.fromCharCode(...a.subarray(i, i + 0x8000));
+  }
+  return btoa(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+
+export function fromB64url(value) {
+  const s = String(value).replace(/-/g, "+").replace(/_/g, "/");
+  const raw = atob(s + "=".repeat((4 - s.length % 4) % 4));
+  return Uint8Array.from(raw, (c) => c.charCodeAt(0));
+}
+
+export function randomToken(bytes = 24) {
+  return b64url(crypto.getRandomValues(new Uint8Array(bytes)));
+}
+
+export async function sha256(value) {
+  return hex(await crypto.subtle.digest("SHA-256", enc.encode(String(value))));
+}
+
+async function aesKey(secret) {
+  if (!secret) throw new Error("DELIVERY_SECRET non configurato");
+  const raw = await crypto.subtle.digest("SHA-256", enc.encode(String(secret)));
+  return crypto.subtle.importKey("raw", raw, "AES-GCM", false, ["encrypt", "decrypt"]);
+}
+
+export async function seal(secret, value) {
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const out = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv },
+    await aesKey(secret),
+    enc.encode(String(value)),
+  );
+  return `v1.${b64url(iv)}.${b64url(out)}`;
+}
+
+export async function unseal(secret, value) {
+  const [version, iv, body] = String(value || "").split(".");
+  if (version !== "v1" || !iv || !body) throw new Error("segreto Delivery illeggibile");
+  const out = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv: fromB64url(iv) },
+    await aesKey(secret),
+    fromB64url(body),
+  );
+  return dec.decode(out);
+}
+
+async function hmac(secret, value) {
+  const key = await crypto.subtle.importKey(
+    "raw", enc.encode(String(secret)), { name: "HMAC", hash: "SHA-256" }, false, ["sign"],
+  );
+  return b64url(await crypto.subtle.sign("HMAC", key, enc.encode(String(value))));
+}
+
+export async function signValue(secret, payload, ttlSeconds = 900) {
+  const exp = Math.floor(Date.now() / 1000) + ttlSeconds;
+  const body = b64url(enc.encode(JSON.stringify({ ...payload, exp })));
+  return `${body}.${await hmac(secret, body)}`;
+}
+
+export async function verifyValue(secret, value) {
+  const dot = String(value || "").lastIndexOf(".");
+  if (dot < 1) return null;
+  const body = value.slice(0, dot);
+  const got = value.slice(dot + 1);
+  const want = await hmac(secret, body);
+  if (!safeEqual(got, want)) return null;
+  try {
+    const payload = JSON.parse(dec.decode(fromB64url(body)));
+    if (!payload.exp || payload.exp < Math.floor(Date.now() / 1000)) return null;
+    return payload;
+  } catch {
+    return null;
+  }
+}
+
+function safeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+
+function hex(buffer) {
+  return [...new Uint8Array(buffer)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}

package/dist/functions/_shared/delivery-purge.js

@@ -0,0 +1,222 @@
+/* Cancellazione dei byte delle consegne: l'unico posto che tocca B2 per togliere.
+ *
+ * Sta in _shared perché ha due chiamanti con tempi diversi:
+ * - functions/admin/api/deliveries.js — la cancellazione chiesta a mano, che
+ *   avviene nella richiesta stessa, e il recupero di ciò che si fosse fermato;
+ * - workers/delivery-housekeeping — il cron, che è l'unico a far scattare i
+ *   lavori che nessuno innesca di persona (file scaduti, caricamenti
+ *   abbandonati, originali archiviati). Pages non ha cron trigger: senza quel
+ *   Worker quei tre restano fermi finché qualcuno non apre il pannello.
+ *
+ * NIENTE React e niente dipendenze dal contesto Pages: gira anche in un Worker
+ * nudo, con le sole `env.DB` e le variabili B2.
+ */
+
+import { b2AbortMultipart, b2Delete } from "./b2.js";
+
+const DAY = 86_400_000;
+
+/* Ogni oggetto tolto da B2 è una sottorichiesta, e il tetto è per invocazione:
+ * da qui il vecchio «due pacchetti per giro», che era un limite di piattaforma
+ * travestito da LIMIT. Il budget lo dice esplicitamente e lo rende regolabile —
+ * stretto quando c'è un utente che aspetta la risposta, largo nel cron.
+ * Un pacchetto già cominciato arriva in fondo anche se sfora (gli servono al
+ * più sette chiamate): le sue righe non spariscono finché i suoi byte no. */
+export const B2_CALLS_PER_REQUEST = 24;
+export const budget = (left = B2_CALLS_PER_REQUEST) => ({ left });
+
+/* Toglie da B2 tutto ciò che appartiene ai pacchetti passati e poi le righe.
+ * I multipart ancora aperti vanno abortiti prima: le parti già caricate non
+ * appartengono a nessun oggetto e la lifecycle le raccoglierebbe soltanto dopo
+ * giorni. Una DELETE S3 su bucket versionato nasconde: i byte spariscono con
+ * `daysFromHidingToDeleting` (vedi DELIVERY.md). */
+async function purgePackages(env, rows, calls) {
+  for (const pkg of rows) {
+    if (calls.left <= 0) return false;
+    const uploads = await env.DB.prepare(
+      "SELECT object_key,b2_upload_id,state FROM delivery_uploads WHERE package_id=?"
+    ).bind(pkg.id).all();
+    for (const upload of (uploads.results || [])) {
+      if (upload.state === "uploading" && upload.b2_upload_id !== "single") {
+        calls.left -= 1;
+        await b2AbortMultipart(env, upload.object_key, upload.b2_upload_id);
+      }
+    }
+    const keys = new Set([
+      pkg.originals_key, pkg.web_key, pkg.thumbs_key, pkg.manifest_key,
+      ...(uploads.results || []).map((upload) => upload.object_key),
+    ].filter(Boolean));
+    for (const key of keys) {
+      calls.left -= 1;
+      await b2Delete(env, key);
+    }
+    await env.DB.prepare("DELETE FROM delivery_packages WHERE id=? AND state='deleted'")
+      .bind(pkg.id).run();
+  }
+  return true;
+}
+
+async function purgeHeroes(env, rows, calls) {
+  for (const hero of rows) {
+    if (calls.left <= 0) return false;
+    calls.left -= 1;
+    await b2Delete(env, hero.object_key);
+    await env.DB.prepare("DELETE FROM delivery_hero_objects WHERE id=?").bind(hero.id).run();
+  }
+  return true;
+}
+
+/* Cancellazione immediata di quanto è già marcato `deleted` per un transfer.
+ * Torna false se è rimasto indietro qualcosa — un errore su B2, o un transfer
+ * così grande da esaurire il budget: le tombstone hanno `purge_after` nel
+ * passato, quindi il giro successivo (cron, o la prossima schermata dell'admin)
+ * riprende da dov'era. */
+export async function purgeDeliveryNow(env, id, calls = budget()) {
+  try {
+    const packages = await env.DB.prepare(
+      "SELECT * FROM delivery_packages WHERE delivery_id=? AND state='deleted'"
+    ).bind(id).all();
+    if (!await purgePackages(env, packages.results || [], calls)) return false;
+    const heroes = await env.DB.prepare(
+      "SELECT id,object_key FROM delivery_hero_objects WHERE delivery_id=?"
+    ).bind(id).all();
+    if (!await purgeHeroes(env, heroes.results || [], calls)) return false;
+    await env.DB.prepare(`
+      DELETE FROM deliveries
+      WHERE id=? AND status='deleted'
+        AND NOT EXISTS (SELECT 1 FROM delivery_packages p WHERE p.delivery_id=deliveries.id)
+        AND NOT EXISTS (SELECT 1 FROM delivery_hero_objects h WHERE h.delivery_id=deliveries.id)
+    `).bind(id).run();
+    return true;
+  } catch (error) {
+    console.error("delivery purge now:", error);
+    return false;
+  }
+}
+
+/* Le hero dedicate vanno lette prima di cancellare il pacchetto: la loro
+ * `package_id` è ON DELETE SET NULL, e dopo non si saprebbe più a chi
+ * appartenevano. */
+export async function purgePackageNow(env, packageId, calls = budget()) {
+  try {
+    const heroes = await env.DB.prepare(
+      "SELECT id,object_key FROM delivery_hero_objects WHERE package_id=?"
+    ).bind(packageId).all();
+    if (!await purgeHeroes(env, heroes.results || [], calls)) return false;
+    const pkg = await env.DB.prepare(
+      "SELECT * FROM delivery_packages WHERE id=? AND state='deleted'"
+    ).bind(packageId).first();
+    if (pkg) return purgePackages(env, [pkg], calls);
+    return true;
+  } catch (error) {
+    console.error("package purge now:", error);
+    return false;
+  }
+}
+
+/* Un giro di housekeeping. Le cancellazioni chieste a mano non passano di qui —
+ * avvengono nella loro richiesta — ma se una si era fermata a metà è questo giro
+ * a finirla, perché la sua `purge_after` è già scaduta. Un solo budget per tutte
+ * le fasi; le LIMIT tengono corta ogni singola query, il budget tiene corto il
+ * totale. Torna false se il budget è finito: c'è ancora lavoro da fare. */
+export async function purgeDue(env, calls = budget()) {
+  const now = new Date().toISOString();
+  const stale = new Date(Date.now() - 7 * DAY).toISOString();
+  const expiredFiles = await env.DB.prepare(`
+    SELECT id FROM deliveries
+    WHERE files_expires_at IS NOT NULL AND files_expires_at<=?
+      AND status IN ('uploading','active','archived')
+      AND EXISTS (
+        SELECT 1 FROM delivery_packages p
+        WHERE p.delivery_id=deliveries.id AND p.state!='deleted'
+      )
+    ORDER BY files_expires_at LIMIT 10
+  `).bind(now).all();
+  for (const delivery of (expiredFiles.results || [])) {
+    await env.DB.batch([
+      env.DB.prepare(`
+        UPDATE delivery_packages SET state='deleted',deleted_at=?,purge_after=?,updated_at=?
+        WHERE delivery_id=? AND state!='deleted'
+      `).bind(now, now, now, delivery.id),
+      env.DB.prepare(`
+        UPDATE delivery_hero_objects SET state='deleted',purge_after=?,updated_at=?
+        WHERE delivery_id=? AND state!='deleted'
+      `).bind(now, now, delivery.id),
+    ]);
+  }
+  await env.DB.prepare(`
+    UPDATE delivery_packages SET state='deleted',deleted_at=?,purge_after=?,updated_at=?
+    WHERE state='uploading' AND updated_at<=?
+      AND NOT EXISTS (
+        SELECT 1 FROM delivery_uploads u
+        WHERE u.package_id=delivery_packages.id AND u.updated_at>?
+      )
+  `).bind(now, now, now, stale, stale).run();
+  const abandoned = await env.DB.prepare(`
+    SELECT d.id FROM deliveries d
+    WHERE d.status='uploading' AND d.updated_at<=?
+      AND NOT EXISTS (
+        SELECT 1 FROM delivery_packages p
+        WHERE p.delivery_id=d.id AND p.state IN ('uploading','ready')
+      )
+    ORDER BY d.updated_at LIMIT 10
+  `).bind(stale).all();
+  /* Sono già fermi da sette giorni: non ne aggiungiamo altri sette. */
+  for (const delivery of (abandoned.results || [])) {
+    await env.DB.batch([
+      env.DB.prepare(`
+        UPDATE deliveries SET status='deleted',deleted_at=?,purge_after=?,updated_at=? WHERE id=?
+      `).bind(now, now, now, delivery.id),
+      env.DB.prepare(`
+        UPDATE delivery_links SET revoked_at=COALESCE(revoked_at,?) WHERE delivery_id=?
+      `).bind(now, delivery.id),
+    ]);
+  }
+  const staleHeroes = await env.DB.prepare(`
+    SELECT id,object_key FROM delivery_hero_objects
+    WHERE (state='pending' AND updated_at<=?)
+       OR (state='deleted' AND purge_after IS NOT NULL AND purge_after<=?)
+    ORDER BY updated_at LIMIT 10
+  `).bind(new Date(Date.now() - DAY).toISOString(), now).all();
+  if (!await purgeHeroes(env, staleHeroes.results || [], calls)) return false;
+  const archived = await env.DB.prepare(`
+    SELECT p.id,p.originals_key,u.bytes
+    FROM delivery_packages p
+    LEFT JOIN delivery_uploads u ON u.package_id=p.id AND u.variant='originals'
+    WHERE p.state='ready' AND p.originals_key IS NOT NULL
+      AND p.originals_purge_after IS NOT NULL AND p.originals_purge_after<=?
+    ORDER BY p.originals_purge_after LIMIT 4
+  `).bind(now).all();
+  for (const pkg of (archived.results || [])) {
+    if (calls.left <= 0) return false;
+    calls.left -= 1;
+    await b2Delete(env, pkg.originals_key);
+    await env.DB.batch([
+      env.DB.prepare(`
+        UPDATE delivery_packages SET originals_key=NULL,originals_purge_after=NULL,
+          stored_bytes=MAX(0,stored_bytes-?),updated_at=? WHERE id=?
+      `).bind(Number(pkg.bytes || 0), now, pkg.id),
+      env.DB.prepare("DELETE FROM delivery_uploads WHERE package_id=? AND variant='originals'")
+        .bind(pkg.id),
+    ]);
+  }
+  const { results } = await env.DB.prepare(`
+    SELECT * FROM delivery_packages
+    WHERE state='deleted' AND purge_after IS NOT NULL AND purge_after<=?
+    ORDER BY purge_after LIMIT 8
+  `).bind(now).all();
+  if (!await purgePackages(env, results || [], calls)) return false;
+  await env.DB.prepare(`
+    DELETE FROM deliveries
+    WHERE status='deleted' AND purge_after IS NOT NULL AND purge_after<=?
+      AND NOT EXISTS (SELECT 1 FROM delivery_packages p WHERE p.delivery_id=deliveries.id)
+      AND NOT EXISTS (SELECT 1 FROM delivery_hero_objects h WHERE h.delivery_id=deliveries.id)
+  `).bind(now).run();
+  /* Una fase che ha riempito la sua LIMIT probabilmente ha ancora coda: chi
+   * chiama in loop (il cron) sa che deve rifare un giro. */
+  return (expiredFiles.results || []).length < 10 &&
+    (abandoned.results || []).length < 10 &&
+    (staleHeroes.results || []).length < 10 &&
+    (archived.results || []).length < 4 &&
+    (results || []).length < 8;
+}

package/dist/functions/_shared/edge-cache.js

@@ -0,0 +1,37 @@
+/* Un risultato calcolato una volta e riusato per qualche secondo, nella cache dell'edge.
+ *
+ * Lo usano i due numeri cari della Panoramica: lo spazio occupato su R2 va contato elencando
+ * il bucket INTERO (mille oggetti per chiamata), e le visite sono una richiesta a un servizio
+ * esterno con un tetto di chiamate. Nessuno dei due cambia da un minuto all'altro, e senza
+ * questo ogni ritorno sulla schermata iniziale — che è anche quella da cui si parte — ripaga
+ * il prezzo pieno.
+ *
+ * `caches.default` e NON una variabile di modulo: un isolate vive poco, non è condiviso e non
+ * si sa quale risponderà: una variabile darebbe un colpo di fortuna, non una cache.
+ *
+ * La chiave dev'essere un URL della ZONA della richiesta. Con un hostname inventato Cloudflare
+ * ignora la `put` senza dare errore, e la cache sembra funzionare mentre non fa niente: per
+ * questo la si costruisce da `request.url`. Il percorso non è una rotta — non esiste nessun
+ * file sotto quel nome — è solo un identificatore, ed è sotto /admin/ così anche a volerlo
+ * chiedere si finirebbe contro Access.
+ */
+export async function cachedJson(request, waitUntil, name, ttlSeconds, build) {
+  const key = new Request(new URL(`/admin/api/_cache/${name}`, request.url).toString());
+  const cache = caches.default;
+
+  // `fresh=1` salta la lettura ma NON la scrittura: chi preme «Aggiorna» rinfresca la cache
+  // per tutti, invece di prendersi il numero buono e lasciare agli altri quello vecchio.
+  const url = new URL(request.url);
+  if (url.searchParams.get("fresh") !== "1") {
+    const hit = await cache.match(key);
+    if (hit) return { data: await hit.json(), cached: true };
+  }
+
+  const data = await build();
+  const stored = new Response(JSON.stringify(data), {
+    headers: { "Content-Type": "application/json", "Cache-Control": `max-age=${ttlSeconds}` },
+  });
+  const put = cache.put(key, stored);
+  if (typeof waitUntil === "function") waitUntil(put); else await put;
+  return { data, cached: false };
+}