@cardinali-studio/adminkit 2.2.10 → 2.2.12

package/dist/deployment.js

@@ -191,13 +191,26 @@ export class D1DeploymentAttemptRepository {
         WHERE draft_revision_id IN (SELECT revision_id FROM content_release_entries WHERE release_id = ?)
           AND document_id IN (SELECT document_id FROM content_release_entries WHERE release_id = ?) AND ${guard}`)
                 .bind(input.now, input.releaseId, input.releaseId, input.attemptId, input.releaseId, input.tokenChecksum, input.now),
+            this.db.prepare(`UPDATE site_access_versions SET state = 'superseded', superseded_at = ?, rollback_expires_at = ?
+        WHERE state = 'active' AND version_id IS NOT (SELECT version_id FROM content_release_site_access WHERE release_id = ?)
+          AND EXISTS (SELECT 1 FROM content_release_site_access WHERE release_id = ?) AND ${guard}`)
+                .bind(input.now, input.now + 7 * 24 * 60 * 60 * 1000, input.releaseId, input.releaseId, input.attemptId, input.releaseId, input.tokenChecksum, input.now),
+            this.db.prepare(`UPDATE site_access_versions SET state = 'active', activated_at = ?
+        WHERE version_id = (SELECT version_id FROM content_release_site_access WHERE release_id = ?) AND state = 'draft' AND ${guard}`)
+                .bind(input.now, input.releaseId, input.attemptId, input.releaseId, input.tokenChecksum, input.now),
+            this.db.prepare(`UPDATE site_access_state SET
+          active_version_id = COALESCE((SELECT version_id FROM content_release_site_access WHERE release_id = ?), active_version_id),
+          draft_version_id = CASE WHEN draft_version_id = (SELECT version_id FROM content_release_site_access WHERE release_id = ?) THEN NULL ELSE draft_version_id END,
+          updated_at = ?
+        WHERE singleton = 1 AND EXISTS (SELECT 1 FROM content_release_site_access WHERE release_id = ?) AND ${guard}`)
+                .bind(input.releaseId, input.releaseId, input.now, input.releaseId, input.attemptId, input.releaseId, input.tokenChecksum, input.now),
             this.db.prepare(`UPDATE production_deployment_attempts SET phase = 'succeeded', active_slot = NULL, updated_at = ?, finished_at = ?
         WHERE attempt_id = ? AND release_id = ? AND phase = 'verifying_canonical' AND ci_claim_token_checksum = ?
           AND ci_claim_expires_at > ? AND EXISTS (SELECT 1 FROM content_site_state WHERE singleton = 1 AND current_release_id = ?)`)
                 .bind(input.now, input.now, input.attemptId, input.releaseId, input.tokenChecksum, input.now, input.releaseId),
         ];
         const results = await this.db.batch(statements);
-        if (results[0]?.meta?.changes !== 1 || results[1]?.meta?.changes !== 1 || results[3]?.meta?.changes !== 1) {
+        if (results[0]?.meta?.changes !== 1 || results[1]?.meta?.changes !== 1 || results[6]?.meta?.changes !== 1) {
             throw new Error("attempt_unavailable");
         }
     }

package/dist/form/media/MediaFolders.d.ts

@@ -9,7 +9,7 @@ export declare function FolderMenu({ lib, prefix, label, openTo }: {
     label: string;
     openTo?: "left" | "auto";
 }): import("react").JSX.Element;
-export declare function MediaFolders({ lib, trash }: {
+export declare function MediaFolders({ lib, trash, settings }: {
     lib: MediaLibrary;
     /** `leave` riporta ai media: dal cestino, cliccare una cartella deve anche USCIRE dal cestino. */
     trash?: {
@@ -17,4 +17,8 @@ export declare function MediaFolders({ lib, trash }: {
         open: () => void;
         leave: () => void;
     };
+    settings?: {
+        active: boolean;
+        open: () => void;
+    };
 }): import("react").JSX.Element;

package/dist/form/media/MediaFolders.js

@@ -63,10 +63,11 @@ export function FolderMenu({ lib, prefix, label, openTo = "left" }) {
                         } }), _jsx("span", { className: "ak-hint", children: "Cambia anche l'indirizzo delle foto dentro. Le pagine del sito vengono aggiornate; i link scritti a mano altrove no." }), _jsxs("div", { className: "mf-menu-row", children: [_jsx("button", { className: "ak-btn ak-btn-primary", disabled: !name.trim(), onClick: () => { close(); void lib.renameFolder(prefix, name); }, children: "Rinomina" }), _jsx("button", { className: "ak-btn ak-btn-quiet", onClick: close, children: "Annulla" })] })] }))] }));
 }
 const IcoTrash = () => (_jsx("svg", { className: "mf-ico", viewBox: "0 0 16 16", width: "15", height: "15", "aria-hidden": "true", children: _jsx("path", { fill: "none", stroke: "currentColor", strokeWidth: "1.4", strokeLinecap: "round", strokeLinejoin: "round", d: "M3 4.5h10M6 4.5V3h4v1.5M4.5 4.5 5 13.5h6l.5-9" }) }));
+const IcoSettings = () => (_jsxs("svg", { className: "mf-ico", viewBox: "0 0 16 16", width: "15", height: "15", "aria-hidden": "true", children: [_jsx("path", { fill: "none", stroke: "currentColor", strokeWidth: "1.35", strokeLinecap: "round", strokeLinejoin: "round", d: "M6.6 2.2h2.8l.4 1.5c.4.2.8.4 1.1.7l1.5-.4 1.4 2.4-1.1 1.1v1l1.1 1.1-1.4 2.4-1.5-.4c-.3.3-.7.5-1.1.7l-.4 1.5H6.6l-.4-1.5a5 5 0 0 1-1.1-.7l-1.5.4-1.4-2.4 1.1-1.1v-1L2.2 6.4 3.6 4l1.5.4c.3-.3.7-.5 1.1-.7l.4-1.5Z" }), _jsx("circle", { cx: "8", cy: "8", r: "2", fill: "none", stroke: "currentColor", strokeWidth: "1.35" })] }));
 /* `trash` è facoltativo perché il cestino è una ROTTA, e le rotte le conosce l'applicazione, non
  * questo componente. Sta qui in fondo, sotto «+ Cartella», perché è l'ultimo posto dove finiscono
  * le foto: nella colonna che elenca dove stanno, non in una barra da un'altra parte. */
-export function MediaFolders({ lib, trash }) {
+export function MediaFolders({ lib, trash, settings }) {
     const [over, setOver] = useState(null);
     const [draggingFolder, setDraggingFolder] = useState(false);
     const canDrop = lib.mode === "manage";
@@ -112,5 +113,5 @@ export function MediaFolders({ lib, trash }) {
                         + (over === f.prefix ? " is-over" : ""), onDragOver: (e) => { if (canDrop) {
                         e.preventDefault();
                         setOver(f.prefix);
-                    } }, onDragLeave: () => setOver((p) => (p === f.prefix ? null : p)), onDrop: drop(f.prefix), children: [_jsxs("button", { className: "mf-open", onClick: () => goTo(f.prefix), children: [_jsx("span", { className: "mf-name", children: f.label || f.name }), f.count != null && _jsx("span", { className: "mf-count", children: f.count })] }), canDrop && _jsx(FolderMenu, { lib: lib, prefix: f.prefix, label: f.label || f.name })] }, f.prefix))) }), draggingFolder && (_jsx("div", { className: "mf-root-drop" + (over === "__root" ? " is-over" : ""), onDragOver: (e) => { e.preventDefault(); setOver("__root"); }, onDragLeave: () => setOver((p) => (p === "__root" ? null : p)), onDrop: drop(""), children: "Porta al primo livello" })), canDrop && (_jsx("button", { className: "ak-btn ak-btn-quiet mf-new", onClick: () => void lib.newFolder(""), children: "+ Cartella" })), trash && (_jsx("ul", { className: "mf-list mf-tail", children: _jsx("li", { className: "mf-item" + (trash.active ? " is-on" : ""), children: _jsxs("button", { className: "mf-open", onClick: trash.open, children: [_jsx(IcoTrash, {}), _jsx("span", { className: "mf-name", children: "Cestino" })] }) }) }))] }));
+                    } }, onDragLeave: () => setOver((p) => (p === f.prefix ? null : p)), onDrop: drop(f.prefix), children: [_jsxs("button", { className: "mf-open", onClick: () => goTo(f.prefix), children: [_jsx("span", { className: "mf-name", children: f.label || f.name }), f.count != null && _jsx("span", { className: "mf-count", children: f.count })] }), canDrop && _jsx(FolderMenu, { lib: lib, prefix: f.prefix, label: f.label || f.name })] }, f.prefix))) }), draggingFolder && (_jsx("div", { className: "mf-root-drop" + (over === "__root" ? " is-over" : ""), onDragOver: (e) => { e.preventDefault(); setOver("__root"); }, onDragLeave: () => setOver((p) => (p === "__root" ? null : p)), onDrop: drop(""), children: "Porta al primo livello" })), canDrop && (_jsx("button", { className: "ak-btn ak-btn-quiet mf-new", onClick: () => void lib.newFolder(""), children: "+ Cartella" })), trash && (_jsx("ul", { className: "mf-list mf-tail", children: _jsx("li", { className: "mf-item" + (trash.active ? " is-on" : ""), children: _jsxs("button", { className: "mf-open", onClick: trash.open, children: [_jsx(IcoTrash, {}), _jsx("span", { className: "mf-name", children: "Cestino" })] }) }) })), settings && (_jsx("ul", { className: "mf-list mf-settings-tail", children: _jsx("li", { className: "mf-item" + (settings.active ? " is-on" : ""), children: _jsxs("button", { className: "mf-open", onClick: settings.open, children: [_jsx(IcoSettings, {}), _jsx("span", { className: "mf-name", children: "Impostazioni" })] }) }) }))] }));
 }

package/dist/form/media/MediaGrid.js

@@ -23,6 +23,15 @@ import { SORT_LABELS } from "./useMediaLibrary.js";
 import { DRAG_TYPE, DRAG_FOLDERS, readDragged, FolderMenu } from "./MediaFolders.js";
 import { Lightbox } from "./Lightbox.js";
 import { UploadDialog } from "./UploadDialog.js";
+const JOURNAL_LABELS = {
+    preparing: "Preparo le copie Media.",
+    ready: "Media pronta: pubblica per applicare la modifica.",
+    blocked_in_use: "Operazione bloccata: una bozza o la versione online usa ancora la sorgente.",
+    bound: "Pubblicazione con Media in corso.",
+    finalizing: "Pubblicazione riuscita: completo la pulizia Media.",
+    completed_with_warning: "Pubblicato con Media da completare.",
+    failed: "Operazione Media interrotta prima della pubblicazione.",
+};
 /* Scaricare più file significa più download: il browser ne consente una raffica breve dallo
  * stesso gesto dell'utente, e non c'è modo di fare uno zip senza un endpoint che lo costruisca. */
 function download(urls) {
@@ -117,7 +126,7 @@ export function MediaGrid({ lib, onPick, onCancel }) {
                     void lib.upload(e.dataTransfer.files);
                 }, children: [dragDepth > 0 && (_jsx("div", { className: "mg-dropzone", children: _jsxs("span", { children: ["Rilascia per caricare in ", _jsx("strong", { children: lib.prefix ? lib.labelOf(lib.prefix) : "Senza cartella" })] }) })), _jsx("header", { className: "mg-bar", children: sel.size === 0 ? (_jsxs(_Fragment, { children: [(manage || lib.multiple) && (_jsxs("label", { className: "mg-all", children: [_jsx("input", { type: "checkbox", checked: false, ref: (el) => { if (el)
                                                 el.indeterminate = false; }, onChange: () => lib.setAll(true) }), _jsx("span", { children: "Seleziona tutto" })] })), _jsx("span", { className: "ak-spacer" }), _jsxs("label", { className: "ak-hint", children: ["ordina per", " ", _jsx("select", { className: "mg-sort", value: lib.sortKey, onChange: (e) => lib.setSort(e.target.value), children: Object.entries(SORT_LABELS).map(([k, l]) => _jsx("option", { value: k, children: l }, k)) }), _jsx("button", { className: "ak-icon", onClick: lib.flipDir, title: "Inverti l'ordine", children: lib.sortDir === "asc" ? "↑" : "↓" })] })] })) : (_jsxs(_Fragment, { children: [_jsxs("label", { className: "mg-all", children: [_jsx("input", { type: "checkbox", checked: allOn, ref: (el) => { if (el)
-                                                el.indeterminate = !allOn; }, onChange: () => lib.setAll(!allOn) }), _jsxs("span", { children: [sel.size, " selezionate"] })] }), !allOn && lib.shown.length > sel.size && (_jsxs("button", { className: "mg-act is-link", onClick: () => lib.setAll(true), children: ["Seleziona tutte le ", lib.shown.length] })), manage && (_jsxs(_Fragment, { children: [lib.shown.some((f) => sel.has(f.key)) && (_jsx("button", { className: "mg-act", onClick: () => download(lib.shown.filter((f) => sel.has(f.key)).map((f) => ({ url: f.url, name: f.name }))), children: "Scarica" })), _jsx(MoveMenu, { lib: lib, keys: [...sel] }), _jsx("button", { className: "mg-act is-danger", onClick: () => void lib.remove([...sel]), children: "Elimina" })] })), _jsx("span", { className: "ak-spacer" }), _jsx("button", { className: "mg-act", onClick: () => lib.setAll(false), children: "Deseleziona" })] })) }), lib.error && _jsx("p", { className: "ak-error", onClick: lib.clearError, children: lib.error }), lib.progress && (_jsxs("p", { className: "mg-progress", children: [lib.progress.verb, " ", lib.progress.done, "/", lib.progress.total, "\u2026 \u2014 non chiudere la pagina"] })), lib.prefix !== "" && (manage || lib.subfolders.length > 0) && (_jsxs("section", { className: "mg-section", children: [_jsxs("div", { className: "mg-section-head", children: [_jsx("h2", { className: "mg-section-title", children: "Cartelle" }), manage && (_jsx("button", { className: "mg-act", onClick: () => void lib.newFolder(lib.prefix), children: "+ Cartella" }))] }), lib.subfolders.length > 0 && (_jsx("div", { className: "mg", children: lib.subfolders.map((f) => (_jsx(FolderCell, { lib: lib, folder: f, manage: manage }, f.prefix))) }))] })), lib.prefix !== "" && (manage || lib.subfolders.length > 0) && lib.shown.length > 0 && (_jsx("h2", { className: "mg-section-title", children: "Foto" })), _jsx("div", { className: "mg", children: lib.shown.map((f, i) => {
+                                                el.indeterminate = !allOn; }, onChange: () => lib.setAll(!allOn) }), _jsxs("span", { children: [sel.size, " selezionate"] })] }), !allOn && lib.shown.length > sel.size && (_jsxs("button", { className: "mg-act is-link", onClick: () => lib.setAll(true), children: ["Seleziona tutte le ", lib.shown.length] })), manage && (_jsxs(_Fragment, { children: [lib.shown.some((f) => sel.has(f.key)) && (_jsx("button", { className: "mg-act", onClick: () => download(lib.shown.filter((f) => sel.has(f.key)).map((f) => ({ url: f.url, name: f.name }))), children: "Scarica" })), _jsx(MoveMenu, { lib: lib, keys: [...sel] }), _jsx("button", { className: "mg-act is-danger", onClick: () => void lib.remove([...sel]), children: "Elimina" })] })), _jsx("span", { className: "ak-spacer" }), _jsx("button", { className: "mg-act", onClick: () => lib.setAll(false), children: "Deseleziona" })] })) }), lib.error && _jsx("p", { className: "ak-error", onClick: lib.clearError, children: lib.error }), manage && lib.mediaOperations.length > 0 && (_jsx("section", { className: "mg-journal", "aria-live": "polite", "aria-label": "Stato operazioni Media", children: lib.mediaOperations.map((operation) => (_jsxs("div", { className: `mg-journal-row is-${operation.state}`, children: [_jsx("span", { className: "mg-journal-badge", children: operation.type === "move" ? "Spostamento" : "Eliminazione" }), _jsx("span", { children: JOURNAL_LABELS[operation.state] ?? "Operazione Media in attesa." }), operation.failedEntries > 0 && _jsxs("span", { className: "ak-hint", children: [operation.failedEntries, " file da riprovare"] }), _jsx("span", { className: "ak-spacer" }), operation.state === "completed_with_warning" && operation.releaseId && (_jsx("button", { className: "mg-act", disabled: lib.busy, onClick: () => void lib.resumeMedia(operation), children: "Riprendi" })), ["preparing", "ready", "blocked_in_use", "failed"].includes(operation.state) && !operation.releaseId && (_jsx("button", { className: "mg-act is-danger", disabled: lib.busy, onClick: () => void lib.cancelMedia(operation), children: "Annulla" }))] }, operation.operationId))) })), lib.progress && (_jsxs("p", { className: "mg-progress", children: [lib.progress.verb, " ", lib.progress.done, "/", lib.progress.total, "\u2026 \u2014 non chiudere la pagina"] })), lib.prefix !== "" && (manage || lib.subfolders.length > 0) && (_jsxs("section", { className: "mg-section", children: [_jsxs("div", { className: "mg-section-head", children: [_jsx("h2", { className: "mg-section-title", children: "Cartelle" }), manage && (_jsx("button", { className: "mg-act", onClick: () => void lib.newFolder(lib.prefix), children: "+ Cartella" }))] }), lib.subfolders.length > 0 && (_jsx("div", { className: "mg", children: lib.subfolders.map((f) => (_jsx(FolderCell, { lib: lib, folder: f, manage: manage }, f.prefix))) }))] })), lib.prefix !== "" && (manage || lib.subfolders.length > 0) && lib.shown.length > 0 && (_jsx("h2", { className: "mg-section-title", children: "Foto" })), _jsx("div", { className: "mg", children: lib.shown.map((f, i) => {
                             const on = sel.has(f.key);
                             return (_jsxs("figure", { className: "mg-item" + (on ? " is-on" : ""), draggable: manage, onDragStart: (e) => {
                                     // Si trascina la SELEZIONE se la foto ne fa parte, altrimenti solo quella.

package/dist/form/media/image-conversion.d.ts

@@ -0,0 +1,14 @@
+export declare const MEDIA_WEBP_EDGE = 2500;
+export declare const MEDIA_WEBP_QUALITY = 0.8;
+export declare function isConvertibleImage(file: File): boolean;
+export declare function webpName(name: string): string;
+export declare function fitLongEdge(width: number, height: number, edge?: number): {
+    width: number;
+    height: number;
+};
+/** La conversione canvas rimuove i metadati. Conserviamo almeno DateTimeOriginal, già usato
+ * dalla libreria per l'ordinamento per scatto, leggendo solo l'inizio del JPEG. */
+export declare function jpegCapturedAt(file: File): Promise<string | null>;
+/** I video e gli altri file non-immagine restano intatti. Retry e fallback all'originale sono
+ * responsabilità della coda: questa funzione fa un singolo tentativo e fallisce in modo netto. */
+export declare function convertMediaImage(file: File): Promise<File>;

package/dist/form/media/image-conversion.js

@@ -0,0 +1,163 @@
+/* Conversione prima dell'upload della libreria Media.
+ *
+ * Sta nel browser: il file originale non attraversa la rete e ogni worker della coda può
+ * convertire e caricare in parallelo. HEIC/HEIF è l'unica eccezione ai codec del browser e
+ * viene decodificato, solo quando serve, dal modulo dedicato caricato dinamicamente.
+ */
+export const MEDIA_WEBP_EDGE = 2500;
+export const MEDIA_WEBP_QUALITY = .8;
+const IMAGE_EXT = /\.(?:avif|bmp|gif|heic|heif|jfif|jpe?g|png|tiff?|webp)$/i;
+const HEIC_EXT = /\.(?:heic|heif)$/i;
+export function isConvertibleImage(file) {
+    return file.type.startsWith("image/") || IMAGE_EXT.test(file.name);
+}
+export function webpName(name) {
+    const base = name.replace(/\.[^./\\]+$/, "") || "immagine";
+    return `${base}.webp`;
+}
+export function fitLongEdge(width, height, edge = MEDIA_WEBP_EDGE) {
+    const scale = Math.min(1, edge / Math.max(width, height));
+    return {
+        width: Math.max(1, Math.round(width * scale)),
+        height: Math.max(1, Math.round(height * scale)),
+    };
+}
+/** La conversione canvas rimuove i metadati. Conserviamo almeno DateTimeOriginal, già usato
+ * dalla libreria per l'ordinamento per scatto, leggendo solo l'inizio del JPEG. */
+export async function jpegCapturedAt(file) {
+    if (!(file.type === "image/jpeg" || /\.(?:jpe?g|jfif)$/i.test(file.name)))
+        return null;
+    try {
+        const buffer = await file.slice(0, 512 * 1024).arrayBuffer();
+        const view = new DataView(buffer);
+        if (view.byteLength < 4 || view.getUint16(0) !== 0xffd8)
+            return null;
+        let offset = 2;
+        while (offset + 12 < view.byteLength) {
+            if (view.getUint8(offset) !== 0xff)
+                return null;
+            const marker = view.getUint8(offset + 1);
+            const length = view.getUint16(offset + 2);
+            if (marker === 0xe1) {
+                const app1 = offset + 4;
+                if (app1 + 14 >= view.byteLength || view.getUint32(app1) !== 0x45786966)
+                    return null;
+                const tiff = app1 + 6;
+                const little = view.getUint16(tiff) === 0x4949;
+                const u16 = (at) => view.getUint16(at, little);
+                const u32 = (at) => view.getUint32(at, little);
+                const ifd0 = tiff + u32(tiff + 4);
+                let exif = 0;
+                for (let i = 0, count = u16(ifd0); i < count; i++) {
+                    const entry = ifd0 + 2 + i * 12;
+                    if (u16(entry) === 0x8769) {
+                        exif = tiff + u32(entry + 8);
+                        break;
+                    }
+                }
+                if (!exif)
+                    return null;
+                for (let i = 0, count = u16(exif); i < count; i++) {
+                    const entry = exif + 2 + i * 12;
+                    if (u16(entry) !== 0x9003)
+                        continue;
+                    const start = tiff + u32(entry + 8);
+                    let raw = "";
+                    for (let j = 0; j < 19 && start + j < view.byteLength; j++)
+                        raw += String.fromCharCode(view.getUint8(start + j));
+                    const match = raw.match(/^(\d{4}):(\d{2}):(\d{2}) (\d{2}):(\d{2}):(\d{2})/);
+                    return match ? `${match[1]}-${match[2]}-${match[3]}T${match[4]}:${match[5]}:${match[6]}` : null;
+                }
+                return null;
+            }
+            if (marker === 0xda || length < 2)
+                return null;
+            offset += 2 + length;
+        }
+    }
+    catch { /* metadati assenti o corrotti: non impediscono una conversione valida */ }
+    return null;
+}
+async function bitmapOf(file) {
+    const heic = HEIC_EXT.test(file.name) || /image\/(?:hei[cf]|heif-sequence)/i.test(file.type);
+    const options = {
+        imageOrientation: "from-image",
+        /* `none` lascerebbe i numeri del profilo sorgente senza trasformazione: disegnarli poi su
+           un canvas sRGB è il percorso classico verso colori slavati o troppo saturi. */
+        colorSpaceConversion: "default",
+        premultiplyAlpha: "default",
+    };
+    if (heic) {
+        /* Prima il codec di sistema: quando Safari/il browser sa leggere HEIC, è la strada che ha
+           accesso completo al suo profilo ICC/NCLX. Il decoder WASM è il ripiego interoperabile. */
+        try {
+            return await createImageBitmap(file, options);
+        }
+        catch { /* HEIC non supportato nativamente */ }
+        /* La variante CSP non usa `unsafe-eval`, vietato normalmente dall'admin. Il chunk grande
+           del decoder non entra nel caricamento iniziale: viene scaricato soltanto al primo HEIC. */
+        const { heicTo } = await import("heic-to/csp");
+        return heicTo({ blob: file, type: "bitmap", options });
+    }
+    return createImageBitmap(file, options);
+}
+async function drawWebp(bitmap, width, height) {
+    if (typeof OffscreenCanvas !== "undefined") {
+        const canvas = new OffscreenCanvas(width, height);
+        /* Il WebP generato dal canvas normalmente non porta con sé il profilo sorgente. Rendendo
+           esplicitamente in sRGB, i pixel sono già corretti; la specifica WebP prescrive sRGB
+           quando ICCP manca. Non copiamo l'ICC originale su pixel ormai convertiti. */
+        const context = canvas.getContext("2d", { alpha: true, colorSpace: "srgb" });
+        if (!context)
+            throw new Error("Canvas 2D non disponibile");
+        context.imageSmoothingEnabled = true;
+        context.imageSmoothingQuality = "high";
+        try {
+            context.drawImage(bitmap, 0, 0, width, height);
+            const blob = await canvas.convertToBlob({ type: "image/webp", quality: MEDIA_WEBP_QUALITY });
+            if (blob.type !== "image/webp")
+                throw new Error("Questo browser non supporta la codifica WebP");
+            return blob;
+        }
+        finally {
+            canvas.width = 1;
+            canvas.height = 1;
+        }
+    }
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const context = canvas.getContext("2d", { alpha: true, colorSpace: "srgb" });
+    if (!context)
+        throw new Error("Canvas 2D non disponibile");
+    context.imageSmoothingEnabled = true;
+    context.imageSmoothingQuality = "high";
+    try {
+        context.drawImage(bitmap, 0, 0, width, height);
+        return await new Promise((resolve, reject) => canvas.toBlob((blob) => blob?.type === "image/webp"
+            ? resolve(blob)
+            : reject(new Error("Questo browser non supporta la codifica WebP")), "image/webp", MEDIA_WEBP_QUALITY));
+    }
+    finally {
+        canvas.width = 1;
+        canvas.height = 1;
+    }
+}
+/** I video e gli altri file non-immagine restano intatti. Retry e fallback all'originale sono
+ * responsabilità della coda: questa funzione fa un singolo tentativo e fallisce in modo netto. */
+export async function convertMediaImage(file) {
+    if (!isConvertibleImage(file))
+        return file;
+    const bitmap = await bitmapOf(file);
+    try {
+        const size = fitLongEdge(bitmap.width, bitmap.height);
+        const blob = await drawWebp(bitmap, size.width, size.height);
+        return new File([blob], webpName(file.name), {
+            type: "image/webp",
+            lastModified: file.lastModified,
+        });
+    }
+    finally {
+        bitmap.close();
+    }
+}

package/dist/form/media/media-upload-queue.d.ts

@@ -0,0 +1,31 @@
+export type MediaUploadState = "running" | "done" | "failed";
+export interface MediaUploadJob {
+    id: string;
+    title: string;
+    prefix: string;
+    state: MediaUploadState;
+    total: number;
+    conversionDone: number;
+    uploadDone: number;
+    converted: number;
+    originals: number;
+    failed: number;
+    autoWebp: boolean;
+    errors: string[];
+}
+interface StartInput {
+    prefix: string;
+    title: string;
+    files: File[];
+    autoWebp: boolean;
+}
+export declare function useMediaUploads(): MediaUploadJob[];
+export declare function useMediaUploadCompletions(): number;
+/** Snapshot non mutabile per diagnostica e test della coda fuori da React. */
+export declare function mediaUploadsSnapshot(): MediaUploadJob[];
+export declare function dismissMediaUpload(id: string): void;
+/** Accoda e torna subito: la finestra di scelta può chiudersi, il lavoro resta nel dock. */
+export declare function startMediaUpload(input: StartInput): string;
+export declare function adaptiveConversionConcurrency(files: File[], enabled?: boolean): number;
+export declare function adaptiveUploadConcurrency(): number;
+export {};

package/dist/form/media/media-upload-queue.js

@@ -0,0 +1,230 @@
+/* Upload persistenti della libreria Media.
+ *
+ * Come per i transfer, lo stato vive fuori da React: cambiare rotta nell'admin non smonta la
+ * conversione, non perde l'avanzamento e non nasconde gli errori. Le due fasi hanno pool
+ * distinti e una coda limitata fra loro: conversione e rete si sovrappongono, ma non si
+ * accumulano in RAM decine di WebP già pronti.
+ */
+import { useSyncExternalStore } from "react";
+import { api, ApiError } from "../../api.js";
+import { convertMediaImage, isConvertibleImage, jpegCapturedAt } from "./image-conversion.js";
+let jobs = [];
+let completions = 0;
+const listeners = new Set();
+function emit() {
+    jobs = [...jobs];
+    for (const listener of listeners)
+        listener();
+}
+function patch(id, change) {
+    jobs = jobs.map((job) => job.id === id ? { ...job, ...change } : job);
+    emit();
+}
+function current(id) {
+    return jobs.find((job) => job.id === id);
+}
+function subscribe(listener) {
+    listeners.add(listener);
+    return () => { listeners.delete(listener); };
+}
+export function useMediaUploads() {
+    return useSyncExternalStore(subscribe, () => jobs, () => jobs);
+}
+export function useMediaUploadCompletions() {
+    return useSyncExternalStore(subscribe, () => completions, () => completions);
+}
+/** Snapshot non mutabile per diagnostica e test della coda fuori da React. */
+export function mediaUploadsSnapshot() { return jobs; }
+export function dismissMediaUpload(id) {
+    jobs = jobs.filter((job) => job.id !== id || job.state === "running");
+    emit();
+}
+/** Accoda e torna subito: la finestra di scelta può chiudersi, il lavoro resta nel dock. */
+export function startMediaUpload(input) {
+    const id = crypto.randomUUID();
+    jobs = [...jobs, {
+            id, title: input.title, prefix: input.prefix, state: "running", total: input.files.length,
+            conversionDone: 0, uploadDone: 0, converted: 0, originals: 0, failed: 0,
+            autoWebp: input.autoWebp, errors: [],
+        }];
+    emit();
+    void run(id, input);
+    return id;
+}
+async function run(id, input) {
+    const conversionWorkers = adaptiveConversionConcurrency(input.files, input.autoWebp);
+    const uploadWorkers = adaptiveUploadConcurrency();
+    /* Due soli elementi pronti: abbastanza per non lasciare la rete in attesa, pochi abbastanza
+     * da non tenere in memoria un intero servizio fotografico già convertito. */
+    const ready = new BoundedQueue(2);
+    let next = 0;
+    const convert = async () => {
+        while (next < input.files.length) {
+            const file = input.files[next++];
+            const prepared = await prepare(file, input.autoWebp);
+            const job = current(id);
+            patch(id, {
+                conversionDone: job.conversionDone + 1,
+                converted: job.converted + (prepared.converted ? 1 : 0),
+                originals: job.originals + (prepared.originalFallback ? 1 : 0),
+                errors: prepared.conversionError
+                    ? appendError(job.errors, `${file.name}: conversione non riuscita, carico l’originale (${prepared.conversionError})`)
+                    : job.errors,
+            });
+            await ready.push(prepared);
+        }
+    };
+    const upload = async () => {
+        for (;;) {
+            const prepared = await ready.shift();
+            if (!prepared)
+                return;
+            try {
+                await uploadWithRetry(input.prefix, prepared.upload, prepared.capturedAt);
+                const job = current(id);
+                patch(id, { uploadDone: job.uploadDone + 1 });
+            }
+            catch (error) {
+                const job = current(id);
+                patch(id, {
+                    uploadDone: job.uploadDone + 1,
+                    failed: job.failed + 1,
+                    errors: appendError(job.errors, `${prepared.source.name}: ${readable(error)}`),
+                });
+            }
+        }
+    };
+    try {
+        const consumers = Array.from({ length: Math.min(uploadWorkers, input.files.length) }, upload);
+        await Promise.all(Array.from({ length: Math.min(conversionWorkers, input.files.length) }, convert));
+        ready.close();
+        await Promise.all(consumers);
+        patch(id, { state: current(id).failed ? "failed" : "done" });
+    }
+    catch (error) {
+        /* Un errore della coda è un guasto nostro, non di una foto. Chiude comunque i consumer e
+           resta visibile: un job "in corso" per sempre sarebbe impossibile da diagnosticare. */
+        ready.close();
+        const job = current(id);
+        patch(id, { state: "failed", failed: Math.max(1, job.failed), errors: appendError(job.errors, readable(error)) });
+    }
+    finally {
+        completions += 1;
+        emit();
+    }
+}
+async function prepare(file, autoWebp) {
+    const capturedAt = await jpegCapturedAt(file);
+    if (!autoWebp || !isConvertibleImage(file)) {
+        return { source: file, upload: file, converted: false, originalFallback: false, capturedAt };
+    }
+    let last;
+    /* Tre tentativi reali. Fra uno e l'altro restituiamo il controllo al browser: dopo una
+     * pressione di memoria può liberare bitmap/canvas chiusi prima di riprovare. */
+    for (let attempt = 1; attempt <= 3; attempt++) {
+        try {
+            const converted = await convertMediaImage(file);
+            return { source: file, upload: converted, converted: true, originalFallback: false, capturedAt };
+        }
+        catch (error) {
+            last = error;
+            if (attempt < 3)
+                await delay(attempt * 180);
+        }
+    }
+    return {
+        source: file, upload: file, converted: false, originalFallback: true,
+        conversionError: readable(last), capturedAt,
+    };
+}
+async function uploadWithRetry(prefix, file, capturedAt) {
+    let last;
+    for (let attempt = 1; attempt <= 3; attempt++) {
+        try {
+            return await api.upload(prefix, file, { capturedAt });
+        }
+        catch (error) {
+            last = error;
+            if (attempt === 3 || !retryable(error))
+                throw error;
+            await delay(attempt * 300);
+        }
+    }
+    throw last;
+}
+function retryable(error) {
+    return !(error instanceof ApiError) || error.status === 408 || error.status === 429 || error.status >= 500;
+}
+export function adaptiveConversionConcurrency(files, enabled = true) {
+    if (!enabled || !files.some(isConvertibleImage))
+        return Math.min(4, Math.max(1, files.length));
+    const cores = typeof navigator === "undefined" ? 4 : navigator.hardwareConcurrency || 4;
+    const memory = typeof navigator === "undefined"
+        ? 4
+        : navigator.deviceMemory || 4;
+    let count = cores >= 12 && memory >= 8 ? 3 : cores >= 6 && memory >= 4 ? 2 : 1;
+    /* Il decoder HEIC ha un buffer compresso, un RGBA completo e il canvas di uscita. Due in
+     * parallelo sono già una quantità importante di memoria anche su una workstation. */
+    if (files.some((file) => /\.(?:heic|heif)$/i.test(file.name)))
+        count = Math.min(count, 2);
+    if (files.some((file) => file.size >= 30 * 1024 * 1024))
+        count = 1;
+    return Math.min(count, Math.max(1, files.length));
+}
+export function adaptiveUploadConcurrency() {
+    if (typeof navigator === "undefined")
+        return 3;
+    const connection = navigator.connection;
+    if (connection?.saveData || connection?.effectiveType === "slow-2g" || connection?.effectiveType === "2g")
+        return 2;
+    const memory = navigator.deviceMemory || 4;
+    return (navigator.hardwareConcurrency || 4) >= 8 && memory >= 8 ? 4 : 3;
+}
+function appendError(errors, next) {
+    /* Nel dock servono esempi utili, non duecento righe. Il conteggio completo resta in `failed`
+       e `originals`; le prime otto dicono quali file guardare. */
+    return errors.length >= 8 ? errors : [...errors, next];
+}
+function readable(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function delay(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }
+class BoundedQueue {
+    capacity;
+    values = [];
+    readers = [];
+    writers = [];
+    closed = false;
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    async push(value) {
+        while (!this.closed && this.values.length >= this.capacity && this.readers.length === 0) {
+            await new Promise((resolve) => this.writers.push(resolve));
+        }
+        if (this.closed)
+            throw new Error("coda Media chiusa");
+        const reader = this.readers.shift();
+        if (reader)
+            reader(value);
+        else
+            this.values.push(value);
+    }
+    async shift() {
+        const value = this.values.shift();
+        if (value) {
+            this.writers.shift()?.();
+            return value;
+        }
+        if (this.closed)
+            return null;
+        return new Promise((resolve) => this.readers.push(resolve));
+    }
+    close() {
+        this.closed = true;
+        for (const reader of this.readers.splice(0))
+            reader(null);
+        for (const writer of this.writers.splice(0))
+            writer();
+    }
+}

package/dist/form/media/useMediaLibrary.d.ts

@@ -1,4 +1,5 @@
 import { type AssetFile, type AssetFolder } from "../../api.js";
+import type { MediaOperationStatus } from "../../media.js";
 export type SortKey = "uploaded" | "capturedAt" | "name" | "size";
 export declare const SORT_LABELS: Record<SortKey, string>;
 export interface MediaLibrary {
@@ -11,6 +12,7 @@ export interface MediaLibrary {
     selected: Set<string>;
     busy: boolean;
     error: string | null;
+    mediaOperations: MediaOperationStatus[];
     /** Avanzamento di un'operazione lunga. `verb` è quello che si sta facendo ("Carico",
      *  "Cestino", "Sposto"): senza, un'attesa di trenta secondi non dice cosa sta succedendo e
      *  chi guarda ricarica la pagina — interrompendo l'operazione a metà. */
@@ -23,6 +25,8 @@ export interface MediaLibrary {
     sortDir: "asc" | "desc";
     uploadOpen: boolean;
     viewing: number | null;
+    autoWebp: boolean;
+    settingsBusy: boolean;
     go(prefix: string): void;
     reload(): void;
     toggle(key: string): void;
@@ -32,6 +36,7 @@ export interface MediaLibrary {
     /** Vero se sono passati tutti: chi ha aperto un dialogo lo chiude solo in quel caso. */
     upload(files: File[] | FileList): Promise<boolean>;
     setUploadOpen(open: boolean): void;
+    setAutoWebp(on: boolean): Promise<void>;
     view(i: number | null): void;
     step(delta: number): void;
     /** File e cartelle insieme: una cartella si riconosce dalla chiave, che finisce con "/". */
@@ -43,6 +48,8 @@ export interface MediaLibrary {
     renameFolder(prefix: string, label: string): Promise<void>;
     /** Cestina la cartella e tutto ciò che contiene. */
     removeFolder(prefix: string): Promise<void>;
+    resumeMedia(operation: MediaOperationStatus): Promise<void>;
+    cancelMedia(operation: MediaOperationStatus): Promise<void>;
     /** Il nome da mostrare per un prefisso: l'etichetta se c'è, altrimenti lo slug. */
     labelOf(prefix: string): string;
     clearError(): void;