@cardinali-studio/adminkit 1.0.0

package/dist/functions/api/delivery/image.js

@@ -0,0 +1,35 @@
+/* Anteprima admin di un membro contenuto negli ZIP web/thumbs.
+ * Access è già verificato dal middleware; Range evita duplicazioni su B2.
+ */
+import { b2Get } from "../../_shared/b2.js";
+
+export async function onRequestGet({ request, env }) {
+  if (!env.DB) return new Response("D1 non configurato", { status: 500 });
+  const url = new URL(request.url);
+  const packageId = url.searchParams.get("packageId") || "";
+  const variant = url.searchParams.get("variant") === "thumb" ? "thumb" : "web";
+  const index = Number(url.searchParams.get("index"));
+  const pkg = await env.DB.prepare(`
+    SELECT web_key,thumbs_key,manifest_json FROM delivery_packages
+    WHERE id=? AND state='ready'
+  `).bind(packageId).first();
+  const manifest = parseManifest(pkg?.manifest_json);
+  const entry = Number.isInteger(index) && index >= 0 ? manifest.entries?.[index] : null;
+  const member = variant === "thumb" ? entry?.thumb : entry?.web;
+  const key = variant === "thumb" ? pkg?.thumbs_key : pkg?.web_key;
+  if (!member || !key) return new Response("Not found", { status: 404 });
+  const upstream = await b2Get(env, key, `bytes=${member.offset}-${member.offset + member.length - 1}`);
+  if (!upstream.ok) return new Response("Not found", { status: upstream.status });
+  return new Response(upstream.body, {
+    headers: {
+      "Content-Type": "image/webp",
+      "Content-Length": String(member.length),
+      "Cache-Control": "private, max-age=3600",
+      "X-Content-Type-Options": "nosniff",
+    },
+  });
+}
+
+function parseManifest(value) {
+  try { return JSON.parse(value || "{}"); } catch { return { entries: [] }; }
+}

package/dist/functions/api/delivery/multipart.js

@@ -0,0 +1,261 @@
+/* Controllo multipart Backblaze B2.
+ *
+ * La Function crea/firma/completa; il browser invia ogni parte DIRETTAMENTE a
+ * B2 con l'URL prefirmato restituito da `presign`.
+ */
+
+import {
+  b2AbortMultipart, b2CompleteMultipart, b2CreateMultipart, b2ListParts,
+  b2ObjectKey, b2PresignPutObject, b2PresignUploadPart,
+} from "../../_shared/b2.js";
+
+const FILENAMES = {
+  originals: "originals.zip",
+  web: "web.zip",
+  thumbs: "thumbs.zip",
+};
+
+export async function onRequestPost({ request, env }) {
+  if (!env.DB) return json({ ok: false, error: "D1 non configurato" }, 500);
+  let body;
+  try { body = await request.json(); }
+  catch { return json({ ok: false, error: "Corpo JSON non valido" }, 400); }
+  try {
+    switch (body?.action) {
+      case "create": return json({ ok: true, upload: await create(env, body) });
+      case "putPresign": return json({ ok: true, ...(await putPresign(env, body)) });
+      case "putComplete": return json({ ok: true, ...(await putComplete(env, body)) });
+      case "heroPresign": return json({ ok: true, ...(await heroPresign(env, body)) });
+      case "presign": return json({ ok: true, ...(await presign(env, body)) });
+      case "record": return json({ ok: true, ...(await record(env, body)) });
+      case "reconcile": return json({ ok: true, parts: await reconcile(env, body) });
+      case "complete": return json({ ok: true, ...(await complete(env, body)) });
+      case "abort": return json({ ok: true, ...(await abort(env, body)) });
+      default: return json({ ok: false, error: "Azione multipart non valida" }, 400);
+    }
+  } catch (e) {
+    console.error("delivery multipart:", e);
+    return json({ ok: false, error: e instanceof Error ? e.message : String(e) }, 500);
+  }
+}
+
+async function heroPresign(env, body) {
+  const deliveryId = String(body.id || "");
+  const packageId = String(body.packageId || "");
+  const pkg = await env.DB.prepare(`
+    SELECT p.* FROM delivery_packages p JOIN deliveries d ON d.id=p.delivery_id
+    WHERE p.id=? AND p.delivery_id=? AND p.state IN ('uploading','ready') AND d.status!='deleted'
+  `).bind(packageId, deliveryId).first();
+  if (!pkg) throw new Error("pacchetto per la hero non trovato");
+  const heroId = crypto.randomUUID();
+  const key = b2ObjectKey(pkg.storage_prefix, `heroes/${heroId}.webp`);
+  const now = new Date().toISOString();
+  await env.DB.prepare(`
+    INSERT INTO delivery_hero_objects
+      (id,delivery_id,package_id,object_key,state,created_at,updated_at)
+    VALUES (?,?,?,?,'pending',?,?)
+  `).bind(heroId, deliveryId, packageId, key, now, now).run();
+  return {
+    heroId, key,
+    url: await b2PresignPutObject(env, key),
+    expiresIn: 900,
+  };
+}
+
+async function putPresign(env, body) {
+  const pkg = await packageFor(env, body);
+  const variant = String(body.variant || "");
+  if (!FILENAMES[variant]) throw new Error("variante upload non valida");
+  if (variant === "web" && !pkg.web_enabled && !pkg.gallery_enabled) {
+    throw new Error("versione web non richiesta");
+  }
+  if (variant === "thumbs" && !pkg.gallery_enabled) throw new Error("gallery non richiesta");
+  const key = b2ObjectKey(pkg.storage_prefix, FILENAMES[variant]);
+  return { url: await b2PresignPutObject(env, key), key, variant, expiresIn: 900 };
+}
+
+async function putComplete(env, body) {
+  const pkg = await packageFor(env, body);
+  const variant = String(body.variant || "");
+  if (!FILENAMES[variant]) throw new Error("variante upload non valida");
+  const key = b2ObjectKey(pkg.storage_prefix, FILENAMES[variant]);
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+  const previous = await env.DB.prepare(
+    "SELECT id FROM delivery_uploads WHERE package_id=? AND variant=?"
+  ).bind(pkg.id, variant).first();
+  if (previous) {
+    await env.DB.batch([
+      env.DB.prepare("DELETE FROM delivery_upload_parts WHERE upload_id=?").bind(previous.id),
+      env.DB.prepare(`
+        UPDATE delivery_uploads SET object_key=?,b2_upload_id='single',state='completed',
+          bytes=?,updated_at=?,completed_at=? WHERE id=?
+      `).bind(key, Number(body.bytes || 0), now, now, previous.id),
+    ]);
+    return { uploadId: previous.id, key, bytes: Number(body.bytes || 0) };
+  }
+  await env.DB.prepare(`
+    INSERT INTO delivery_uploads
+      (id,delivery_id,package_id,variant,object_key,b2_upload_id,bytes,state,created_at,updated_at,completed_at)
+    VALUES (?,?,?,?,?,'single',?,'completed',?,?,?)
+  `).bind(id, pkg.delivery_id, pkg.id, variant, key, Number(body.bytes || 0), now, now, now).run();
+  return { uploadId: id, key, bytes: Number(body.bytes || 0) };
+}
+
+async function create(env, body) {
+  const pkg = await packageFor(env, body);
+  const variant = String(body.variant || "");
+  if (!FILENAMES[variant]) throw new Error("variante multipart non valida");
+  if (variant === "web" && !pkg.web_enabled && !pkg.gallery_enabled) {
+    throw new Error("versione web non richiesta");
+  }
+  if (variant === "thumbs" && !pkg.gallery_enabled) throw new Error("gallery non richiesta");
+
+  const previous = await env.DB.prepare(
+    "SELECT * FROM delivery_uploads WHERE package_id=? AND variant=?"
+  ).bind(pkg.id, variant).first();
+  if (previous?.state === "uploading") {
+    return normalizeUpload(previous);
+  }
+  if (previous?.state === "completed") {
+    return normalizeUpload(previous);
+  }
+  const key = b2ObjectKey(pkg.storage_prefix, FILENAMES[variant]);
+  const b2UploadId = await b2CreateMultipart(env, key);
+  const now = new Date().toISOString();
+  const id = previous?.id || crypto.randomUUID();
+  if (previous) {
+    await env.DB.batch([
+      env.DB.prepare("DELETE FROM delivery_upload_parts WHERE upload_id=?").bind(id),
+      env.DB.prepare(`
+        UPDATE delivery_uploads SET object_key=?,b2_upload_id=?,state='uploading',
+          created_at=?,updated_at=?,completed_at=NULL WHERE id=?
+      `).bind(key, b2UploadId, now, now, id),
+    ]);
+  } else {
+    await env.DB.prepare(`
+      INSERT INTO delivery_uploads
+        (id,delivery_id,package_id,variant,object_key,b2_upload_id,state,created_at,updated_at)
+      VALUES (?,?,?,?,?,?,'uploading',?,?)
+    `).bind(id, pkg.delivery_id, pkg.id, variant, key, b2UploadId, now, now).run();
+  }
+  return { id, deliveryId: pkg.delivery_id, packageId: pkg.id, variant, key, state: "uploading" };
+}
+
+async function presign(env, body) {
+  const upload = await uploadFor(env, body);
+  const partNumber = Number(body.partNumber);
+  if (!Number.isInteger(partNumber) || partNumber < 1 || partNumber > 10_000) {
+    throw new Error("numero parte non valido");
+  }
+  return {
+    url: await b2PresignUploadPart(env, upload.object_key, upload.b2_upload_id, partNumber),
+    partNumber,
+    expiresIn: 900,
+  };
+}
+
+async function record(env, body) {
+  const upload = await uploadFor(env, body);
+  const partNumber = Number(body.partNumber);
+  const size = Number(body.size);
+  const etag = String(body.etag || "").trim();
+  const digest = String(body.digest || "").trim();
+  if (!Number.isInteger(partNumber) || partNumber < 1 || !Number.isFinite(size) || size < 1 || !etag) {
+    throw new Error("metadati parte non validi");
+  }
+  const now = new Date().toISOString();
+  await env.DB.batch([
+    env.DB.prepare(`
+      INSERT INTO delivery_upload_parts(upload_id,part_number,etag,digest,size,created_at)
+      VALUES (?,?,?,?,?,?)
+      ON CONFLICT(upload_id,part_number) DO UPDATE SET
+        etag=excluded.etag,digest=excluded.digest,size=excluded.size,created_at=excluded.created_at
+    `).bind(upload.id, partNumber, etag, digest || null, size, now),
+    env.DB.prepare("UPDATE delivery_uploads SET updated_at=? WHERE id=?").bind(now, upload.id),
+  ]);
+  return { partNumber, etag, size };
+}
+
+async function reconcile(env, body) {
+  const upload = await uploadFor(env, body);
+  const parts = await b2ListParts(env, upload.object_key, upload.b2_upload_id);
+  const now = new Date().toISOString();
+  for (let at = 0; at < parts.length; at += 50) {
+    await env.DB.batch(parts.slice(at, at + 50).map((part) => env.DB.prepare(`
+      INSERT INTO delivery_upload_parts(upload_id,part_number,etag,size,created_at)
+      VALUES (?,?,?,?,?)
+      ON CONFLICT(upload_id,part_number) DO UPDATE SET
+        etag=excluded.etag,size=excluded.size,created_at=excluded.created_at
+    `).bind(upload.id, part.partNumber, part.etag, part.size, now)));
+  }
+  const saved = await env.DB.prepare(
+    "SELECT part_number,etag,digest,size FROM delivery_upload_parts WHERE upload_id=? ORDER BY part_number"
+  ).bind(upload.id).all();
+  return (saved.results || []).map((part) => ({
+    partNumber: Number(part.part_number), etag: part.etag,
+    digest: part.digest || "", size: Number(part.size),
+  }));
+}
+
+async function complete(env, body) {
+  const upload = await uploadFor(env, body);
+  /* ListParts è la fonte autorevole: una PUT può riuscire e la successiva chiamata
+     `record` interrompersi. Riconciliare sempre evita di lasciare fuori quella parte. */
+  await reconcile(env, body);
+  const { results } = await env.DB.prepare(
+    "SELECT part_number,etag,size FROM delivery_upload_parts WHERE upload_id=? ORDER BY part_number"
+  ).bind(upload.id).all();
+  if (!results?.length) throw new Error("nessuna parte caricata");
+  const parts = results.map((p) => ({
+    partNumber: Number(p.part_number), etag: p.etag, size: Number(p.size),
+  }));
+  const answer = await b2CompleteMultipart(env, upload.object_key, upload.b2_upload_id, parts);
+  const now = new Date().toISOString();
+  await env.DB.prepare(
+    "UPDATE delivery_uploads SET state='completed',bytes=?,completed_at=?,updated_at=? WHERE id=?"
+  ).bind(parts.reduce((n, p) => n + p.size, 0), now, now, upload.id).run();
+  return { uploadId: upload.id, key: upload.object_key, bytes: parts.reduce((n, p) => n + p.size, 0), ...answer };
+}
+
+async function abort(env, body) {
+  const upload = await uploadFor(env, body, false);
+  if (!upload) return { aborted: false };
+  await b2AbortMultipart(env, upload.object_key, upload.b2_upload_id);
+  await env.DB.prepare("UPDATE delivery_uploads SET state='aborted',updated_at=? WHERE id=?")
+    .bind(new Date().toISOString(), upload.id).run();
+  return { aborted: true };
+}
+
+async function packageFor(env, body) {
+  const pkg = await env.DB.prepare(`
+    SELECT p.* FROM delivery_packages p JOIN deliveries d ON d.id=p.delivery_id
+    WHERE p.id=? AND p.delivery_id=? AND p.state='uploading' AND d.status!='deleted'
+  `).bind(String(body.packageId || ""), String(body.id || "")).first();
+  if (!pkg) throw new Error("pacchetto in caricamento non trovato");
+  return pkg;
+}
+
+async function uploadFor(env, body, required = true) {
+  const upload = await env.DB.prepare(`
+    SELECT u.* FROM delivery_uploads u
+    JOIN delivery_packages p ON p.id=u.package_id
+    JOIN deliveries d ON d.id=u.delivery_id
+    WHERE u.id=? AND u.state='uploading' AND p.state='uploading' AND d.status!='deleted'
+  `).bind(String(body.uploadId || "")).first();
+  if (!upload && required) throw new Error("sessione multipart non trovata");
+  return upload;
+}
+
+function normalizeUpload(row) {
+  return {
+    id: row.id, deliveryId: row.delivery_id, packageId: row.package_id,
+    variant: row.variant, key: row.object_key, state: row.state,
+  };
+}
+
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status, headers: { "Content-Type": "application/json", "Cache-Control": "no-store" },
+  });
+}

package/dist/functions/api/pages/get.js

@@ -0,0 +1,26 @@
+/* GET /admin/api/pages/get?slug=<slug> — corpo (markdown) e front matter di una
+ * pagina, letti dal repo. Usato dall'editor pagina. Dietro Access.
+ */
+import { json } from "../../_shared/assets.js";
+import { getText } from "../../_shared/github.js";
+import { splitFrontMatter, deserializeItem } from "../../../index.js";
+import { site } from "../../site.js";
+
+export async function onRequestGet({ request, env }) {
+  if (!env.GITHUB_TOKEN || !env.GITHUB_REPO) return json({ ok: false, error: "backend GitHub non configurato" }, 500);
+  const slug = new URL(request.url).searchParams.get("slug") || "";
+  if (!/^[a-z0-9-]+$/.test(slug)) return json({ ok: false, error: "slug non valido" }, 400);
+
+  const text = await getText(env, `content/${slug}/index.md`);
+  if (text == null) return json({ ok: false, error: "pagina non trovata" }, 404);
+
+  const { body: rawBody } = splitFrontMatter(text);
+  const body = (rawBody ?? text).replace(/^\n+/, "").replace(/\s+$/, "");
+
+  // Il front matter lo legge lo schema, non uno scanner di righe scritto qui: prima questo
+  // file aveva la sua interpretazione, diversa da quella del serializzatore, e due letture
+  // dello stesso formato sono due occasioni di divergere.
+  const model = deserializeItem(text, site().page, { slug });
+
+  return json({ ok: true, slug, body, page: model });
+}

package/dist/functions/api/pages.js

@@ -0,0 +1,354 @@
+/* GET·POST /admin/api/pages
+ *
+ * GET  — l'elenco delle pagine letto dal repo (vedi il commento sopra `onRequestGet`).
+ * POST — riceve dall'admin l'elenco DESIDERATO e lo riscrive nel repo in un solo commit atomico
+ *        (Git Data API): crea/aggiorna `content/<slug>/index.md`, gestisce i rename via `_orig`,
+ *        elimina le cartelle non più presenti.
+ *
+ * Si scrive sul branch di BOZZA, quindi un salvataggio NON fa partire nessuna build e il sito
+ * online non cambia: a mandarlo online è `publish.js`, ed è un gesto a parte.
+ *
+ * La serializzazione NON è più qui: la fa il codec del kit, guidato dallo schema del sito. Questo
+ * file si occupa solo di parlare con GitHub. Ciò che prima era `MANAGED` + `buildMarkdown` —
+ * cioè la conoscenza di quali campi esistono e come si scrivono — vive ora in un posto solo,
+ * insieme alla conoscenza di come si mostrano nell'admin.
+ *
+ * Sta dietro Cloudflare Access E dietro la verifica del JWT in functions/admin/_middleware.js.
+ * Secret/vars: GITHUB_TOKEN (secret), GITHUB_REPO, GITHUB_BRANCH.
+ */
+import { serializeItem, deserializeItem, checkFidelity } from "../../index.js";
+import { site } from "../site.js";
+import { getRepoSnapshot, getText, DRAFT } from "../_shared/github.js";
+
+const GH = "https://api.github.com";
+
+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 || {}),
+    },
+  });
+}
+
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+const decode64 = (b64) => decodeURIComponent(escape(atob(String(b64 || "").replace(/\n/g, ""))));
+
+async function readFile(env, repo, branch, path) {
+  const res = await gh(env, `/repos/${repo}/contents/${path}?ref=${branch}`);
+  if (!res.ok) return null;
+  const j = await res.json();
+  return decode64(j.content);
+}
+
+/** `type:` di un file, senza parsare tutto: serve solo a non cancellare ciò che non è nostro. */
+function typeOf(md) {
+  const m = (md || "").match(/^---\n([\s\S]*?)\n---/);
+  const t = m && m[1].match(/^type:\s*(.+)$/m);
+  return t ? t[1].trim().replace(/^["']|["']$/g, "") : "";
+}
+
+/* GET /admin/api/pages — l'elenco delle pagine, letto DAL REPO.
+ *
+ * Prima l'admin partiva da `/index.json`, cioè dal sito PUBBLICATO: un file costruito
+ * dall'ultima build, quindi indietro di una build. Nei minuti dopo un salvataggio — o in una
+ * scheda lasciata aperta da un'ora — mostrava lo stato di prima, e modificare partendo da lì
+ * riscriveva la pagina con quei valori vecchi: quello che era stato salvato nel frattempo
+ * spariva, senza un errore da nessuna parte. È la «finestra di ricostruzione» di ADMIN.md §3,
+ * ed è già costata delle card appena aggiunte a un lavoro del portfolio.
+ *
+ * Leggendo dal repo quella finestra non esiste: non c'è niente da tamponare, perché non c'è
+ * niente di stantio. In più l'albero porta con sé lo `sha` di ogni file, che è ciò che permette
+ * di accorgersi se qualcuno ha modificato la stessa pagina nel frattempo (vedi il POST).
+ *
+ * Si usa `getRepoSnapshot` e non `readAllPages`, che pure esiste: servono anche gli `sha`, e
+ * quella funzione rifarebbe la stessa chiamata all'albero per conto suo. Tutti i file si leggono
+ * dallo STESSO commit, così l'elenco non può essere un misto di due momenti diversi.
+ */
+export async function onRequestGet({ env }) {
+  if (!env.GITHUB_TOKEN || !env.GITHUB_REPO) {
+    return json({ ok: false, error: "Backend non configurato (GITHUB_TOKEN/GITHUB_REPO mancanti)." }, 500);
+  }
+  try {
+    const snapshot = await getRepoSnapshot(env);
+    const blobs = snapshot.tree.filter((t) => t.type === "blob" && site().isManagedPath(t.path));
+
+    const letti = await Promise.all(blobs.map(async (t) => {
+      const text = await getText(env, t.path, snapshot.commitSha);
+      if (text == null) return null;
+      // Stesso filtro del manifest: un tipo escluso non si mostra E non si cancella. Prima i
+      // due criteri erano scritti in due posti e coincidevano solo per caso.
+      if (site().excludedTypes.includes(typeOf(text))) return null;
+      const slug = t.path.split("/")[1];
+      return { slug, url: `/${slug}/`, sha: t.sha, page: deserializeItem(text, site().page, { slug }) };
+    }));
+
+    const pages = letti.filter(Boolean)
+      .sort((a, b) => Number(a.page.weight ?? 0) - Number(b.page.weight ?? 0));
+
+    return json({ ok: true, commit: snapshot.commitSha, pages });
+  } catch (err) {
+    return json({ ok: false, error: String((err && err.message) || err) }, 502);
+  }
+}
+
+export async function onRequestPost({ request, env, data }) {
+  if (!env.GITHUB_TOKEN || !env.GITHUB_REPO) {
+    return json({ ok: false, error: "Backend non configurato (GITHUB_TOKEN/GITHUB_REPO mancanti)." }, 500);
+  }
+  const repo = env.GITHUB_REPO;
+  const branch = env.GITHUB_BRANCH || DRAFT;
+  // L'email viene dal JWT VERIFICATO dal middleware, non dall'header omonimo: quello lo scrive
+  // chiunque con un curl, e qui finisce nel messaggio di commit — l'unica traccia di chi ha
+  // cambiato cosa.
+  const editor = data?.cloudflareAccess?.JWT?.payload?.email || "admin";
+
+  let body;
+  try { body = await request.json(); } catch { return json({ ok: false, error: "JSON non valido" }, 400); }
+  const pages = Array.isArray(body.pages) ? body.pages : null;
+  if (!pages) return json({ ok: false, error: "Campo 'pages' mancante" }, 400);
+
+  // Il peso si RICALCOLA dalla posizione, non si prende dal client: è il server a decidere
+  // l'ordine, e l'ordine è ciò che l'utente ha espresso trascinando.
+  pages.forEach((p, i) => { p.weight = site().positionWeight(p, i, pages); });
+
+  /* IL CANCELLO. Questo endpoint scrive contenuti nel repo, e fino a qui l'unico controllo era
+   * la forma dello slug: tutto il resto —
+   * `type`, `sections`, `works` — diventava YAML e commit senza che nessuno lo guardasse. Ci
+   * sono già passate una card del portfolio con `type: ""` (invisibile sul sito, valore che non
+   * corrisponde a nessun ramo del template) e il rischio di un `info: ""` al posto di `[]`:
+   * valori sintatticamente validi e di FORMA sbagliata, che nessuna delle difese esistenti
+   * intercetta. La guardia di fedeltà risponde a un'altra domanda — «so riprodurre il file
+   * VECCHIO che sto per sovrascrivere?» — e `validate-content.mjs` gira in CI in parallelo alla
+   * build, cioè dice che il sito è sbagliato quando è già online.
+   *
+   * Si valida DOPO il ricalcolo dei pesi, non prima: l'invariante da garantire è «non
+   * scriviamo mai un modello non valido», e il modello che viene scritto è questo.
+   *
+   * `r.data` non si usa MAI: `z.object` scarta le chiavi che non dichiara, e «un campo non
+   * dichiarato sopravvive comunque» è una regola del progetto (ADMIN.md §5) — serializzare il
+   * risultato del parse la romperebbe in silenzio. Si valida l'oggetto e si serializza quello. */
+  const problems = [];
+  for (const p of pages) {
+    const r = site().pagePayload.safeParse(p);
+    if (r.success) continue;
+    const detail = r.error.issues.slice(0, 5)
+      .map((i) => `${i.path.join(".") || "?"} ${i.message}`).join("; ");
+    problems.push({ slug: typeof p?.slug === "string" ? p.slug : "?", detail });
+  }
+  if (problems.length) {
+    // Tutto o niente, come già fa `unreadable`: il commit è atomico, e un rifiuto parziale
+    // lascerebbe metà delle modifiche a terra senza che nessuno sappia quali.
+    return json({
+      ok: false,
+      code: "invalid",
+      error: "Contenuti non validi, non ho salvato nulla:\n" +
+        problems.map((p) => `${p.slug}: ${p.detail}`).join("\n"),
+      slugs: problems.map((p) => p.slug),
+    }, 400);
+  }
+
+  try {
+    const result = await commitPages({ env, repo, branch, editor, pages });
+    return json(result.body, result.status);
+  } catch (err) {
+    return json({ ok: false, error: String((err && err.message) || err) }, 502);
+  }
+}
+
+async function commitPages(args, attempt = 0) {
+  const { env, repo, branch, editor, pages } = args;
+
+  // 1) ref -> commit base -> tree base
+  const refRes = await gh(env, `/repos/${repo}/git/ref/heads/${branch}`);
+  if (!refRes.ok) throw new Error(`ref ${refRes.status}: ${await refRes.text()}`);
+  const baseCommitSha = (await refRes.json()).object.sha;
+  const commitRes = await gh(env, `/repos/${repo}/git/commits/${baseCommitSha}`);
+  const baseTreeSha = (await commitRes.json()).tree.sha;
+
+  // 2) file di contenuto esistenti. `isManagedPath` viene dallo SCHEMA ed è lo stesso predicato
+  //    che usa il manifest: prima il manifest escludeva per `type` e la spazzata filtrava per
+  //    forma del path, e coincidevano solo per caso.
+  const treeRes = await gh(env, `/repos/${repo}/git/trees/${baseTreeSha}?recursive=1`);
+  const tree = (await treeRes.json()).tree || [];
+  const managed = tree.filter((t) => site().isManagedPath(t.path));
+  const existingSlugs = new Set(managed.map((t) => t.path.split("/")[1]));
+  const shaOf = new Map(managed.map((t) => [t.path.split("/")[1], t.sha]));
+
+  /* CONTROLLO DI VERSIONE PER FILE. Il client dice da quale versione è partito (`_sha`, lo sha
+   * del blob che gli ha dato l'elenco); se quel file nel frattempo è cambiato, la sua copia è
+   * vecchia e sovrascriverla cancellerebbe il lavoro di qualcun altro.
+   *
+   * È il caso che ADMIN.md §3 dichiarava scoperto: due schede aperte sulla STESSA pagina,
+   * entrambe modificate, vince l'ultima che salva. Non lo copriva nessuna delle due difese —
+   * spedire solo ciò che si è toccato protegge le pagine che NON si sono aperte, non quella che
+   * si sta scrivendo.
+   *
+   * Si guarda solo lo slug di partenza (`_orig` per un rename): una pagina nuova non ha una
+   * versione da confrontare, e `_sha` assente significa "non controllare", così un client che
+   * non lo manda continua a funzionare. */
+  const stale = [];
+  for (const p of pages) {
+    if (!p._sha) continue;
+    const sourceSlug = existingSlugs.has(p.slug) ? p.slug : (p._orig || p.slug);
+    const attuale = shaOf.get(sourceSlug);
+    if (attuale && attuale !== p._sha) stale.push(sourceSlug);
+  }
+  if (stale.length) {
+    // Tutto o niente come gli altri rifiuti: il commit è atomico, e salvarne metà lascerebbe a
+    // terra l'altra metà senza che nessuno sappia quale.
+    return {
+      status: 409,
+      body: {
+        ok: false,
+        code: "stale",
+        error: stale.length === 1
+          ? `La pagina "${stale[0]}" è stata modificata altrove dopo che l'hai aperta. Non ho ` +
+            `salvato nulla: ricarica per vedere la versione aggiornata.`
+          : `Queste pagine sono state modificate altrove dopo che le hai aperte: ` +
+            `${stale.join(", ")}. Non ho salvato nulla: ricarica per vedere le versioni aggiornate.`,
+        slugs: stale,
+      },
+    };
+  }
+
+  // 3) entry del nuovo tree
+  const entries = [];
+  const desiredSlugs = new Set();
+  const rejected = [];
+
+  for (const p of pages) {
+    desiredSlugs.add(p.slug);
+    const sourceSlug = existingSlugs.has(p.slug)
+      ? p.slug
+      : (p._orig && existingSlugs.has(p._orig) ? p._orig : null);
+    const oldMd = sourceSlug
+      ? await readFile(env, repo, branch, `content/${sourceSlug}/index.md`)
+      : null;
+
+    // GUARDIA DI FEDELTÀ: se non sappiamo riprodurre il file che stiamo per sovrascrivere,
+    // non lo sovrascriviamo. Intercetta i costrutti che il lettore del front matter non regge
+    // e trasforma una corruzione silenziosa in un rifiuto visibile.
+    if (oldMd) {
+      const f = checkFidelity(oldMd, site().page, { slug: sourceSlug });
+      if (!f.ok) { rejected.push(sourceSlug); continue; }
+    }
+
+    entries.push({
+      path: `content/${p.slug}/index.md`,
+      mode: "100644",
+      type: "blob",
+      content: serializeItem(p, {
+        shape: site().page,
+        oldMd,
+        // Solo per i tipi che un corpo ce l'hanno: su una gallery il segnaposto sarebbe
+        // testo scritto nel repo che non compare da nessuna parte (vedi hasBody).
+        placeholderBody: site().hasBody(p.type)
+          ? (m) => `Placeholder content for **${m.title || p.slug}**.`
+          : undefined,
+      }),
+    });
+  }
+
+  if (rejected.length) {
+    return {
+      status: 409,
+      body: {
+        ok: false,
+        code: "unreadable",
+        error:
+          `Non riesco a riprodurre fedelmente ${rejected.join(", ")}: il file contiene qualcosa ` +
+          `che il lettore del front matter non gestisce. Per non rischiare di corromperlo non ho ` +
+          `salvato NULLA. Vanno sistemati a mano.`,
+        slugs: rejected,
+      },
+    };
+  }
+
+  // 4) cancellazioni. Un file che non è nell'elenco desiderato viene rimosso — ma solo dopo
+  //    aver controllato che sia davvero una pagina dell'admin: un sito può dichiarare tipi
+  //    ESCLUSI (banchi di prova, pagine tecniche) che il manifest non mostra, e cancellarli
+  //    sarebbe un danno silenzioso. In pratica qui non entra quasi mai nessuno, quindi la
+  //    lettura non costa.
+  const skipped = [];
+  for (const slug of existingSlugs) {
+    if (desiredSlugs.has(slug)) continue;
+    const md = await readFile(env, repo, branch, `content/${slug}/index.md`);
+    if (md && site().excludedTypes.includes(typeOf(md))) { skipped.push(slug); continue; }
+    entries.push({ path: `content/${slug}/index.md`, mode: "100644", type: "blob", sha: null });
+  }
+
+  // 5) tree, commit, ref
+  const newTreeRes = await gh(env, `/repos/${repo}/git/trees`, {
+    method: "POST",
+    body: JSON.stringify({ base_tree: baseTreeSha, tree: entries }),
+  });
+  if (!newTreeRes.ok) throw new Error(`tree ${newTreeRes.status}: ${await newTreeRes.text()}`);
+  const newTreeSha = (await newTreeRes.json()).sha;
+
+  const newCommitRes = await gh(env, `/repos/${repo}/git/commits`, {
+    method: "POST",
+    body: JSON.stringify({
+      message: `admin: aggiorna pagine (${editor})`,
+      tree: newTreeSha,
+      parents: [baseCommitSha],
+    }),
+  });
+  if (!newCommitRes.ok) throw new Error(`commit ${newCommitRes.status}: ${await newCommitRes.text()}`);
+  const newCommitSha = (await newCommitRes.json()).sha;
+
+  const patchRes = await gh(env, `/repos/${repo}/git/refs/heads/${branch}`, {
+    method: "PATCH",
+    body: JSON.stringify({ sha: newCommitSha }),
+  });
+
+  if (!patchRes.ok) {
+    // `PATCH /git/refs` senza `force` è fast-forward-only: un 422 qui significa che qualcuno ha
+    // committato mentre stavamo lavorando (un altro salvataggio, o uno spostamento di media,
+    // che passa dallo stesso meccanismo). Prima usciva come un `ref update 422:` illeggibile.
+    // Un tentativo da base fresca, poi si dice all'utente cosa è successo davvero.
+    if (patchRes.status === 422 && attempt === 0) {
+      return commitPages(args, 1);
+    }
+    if (patchRes.status === 422) {
+      return {
+        status: 409,
+        body: {
+          ok: false,
+          code: "conflict",
+          error: "Il sito è stato modificato altrove mentre salvavi. Ricarica la pagina e riprova.",
+        },
+      };
+    }
+    throw new Error(`ref update ${patchRes.status}: ${await patchRes.text()}`);
+  }
+
+  /* Le VERSIONI nuove, da rimandare al client. Dopo questo commit ogni file toccato ha uno `sha`
+   * diverso: senza rispedirli, il salvataggio successivo partirebbe da versioni che non esistono
+   * più e il controllo qui sopra lo rifiuterebbe — cioè il pannello si bloccherebbe da solo dopo
+   * il primo salvataggio. Costa una chiamata, e l'albero serve solo a questo. */
+  const shas = {};
+  try {
+    const t = await gh(env, `/repos/${repo}/git/trees/${newTreeSha}?recursive=1`);
+    if (t.ok) {
+      for (const e of (await t.json()).tree || []) {
+        if (e.type === "blob" && site().isManagedPath(e.path)) shas[e.path.split("/")[1]] = e.sha;
+      }
+    }
+  } catch { /* il salvataggio è andato: senza gli sha il client ricarica, non perde niente */ }
+
+  return {
+    status: 200,
+    body: { ok: true, pushed: true, commit: newCommitSha, files: entries.length, skipped, shas },
+  };
+}