@cardinali-studio/adminkit 1.0.0

package/dist/functions/api/assets/move.js

@@ -0,0 +1,253 @@
+/* POST /admin/api/assets/move — sposta file in un'altra cartella e aggiorna i riferimenti.
+ *
+ * Il protocollo a gruppi è intenzionalmente in due fasi:
+ *   skipRefs   COPIA i file e restituisce la mappa, ma conserva gli originali;
+ *   applyRefs  verifica tutte le copie, aggiorna il repo e solo dopo cancella gli originali.
+ *
+ * Così un errore o una scheda chiusa a metà lascia al massimo dei duplicati. Il sito continua a
+ * trovare i vecchi URL finché il commit non è riuscito, e trova i nuovi quando gli originali
+ * vengono eliminati. R2 e GitHub non offrono una transazione comune: questa sequenza mantiene
+ * vera l'invariante importante senza fingere che la transazione esista.
+ */
+import { json, isKey, isPrefix, uniqueKey } from "../../_shared/assets.js";
+import { mediaUrl } from "../../_shared/refs.js";
+import { rewriteMediaReferences } from "../../_shared/media-content.js";
+import { getBase } from "../../_shared/github.js";
+import { finalizePendingMedia, recordPendingMedia } from "../../_shared/pending-media.js";
+
+function mediaKey(url) {
+  if (typeof url !== "string" || !url.startsWith("/media/")) return null;
+  try {
+    const key = url.slice("/media/".length).split("/").map(decodeURIComponent).join("/");
+    return isKey(key) && mediaUrl(key) === url ? key : null;
+  } catch {
+    return null;
+  }
+}
+
+export function validatedMoveMap(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const entries = [];
+  for (const [oldUrl, newUrl] of Object.entries(value)) {
+    const oldKey = mediaKey(oldUrl);
+    const newKey = mediaKey(newUrl);
+    if (!oldKey || !newKey || oldKey === newKey) return null;
+    entries.push({ oldUrl, newUrl, oldKey, newKey });
+  }
+  return entries;
+}
+
+/** Copia ogni file senza cancellare l'originale. Gli errori di un elemento non nascondono
+ *  la mappa degli elementi già copiati: il client potrà completare quelli riusciti. */
+export async function prepareMoves(bucket, keys, dest) {
+  const urlMap = {};
+  const prepared = [];
+  const failed = [];
+  for (const key of keys) {
+    try {
+      const base = key.split("/").pop();
+      const parent = key.slice(0, key.length - base.length);
+      if (parent === dest) continue;
+      const obj = await bucket.get(key);
+      if (!obj) {
+        failed.push({ key, error: "file non trovato" });
+        continue;
+      }
+      const newKey = await uniqueKey(bucket, dest, base);
+      await bucket.put(newKey, obj.body, {
+        httpMetadata: obj.httpMetadata || {},
+        customMetadata: obj.customMetadata || undefined,
+      });
+      urlMap[mediaUrl(key)] = mediaUrl(newKey);
+      prepared.push({ oldKey: key, newKey });
+    } catch (error) {
+      failed.push({ key, error: error.message || String(error) });
+    }
+  }
+  return { moved: prepared.length, urlMap, prepared, failed };
+}
+
+async function missingCopies(bucket, entries) {
+  const missing = [];
+  for (const entry of entries) {
+    try {
+      if (!await bucket.head(entry.newKey)) missing.push(entry.newKey);
+    } catch {
+      missing.push(entry.newKey);
+    }
+  }
+  return missing;
+}
+
+/** Da chiamare solo dopo il commit dei riferimenti. Un fallimento lascia un duplicato innocuo. */
+export async function finalizeMoves(bucket, entries) {
+  let finalized = 0;
+  const failed = [];
+  for (const entry of entries) {
+    try {
+      await bucket.delete(entry.oldKey);
+      finalized++;
+    } catch (error) {
+      failed.push({ key: entry.oldKey, error: error.message || String(error) });
+    }
+  }
+  return { finalized, failed };
+}
+
+async function abortPrepared(bucket, entries) {
+  for (const entry of entries) {
+    try { await bucket.delete(entry.newKey); } catch { /* l'originale esiste ancora */ }
+  }
+}
+
+function rewriteError(error) {
+  const blocked = Array.isArray(error.blockers) ? error.blockers : undefined;
+  return json({
+    ok: false,
+    code: error.code || "media_refs_failed",
+    error: error.message || String(error),
+    ...(blocked ? { blockers: blocked } : {}),
+  }, error.code === "media_refs_blocked" || error.code === "conflict" ? 409 : 502);
+}
+
+async function confirmRewrittenCommit(env, commitSha) {
+  try {
+    return (await getBase(env)).commitSha === commitSha
+      ? null
+      : json({
+          ok: false,
+          code: "conflict",
+          error: "Il sito è cambiato dopo l'aggiornamento dei riferimenti. Gli originali sono stati conservati.",
+        }, 409);
+  } catch (error) {
+    return json({
+      ok: false,
+      code: "github_read_failed",
+      error: `Non riesco a confermare il commit dei riferimenti: ${error.message || String(error)}`,
+    }, 502);
+  }
+}
+
+export async function onRequestPost({ request, env }) {
+  if (!env.MEDIA) return json({ ok: false, error: "Binding MEDIA non configurato" }, 500);
+  if (!env.GITHUB_TOKEN || !env.GITHUB_REPO) {
+    return json({
+      ok: false,
+      code: "github_unavailable",
+      error: "Non posso spostare media senza aggiornare i riferimenti nel sito.",
+    }, 503);
+  }
+  let body;
+  try { body = await request.json(); } catch { return json({ ok: false, error: "JSON non valido" }, 400); }
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return json({ ok: false, error: "Corpo richiesta non valido" }, 400);
+  }
+
+  /* Seconda fase: le copie esistono già. Prima le verifichiamo TUTTE, poi aggiorniamo il repo,
+   * infine cancelliamo gli originali. */
+  if (Object.hasOwn(body, "applyRefs")) {
+    const entries = validatedMoveMap(body.applyRefs);
+    if (!entries) return json({ ok: false, error: "mappa spostamenti non valida" }, 400);
+    if (!entries.length) return json({ ok: true, moved: 0, pagesUpdated: [], failed: [] });
+
+    const missing = await missingCopies(env.MEDIA, entries);
+    if (missing.length) {
+      return json({
+        ok: false,
+        code: "move_copies_missing",
+        error: `Operazione annullata: ${missing.length} copie di destinazione non sono disponibili.`,
+        missing,
+      }, 409);
+    }
+
+    let rewritten;
+    try {
+      rewritten = await rewriteMediaReferences(
+        env,
+        { map: Object.fromEntries(entries.map((e) => [e.oldUrl, e.newUrl])) },
+        "admin: sposta immagini",
+      );
+    } catch (error) {
+      return rewriteError(error);
+    }
+
+    const conflict = await confirmRewrittenCommit(env, rewritten.verifiedCommit);
+    if (conflict) return conflict;
+    await recordPendingMedia(env.MEDIA, "move", entries, rewritten.verifiedCommit);
+    await finalizePendingMedia(env).catch(() => null);
+    return json({
+      ok: true,
+      moved: entries.length,
+      finalized: 0,
+      failed: [],
+      pagesUpdated: rewritten.labels,
+      warning: "Gli originali resteranno disponibili fino alla prossima pubblicazione.",
+    });
+  }
+
+  let dest = String(body.dest || "").trim();
+  if (dest && !dest.endsWith("/")) dest += "/";
+  if (!dest || !isPrefix(dest) || dest.startsWith("_trash/")) {
+    return json({ ok: false, error: "destinazione non valida" }, 400);
+  }
+
+  const keys = (Array.isArray(body.keys) ? body.keys : [])
+    .filter(isKey)
+    .filter((k) => !k.startsWith("_trash/"));
+  if (!keys.length) return json({ ok: true, moved: 0, urlMap: {}, pagesUpdated: [], failed: [] });
+
+  const prepared = await prepareMoves(env.MEDIA, keys, dest);
+
+  // Prima fase dei gruppi: il chiamante accumula le mappe e chiude con applyRefs.
+  if (body.skipRefs === true) {
+    return json({
+      ok: true,
+      moved: prepared.moved,
+      urlMap: prepared.urlMap,
+      pagesUpdated: [],
+      failed: prepared.failed,
+    });
+  }
+
+  // Compatibilità con la chiamata singola: stessa sequenza sicura, tutta in una richiesta.
+  const entries = prepared.prepared.map((e) => ({
+    ...e,
+    oldUrl: mediaUrl(e.oldKey),
+    newUrl: mediaUrl(e.newKey),
+  }));
+  if (!entries.length) {
+    return json({
+      ok: true,
+      moved: 0,
+      urlMap: prepared.urlMap,
+      pagesUpdated: [],
+      failed: prepared.failed,
+    });
+  }
+
+  let rewritten;
+  try {
+    rewritten = await rewriteMediaReferences(
+      env,
+      { map: prepared.urlMap },
+      "admin: sposta immagini",
+    );
+  } catch (error) {
+    await abortPrepared(env.MEDIA, entries);
+    return rewriteError(error);
+  }
+  const conflict = await confirmRewrittenCommit(env, rewritten.verifiedCommit);
+  if (conflict) return conflict;
+  await recordPendingMedia(env.MEDIA, "move", entries, rewritten.verifiedCommit);
+  await finalizePendingMedia(env).catch(() => null);
+  const failed = [...prepared.failed];
+  return json({
+    ok: true,
+    moved: entries.length,
+    finalized: 0,
+    urlMap: prepared.urlMap,
+    pagesUpdated: rewritten.labels,
+    failed,
+    warning: "Gli originali resteranno disponibili fino alla prossima pubblicazione.",
+  });
+}

package/dist/functions/api/assets/preview.js

@@ -0,0 +1,17 @@
+/* GET /admin/api/assets/preview?key=... — anteprima gated di un oggetto R2
+ * (usata per i thumbnail del cestino, che NON è pubblico). Dietro Access.
+ */
+import { guessMime } from "../../_shared/assets.js";
+
+export async function onRequestGet({ request, env }) {
+  if (!env.MEDIA) return new Response("no binding", { status: 500 });
+  const key = new URL(request.url).searchParams.get("key") || "";
+  if (!key) return new Response("Not found", { status: 404 });
+  const obj = await env.MEDIA.get(key);
+  if (!obj) return new Response("Not found", { status: 404 });
+  const headers = new Headers();
+  obj.writeHttpMetadata(headers);
+  if (!headers.get("Content-Type")) headers.set("Content-Type", guessMime(key));
+  headers.set("Cache-Control", "private, max-age=60");
+  return new Response(obj.body, { headers });
+}

package/dist/functions/api/assets/trash/delete.js

@@ -0,0 +1,13 @@
+/* POST /admin/api/assets/trash/delete — eliminazione DEFINITIVA dal cestino
+ * (senza attendere i 30 giorni). Body: { trashKeys: [...] }. Dietro Access.
+ */
+import { json } from "../../../_shared/assets.js";
+
+export async function onRequestPost({ request, env }) {
+  if (!env.MEDIA) return json({ ok: false, error: "Binding MEDIA non configurato" }, 500);
+  let body;
+  try { body = await request.json(); } catch { return json({ ok: false, error: "JSON non valido" }, 400); }
+  const keys = (body.trashKeys || []).filter((k) => k && k.startsWith("_trash/"));
+  if (keys.length) await env.MEDIA.delete(keys);
+  return json({ ok: true, removed: keys.length });
+}

package/dist/functions/api/assets/trash/empty.js

@@ -0,0 +1,16 @@
+/* POST /admin/api/assets/trash/empty — svuota il cestino (elimina tutto subito,
+ * senza attendere i 30 giorni). Dietro Access.
+ */
+import { json, TRASH, listKeysUnder } from "../../../_shared/assets.js";
+
+export async function onRequestPost({ env }) {
+  if (!env.MEDIA) return json({ ok: false, error: "Binding MEDIA non configurato" }, 500);
+  const keys = await listKeysUnder(env.MEDIA, TRASH);
+  let removed = 0;
+  for (let i = 0; i < keys.length; i += 1000) {
+    const batch = keys.slice(i, i + 1000);
+    await env.MEDIA.delete(batch);
+    removed += batch.length;
+  }
+  return json({ ok: true, removed });
+}

package/dist/functions/api/assets/trash/restore.js

@@ -0,0 +1,43 @@
+/* POST /admin/api/assets/trash/restore — ripristina file dal cestino alla
+ * posizione originale. Se la posizione è occupata, ripristina con suffisso.
+ * Body: { trashKeys: [...] }. Dietro Access.
+ * NB: ripristina il FILE; il riferimento nelle pagine (rimosso all'eliminazione)
+ * va rimesso a mano dall'editor della pagina.
+ */
+import { json } from "../../../_shared/assets.js";
+
+export async function onRequestPost({ request, env }) {
+  if (!env.MEDIA) return json({ ok: false, error: "Binding MEDIA non configurato" }, 500);
+  let body;
+  try { body = await request.json(); } catch { return json({ ok: false, error: "JSON non valido" }, 400); }
+  const keys = (body.trashKeys || []).filter((k) => k && k.startsWith("_trash/"));
+
+  const restored = [], conflicts = [];
+  for (const tk of keys) {
+    const obj = await env.MEDIA.get(tk);
+    if (!obj) continue;
+    const orig = (obj.customMetadata && obj.customMetadata.originalKey) || null;
+    if (!orig) continue;
+    let target = orig;
+    if (await env.MEDIA.head(orig)) {
+      const dot = orig.lastIndexOf(".");
+      const base = dot > 0 ? orig.slice(0, dot) : orig;
+      const ext = dot > 0 ? orig.slice(dot) : "";
+      target = `${base}-ripristinato${ext}`;
+      conflicts.push({ originalKey: orig, restoredAs: target });
+    }
+    const {
+      originalKey: _originalKey,
+      originalName: _originalName,
+      deletedAt: _deletedAt,
+      ...metadata
+    } = obj.customMetadata || {};
+    await env.MEDIA.put(target, obj.body, {
+      httpMetadata: obj.httpMetadata || {},
+      customMetadata: Object.keys(metadata).length ? metadata : undefined,
+    });
+    await env.MEDIA.delete(tk);
+    restored.push(target);
+  }
+  return json({ ok: true, restored, conflicts });
+}

package/dist/functions/api/assets/trash.js

@@ -0,0 +1,28 @@
+/* GET /admin/api/assets/trash — elenca i file nel cestino (con data eliminazione,
+ * chiave originale, anteprima gated). Dietro Access.
+ */
+import { json, TRASH } from "../../_shared/assets.js";
+
+export async function onRequestGet({ env }) {
+  if (!env.MEDIA) return json({ ok: false, error: "Binding MEDIA non configurato" }, 500);
+  const items = [];
+  let cursor;
+  do {
+    const listed = await env.MEDIA.list({ prefix: TRASH, cursor, limit: 1000, include: ["customMetadata", "httpMetadata"] });
+    for (const o of (listed.objects || [])) {
+      const cm = o.customMetadata || {};
+      items.push({
+        trashKey: o.key,
+        originalKey: cm.originalKey || "",
+        name: cm.originalName || o.key.slice(TRASH.length),
+        deletedAt: cm.deletedAt || "",
+        size: o.size,
+        type: (o.httpMetadata && o.httpMetadata.contentType) || "",
+        previewUrl: "/admin/api/assets/preview?key=" + encodeURIComponent(o.key),
+      });
+    }
+    cursor = listed.truncated ? listed.cursor : undefined;
+  } while (cursor);
+  items.sort((a, b) => (a.deletedAt < b.deletedAt ? 1 : -1));
+  return json({ ok: true, items });
+}

package/dist/functions/api/assets/upload.js

@@ -0,0 +1,54 @@
+/* POST /admin/api/assets/upload — carica un file nel bucket.
+ * Header: X-Prefix (cartella di destinazione, es. "food/"), X-Filename, Content-Type.
+ * Corpo: bytes grezzi del file. Dietro Access.
+ */
+import { isPrefix, json, guessMime, uniqueKey } from "../../_shared/assets.js";
+import { extractCapturedAt } from "../../_shared/exif.js";
+import { sizeFromBuffer } from "../../_shared/imagesize.js";
+
+export async function onRequestPost({ request, env }) {
+  if (!env.MEDIA) return json({ ok: false, error: "Binding MEDIA non configurato" }, 500);
+  const prefix = (request.headers.get("X-Prefix") || "").trim();
+  if (!isPrefix(prefix)) return json({ ok: false, error: `prefisso non valido: ${prefix}` }, 400);
+
+  const filename = request.headers.get("X-Filename") || "file";
+  let ctype = request.headers.get("Content-Type") || "";
+
+  const body = await request.arrayBuffer();
+  if (!body || body.byteLength === 0) return json({ ok: false, error: "file vuoto" }, 400);
+
+  const key = await uniqueKey(env.MEDIA, prefix, filename);
+  if (!ctype || ctype === "application/octet-stream") ctype = guessMime(key);
+
+  // data di scatto (EXIF) per l'ordinamento "Data scatto"
+  const custom = {};
+  if (ctype === "image/jpeg") {
+    const cap = extractCapturedAt(body);
+    if (cap) custom.capturedAt = cap;
+  }
+
+  // Dimensioni: si calcolano QUI, una volta sola, e restano nei metadati dell'oggetto.
+  // Servono alle pagine gallery, che le scrivono nel front matter per riservare l'ingombro
+  // esatto di ogni cella. Rileggerle a ogni elenco costerebbe una lettura per file — che è
+  // esattamente quello che faceva il vecchio endpoint pubblico, ed è il motivo per cui aveva
+  // bisogno di una cache all'edge. `move.js` ricopia customMetadata, quindi sopravvivono a
+  // uno spostamento; il ripiego per i file caricati PRIMA di questa modifica sta in assets.js.
+  const wh = sizeFromBuffer(body);
+  if (wh) { custom.w = String(wh[0]); custom.h = String(wh[1]); }
+
+  await env.MEDIA.put(key, body, {
+    httpMetadata: { contentType: ctype },
+    customMetadata: Object.keys(custom).length ? custom : undefined,
+  });
+  return json({
+    ok: true,
+    key,
+    name: key.slice(prefix.length),
+    size: body.byteLength,
+    type: ctype,
+    capturedAt: custom.capturedAt || null,
+    w: wh ? wh[0] : null,
+    h: wh ? wh[1] : null,
+    url: "/media/" + key.split("/").map(encodeURIComponent).join("/"),
+  });
+}

package/dist/functions/api/assets/usage.js

@@ -0,0 +1,41 @@
+/* POST /admin/api/assets/usage — avviso "in uso in queste sorgenti".
+ * Body: { keys?: [...], prefixes?: [...] }. Legge dallo stesso commit pagine,
+ * singleton e impostazioni, poi cerca gli URL /media/<key>.
+ */
+import { json, isKey, isPrefix, listKeysUnder } from "../../_shared/assets.js";
+import { mediaUrl } from "../../_shared/refs.js";
+import {
+  readMediaSources, summarizeMediaUsage, planMediaRewrite,
+} from "../../_shared/media-content.js";
+
+export async function onRequestPost({ request, env }) {
+  if (!env.MEDIA) return json({ ok: false, error: "Binding MEDIA non configurato" }, 500);
+  if (!env.GITHUB_TOKEN || !env.GITHUB_REPO) return json({ ok: false, error: "backend GitHub non configurato" }, 500);
+  let body;
+  try { body = await request.json(); } catch { return json({ ok: false, error: "JSON non valido" }, 400); }
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return json({ ok: false, error: "Corpo richiesta non valido" }, 400);
+  }
+
+  try {
+    const keys = new Set((Array.isArray(body.keys) ? body.keys : []).filter(isKey));
+    for (const pre of (Array.isArray(body.prefixes) ? body.prefixes : []).filter((p) => p && isPrefix(p))) {
+      for (const k of await listKeysUnder(env.MEDIA, pre)) if (!k.endsWith("/.keep")) keys.add(k);
+    }
+    const keyList = [...keys].filter((k) => !k.startsWith("_trash/"));
+    if (!keyList.length) {
+      return json({ ok: true, usage: {}, pages: [], count: 0, selectedCount: 0, blockers: [] });
+    }
+
+    const { sources } = await readMediaSources(env);
+    const summary = summarizeMediaUsage(sources, keyList, mediaUrl);
+    const plan = planMediaRewrite(sources, { removeUrls: keyList.map(mediaUrl) });
+    return json({ ok: true, ...summary, blockers: plan.blockers });
+  } catch (error) {
+    return json({
+      ok: false,
+      code: error.code || "github_read_failed",
+      error: `Non riesco a verificare i riferimenti media: ${error.message || String(error)}`,
+    }, 502);
+  }
+}

package/dist/functions/api/assets.js

@@ -0,0 +1,94 @@
+/* GET /admin/api/assets?prefix=food/ — elenca cartelle e file sotto un prefisso.
+ * Dietro Cloudflare Access (è sotto /admin/*).
+ */
+import { isPrefix, json, listKeysUnder } from "../_shared/assets.js";
+import { sizeFromBucket } from "../_shared/imagesize.js";
+import { pendingSourceKeys } from "../_shared/pending-media.js";
+
+const IMG = /\.(webp|jpe?g|png|avif|gif)$/i;
+
+export async function onRequestGet({ request, env }) {
+  if (!env.MEDIA) return json({ ok: false, error: "Binding MEDIA non configurato" }, 500);
+  const url = new URL(request.url);
+  let prefix = (url.searchParams.get("prefix") || "").trim();
+  if (!isPrefix(prefix)) return json({ ok: false, error: `prefisso non valido: ${prefix}` }, 400);
+  const pending = await pendingSourceKeys(env.MEDIA);
+
+  /* `recursive=1` guarda TUTTO quello che c'è sotto, a qualunque profondità: serve a chi deve
+   * spostare o cancellare una cartella intera, che altrimenti si porterebbe dietro solo il primo
+   * livello e lascerebbe orfano il resto. Restituisce le stesse due liste — cartelle (con la
+   * loro etichetta) e file — così chi chiama non impara una forma nuova. */
+  if (url.searchParams.get("recursive") === "1") {
+    const all = await listKeysUnder(env.MEDIA, prefix);
+    const subPrefixes = new Set();
+    const files = [];
+    for (const k of all) {
+      if (k.startsWith("_trash/") || k.startsWith("_pending-media/") || pending.has(k)) continue;
+      const rel = k.slice(prefix.length);
+      const cut = rel.lastIndexOf("/");
+      if (cut >= 0) {
+        // ogni livello intermedio conta come cartella: a/b/c.jpg dà "a/" e "a/b/"
+        let acc = prefix;
+        for (const seg of rel.slice(0, cut).split("/")) { acc += seg + "/"; subPrefixes.add(acc); }
+      }
+      if (!k.endsWith("/.keep")) files.push({ key: k, name: rel });
+    }
+    const folders = await Promise.all([...subPrefixes].map(async (p) => {
+      const keep = await env.MEDIA.head(p + ".keep");
+      return { prefix: p, name: p.slice(prefix.length).replace(/\/$/, ""), label: keep?.customMetadata?.label || "" };
+    }));
+    return json({ ok: true, prefix, recursive: true, folders, files });
+  }
+
+  const listed = await env.MEDIA.list({ prefix, delimiter: "/", include: ["httpMetadata", "customMetadata"] });
+
+  // `label` è il nome per esteso scelto da chi ha creato la cartella, e sta nei metadati del
+  // suo `.keep` (vedi assets/folder.js). Chi non ce l'ha mostra lo slug, come sempre.
+  const folders = await Promise.all(
+    (listed.delimitedPrefixes || [])
+      .filter((p) => p !== "_trash/" && p !== "_pending-media/")
+      .map(async (p) => {
+        const keep = await env.MEDIA.head(p + ".keep");
+        return {
+          prefix: p,
+          name: p.slice(prefix.length).replace(/\/$/, ""),
+          label: keep?.customMetadata?.label || "",
+        };
+      })
+  );
+
+  // Le DIMENSIONI arrivano dai metadati, dove le scrive upload.js al caricamento. Per i file
+  // messi nel bucket prima che quel codice esistesse i metadati non ci sono: si leggono al volo
+  // dall'intestazione (poche decine di byte a file) invece di lasciarle vuote — senza, le foto
+  // già caricate non sarebbero selezionabili in una gallery, che è il caso di tutte quelle di
+  // oggi. È un ripiego, non la strada normale: una volta ricaricate, il ramo non scatta più.
+  const raw = (listed.objects || [])
+    .filter((o) => o.key !== prefix && !o.key.endsWith("/.keep") && !o.key.endsWith("/") &&
+      !o.key.startsWith("_pending-media/") && !pending.has(o.key));
+
+  const files = await Promise.all(raw.map(async (o) => {
+    const cm = o.customMetadata || {};
+    let w = cm.w ? Number(cm.w) : null;
+    let h = cm.h ? Number(cm.h) : null;
+    if (!(w > 0 && h > 0) && IMG.test(o.key)) {
+      const wh = await sizeFromBucket(env.MEDIA, o.key);
+      if (wh) { w = wh[0]; h = wh[1]; }
+    }
+    return {
+      key: o.key,
+      name: o.key.slice(prefix.length),
+      size: o.size,
+      url: "/media/" + o.key.split("/").map(encodeURIComponent).join("/"),
+      uploaded: o.uploaded,
+      capturedAt: cm.capturedAt || null,
+      type: (o.httpMetadata && o.httpMetadata.contentType) || "",
+      w: w > 0 ? w : null,
+      h: h > 0 ? h : null,
+    };
+  }));
+
+  /* Anche l'etichetta della cartella che si sta guardando: senza, il percorso in alto
+   * mostrerebbe il suo slug — cioè proprio la cosa che l'etichetta serve a nascondere. */
+  const own = prefix ? await env.MEDIA.head(prefix + ".keep") : null;
+  return json({ ok: true, prefix, label: own?.customMetadata?.label || "", folders, files });
+}