@materializecms/server 0.8.0 → 0.9.0

package/src/lang.d.ts

@@ -0,0 +1,7 @@
+import { type Lang } from '@materializecms/core/lang';
+import type { MiddlewareHandler } from 'hono';
+export declare const requestLang: MiddlewareHandler;
+/** The profile's language, when the request did not say one. */
+export declare function useProfileLang(locale: unknown): void;
+/** Runs some work in a given language: an email to someone else, a scheduled job. */
+export declare const withLang: <T>(lang: Lang, work: () => T) => T;

package/src/lang.js

@@ -0,0 +1,17 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { isLang, setScopedLang } from '@materializecms/core/lang';
+const store = new AsyncLocalStorage();
+setScopedLang(() => store.getStore()?.lang);
+export const requestLang = (c, next) => {
+    // A download link can't send headers: it says the language in the address (?lang=en).
+    const header = c.req.header('x-mz-lang') ?? c.req.query('lang');
+    return store.run(isLang(header) ? { lang: header, chosen: true } : { chosen: false }, next);
+};
+/** The profile's language, when the request did not say one. */
+export function useProfileLang(locale) {
+    const s = store.getStore();
+    if (s && !s.chosen && isLang(locale))
+        s.lang = locale;
+}
+/** Runs some work in a given language: an email to someone else, a scheduled job. */
+export const withLang = (lang, work) => store.run({ lang, chosen: true }, work);

package/src/mail.d.ts

@@ -1,3 +1,4 @@
+import { type Lang } from '@materializecms/core/lang';
 /** Outgoing email settings, saved in the panel. The password never goes back to the browser. */
 export interface MailSettings {
     host: string;
@@ -34,8 +35,11 @@ export declare function sendMail(m: MailSettings, message: {
     replyTo?: string;
     headers?: Record<string, string>;
 }): Promise<void>;
-/** A message from a site form as plain text: one "Label: value" per field. */
-export declare function submissionText(page: string, data: Record<string, string>): string;
+/**
+ * A message from a site form as plain text: one "Label: value" per field. It goes to the site's
+ * owner, in `lang` (the current language by default).
+ */
+export declare function submissionText(page: string, data: Record<string, string>, lang?: Lang): string;
 /** Whether the server answers on a port at all: the way to tell a blocked port from a wrong setting. */
 export declare function portOpen(host: string, port: number, timeout?: number): Promise<boolean>;
 export interface MailProblem {

package/src/mail.js

@@ -1,7 +1,9 @@
 import { Resolver } from 'node:dns/promises';
 import { connect } from 'node:net';
+import { currentLang } from '@materializecms/core/lang';
 import { COMMON_DKIM, providerByHost, providerById } from '@materializecms/core/mail';
 import nodemailer from 'nodemailer';
+import { t } from './t.js';
 export const EMPTY_MAIL = {
     host: '',
     port: 587,
@@ -32,10 +34,16 @@ export async function sendMail(m, message) {
     });
     await transport.sendMail({ from: m.from, ...message });
 }
-/** A message from a site form as plain text: one "Label: value" per field. */
-export function submissionText(page, data) {
+/**
+ * A message from a site form as plain text: one "Label: value" per field. It goes to the site's
+ * owner, in `lang` (the current language by default).
+ */
+export function submissionText(page, data, lang = currentLang()) {
     const lines = Object.entries(data).map(([k, v]) => `${k}:\n${v}\n`);
-    return `Nuovo messaggio dal modulo del sito${page ? ` (pagina ${page})` : ''}.\n\n${lines.join('\n')}`;
+    const intro = page
+        ? t.in(lang, 'Nuovo messaggio dal modulo del sito (pagina {page}).', { page })
+        : t.in(lang, 'Nuovo messaggio dal modulo del sito.');
+    return `${intro}\n\n${lines.join('\n')}`;
 }
 // ---------- why sending failed, in words ----------
 /** Whether the server answers on a port at all: the way to tell a blocked port from a wrong setting. */
@@ -62,18 +70,18 @@ export async function explainMailError(error, m) {
     const provider = providerById(m.provider) ?? providerByHost(m.host);
     if (e.code === 'EDNS' || /ENOTFOUND|EAI_AGAIN/.test(text))
         return {
-            message: `Il server «${m.host}» non esiste`,
-            hint: 'Controlla il nome del server: un errore di battitura basta.',
+            message: t('Il server «{host}» non esiste', { host: m.host }),
+            hint: t('Controlla il nome del server: un errore di battitura basta.'),
         };
     if (/wrong version number|ssl3_get_record|packet length too long|unknown protocol/i.test(text))
         return {
-            message: 'La sicurezza non corrisponde alla porta',
-            hint: 'Di solito: porta 587 con STARTTLS, porta 465 con TLS.',
+            message: t('La sicurezza non corrisponde alla porta'),
+            hint: t('Di solito: porta 587 con STARTTLS, porta 465 con TLS.'),
         };
     if (/certificate|self.signed|CERT_/i.test(text))
         return {
-            message: 'Il certificato del server di posta non è valido',
-            hint: 'Controlla il nome del server: deve essere esattamente quello indicato dal fornitore.',
+            message: t('Il certificato del server di posta non è valido'),
+            hint: t('Controlla il nome del server: deve essere esattamente quello indicato dal fornitore.'),
         };
     if (e.code === 'ETIMEDOUT' ||
         e.code === 'ECONNECTION' ||
@@ -86,34 +94,50 @@ export async function explainMailError(error, m) {
                 open.push(p);
         if (open.length)
             return {
-                message: `Il server non risponde sulla porta ${m.port}, ma risponde sulla ${open.join(' e sulla ')}`,
-                hint: `Prova la porta ${open[0]}${open[0] === 465 ? ' con TLS' : ' con STARTTLS'}: la ${m.port} potrebbe essere bloccata dal fornitore del server.`,
+                message: t('Il server non risponde sulla porta {port}, ma risponde sulla {open}', {
+                    port: m.port,
+                    open: open.join(t(' e sulla ')),
+                }),
+                hint: open[0] === 465
+                    ? t('Prova la porta {try} con TLS: la {port} potrebbe essere bloccata dal fornitore del server.', {
+                        try: open[0],
+                        port: m.port,
+                    })
+                    : t('Prova la porta {try} con STARTTLS: la {port} potrebbe essere bloccata dal fornitore del server.', {
+                        try: open[0],
+                        port: m.port,
+                    }),
             };
         return {
-            message: `Il server di posta non risponde (porta ${m.port})`,
-            hint: 'Molti fornitori di VPS bloccano le porte della posta in uscita, soprattutto per gli account nuovi: chiedi al loro supporto di sbloccarle, oppure usa un servizio che accetta la porta 2525.',
+            message: t('Il server di posta non risponde (porta {port})', { port: m.port }),
+            hint: t('Molti fornitori di VPS bloccano le porte della posta in uscita, soprattutto per gli account nuovi: chiedi al loro supporto di sbloccarle, oppure usa un servizio che accetta la porta 2525.'),
         };
     }
     if (e.code === 'EAUTH' || e.responseCode === 535 || e.responseCode === 534)
         return {
-            message: 'Utente o password rifiutati dal server di posta',
-            hint: provider ? `${provider.name}: ${provider.userHint} ${provider.passHint}` : 'Controlla utente e password.',
+            message: t('Utente o password rifiutati dal server di posta'),
+            hint: provider
+                ? `${provider.name}: ${provider.userHint} ${provider.passHint}`
+                : t('Controlla utente e password.'),
         };
     if (e.code === 'EENVELOPE' || (e.responseCode && e.responseCode >= 550 && e.responseCode <= 554)) {
         const sender = e.command === 'MAIL FROM' || /sender|from address|not verified|not allowed to send/i.test(text);
         return sender
             ? {
-                message: 'Il server di posta non accetta questo mittente',
-                hint: `${provider?.note ?? 'Il mittente deve essere un indirizzo o un dominio verificato presso il fornitore.'}`,
+                message: t('Il server di posta non accetta questo mittente'),
+                hint: provider?.note ?? t('Il mittente deve essere un indirizzo o un dominio verificato presso il fornitore.'),
             }
-            : { message: 'Il destinatario è stato rifiutato', hint: 'Controlla l’indirizzo del destinatario dei moduli.' };
+            : {
+                message: t('Il destinatario è stato rifiutato'),
+                hint: t('Controlla l’indirizzo del destinatario dei moduli.'),
+            };
     }
     if (e.responseCode && e.responseCode >= 421 && e.responseCode <= 452)
         return {
-            message: 'Il server di posta ha rimandato l’invio',
-            hint: 'Spesso è un limite di messaggi raggiunto: riprova più tardi o controlla il piano del fornitore.',
+            message: t('Il server di posta ha rimandato l’invio'),
+            hint: t('Spesso è un limite di messaggi raggiunto: riprova più tardi o controlla il piano del fornitore.'),
         };
-    return { message: e.message || text.trim() || 'Invio non riuscito' };
+    return { message: e.message || text.trim() || t('Invio non riuscito') };
 }
 const txt = async (resolver, name) => (await resolver.resolveTxt(name).catch(() => [])).map((parts) => parts.join(''));
 /**
@@ -129,39 +153,46 @@ export async function checkSenderDomain(domain, providerId) {
         checks.push({
             id: 'spf',
             state: 'bad',
-            title: 'Manca il record SPF',
-            detail: `Senza SPF le email da ${domain} finiscono spesso nello spam. ${provider?.spf ? `Aggiungi nel DNS un record TXT su ${domain}: v=spf1 include:${provider.spf[0]} ~all` : 'Il fornitore della posta indica quale record TXT aggiungere nel DNS.'}`,
+            title: t('Manca il record SPF'),
+            detail: provider?.spf
+                ? t('Senza SPF le email da {domain} finiscono spesso nello spam. Aggiungi nel DNS un record TXT su {domain}: v=spf1 include:{host} ~all', { domain, host: provider.spf[0] })
+                : t('Senza SPF le email da {domain} finiscono spesso nello spam. Il fornitore della posta indica quale record TXT aggiungere nel DNS.', { domain }),
         });
     else if (spf.length > 1)
         checks.push({
             id: 'spf',
             state: 'bad',
-            title: 'Ci sono due record SPF',
-            detail: 'I server di posta li scartano entrambi: uniscili in un solo record TXT che inizia con v=spf1.',
+            title: t('Ci sono due record SPF'),
+            detail: t('I server di posta li scartano entrambi: uniscili in un solo record TXT che inizia con v=spf1.'),
         });
     else if (!/\b(include:|a\b|a:|mx\b|mx:|ip4:|ip6:|exists:|redirect=)/i.test(spf[0]))
         checks.push({
             id: 'spf',
             state: 'bad',
-            title: 'Il record SPF non autorizza nessun server',
-            detail: `${spf[0]}: così il dominio dichiara di non inviare email, e i messaggi vengono rifiutati. Aggiungi il server del tuo fornitore${provider?.spf ? ` (include:${provider.spf[0]})` : ''}.`,
+            title: t('Il record SPF non autorizza nessun server'),
+            detail: provider?.spf
+                ? t('{record}: così il dominio dichiara di non inviare email, e i messaggi vengono rifiutati. Aggiungi il server del tuo fornitore (include:{host}).', { record: spf[0], host: provider.spf[0] })
+                : t('{record}: così il dominio dichiara di non inviare email, e i messaggi vengono rifiutati. Aggiungi il server del tuo fornitore.', { record: spf[0] }),
         });
     else if (provider?.spf && !provider.spf.some((h) => spf[0].includes(`include:${h}`)))
         checks.push({
             id: 'spf',
             state: 'warn',
-            title: `Il record SPF non autorizza ${provider.name}`,
-            detail: `Aggiungi include:${provider.spf[0]} al record attuale, prima di ~all o -all: ${spf[0]}`,
+            title: t('Il record SPF non autorizza {provider}', { provider: provider.name }),
+            detail: t('Aggiungi include:{host} al record attuale, prima di ~all o -all: {record}', {
+                host: provider.spf[0],
+                record: spf[0],
+            }),
         });
     else
-        checks.push({ id: 'spf', state: 'ok', title: 'Record SPF presente', detail: spf[0] });
+        checks.push({ id: 'spf', state: 'ok', title: t('Record SPF presente'), detail: spf[0] });
     const selectors = provider ? provider.dkim : COMMON_DKIM;
     if (provider && !selectors.length)
         checks.push({
             id: 'dkim',
             state: 'info',
-            title: 'Firma DKIM: da controllare nel pannello del fornitore',
-            detail: `${provider.name} dà a ogni account nomi propri per la firma DKIM: nel suo pannello vedi se il dominio è verificato.`,
+            title: t('Firma DKIM: da controllare nel pannello del fornitore'),
+            detail: t('{provider} dà a ogni account nomi propri per la firma DKIM: nel suo pannello vedi se il dominio è verificato.', { provider: provider.name }),
         });
     else {
         let found = null;
@@ -175,14 +206,16 @@ export async function checkSenderDomain(domain, providerId) {
             ? {
                 id: 'dkim',
                 state: 'ok',
-                title: 'Firma DKIM presente',
-                detail: `Trovata con il nome ${found}._domainkey.${domain}.`,
+                title: t('Firma DKIM presente'),
+                detail: t('Trovata con il nome {name}.', { name: `${found}._domainkey.${domain}` }),
             }
             : {
                 id: 'dkim',
                 state: 'warn',
-                title: 'Firma DKIM non trovata',
-                detail: `Non l’ho trovata con i nomi più comuni${provider ? ` di ${provider.name}` : ''}. Nel pannello del fornitore attiva la firma del dominio: ti dà i record da aggiungere nel DNS.`,
+                title: t('Firma DKIM non trovata'),
+                detail: provider
+                    ? t('Non l’ho trovata con i nomi più comuni di {provider}. Nel pannello del fornitore attiva la firma del dominio: ti dà i record da aggiungere nel DNS.', { provider: provider.name })
+                    : t('Non l’ho trovata con i nomi più comuni. Nel pannello del fornitore attiva la firma del dominio: ti dà i record da aggiungere nel DNS.'),
             });
     }
     const dmarc = (await txt(resolver, `_dmarc.${domain}`)).find((r) => /^v=DMARC1\b/i.test(r));
@@ -190,16 +223,16 @@ export async function checkSenderDomain(domain, providerId) {
         checks.push({
             id: 'dmarc',
             state: 'warn',
-            title: 'Manca il record DMARC',
-            detail: `Gmail e Yahoo lo chiedono a chi invia molte email. Un inizio sicuro, che osserva senza bloccare niente: record TXT su _dmarc.${domain} con v=DMARC1; p=none`,
+            title: t('Manca il record DMARC'),
+            detail: t('Gmail e Yahoo lo chiedono a chi invia molte email. Un inizio sicuro, che osserva senza bloccare niente: record TXT su _dmarc.{domain} con v=DMARC1; p=none', { domain }),
         });
     else {
         const policy = /\bp=(none|quarantine|reject)/i.exec(dmarc)?.[1]?.toLowerCase();
         checks.push({
             id: 'dmarc',
             state: 'ok',
-            title: 'Record DMARC presente',
-            detail: policy === 'none' ? `Osserva soltanto (p=none): ${dmarc}` : dmarc,
+            title: t('Record DMARC presente'),
+            detail: policy === 'none' ? t('Osserva soltanto (p=none): {record}', { record: dmarc }) : dmarc,
         });
     }
     return checks;

package/src/media.js

@@ -5,6 +5,7 @@ import { join, resolve } from 'node:path';
 import { Readable } from 'node:stream';
 import { slugify } from '@materializecms/core';
 import sharp, {} from 'sharp';
+import { t } from './t.js';
 /** Formats people can upload, by what the file really is (not by its name). */
 const FORMATS = { jpeg: 'jpg', png: 'png', webp: 'webp', gif: 'gif', heif: 'avif' };
 export const MAX_UPLOAD = 25 * 1024 * 1024;
@@ -49,11 +50,11 @@ export function createMediaFiles(dir) {
                 meta = await sharp(input, { animated: true }).metadata();
             }
             catch {
-                throw new MediaError('Il file non è un’immagine leggibile né un modello 3D (.glb)');
+                throw new MediaError(t('Il file non è un’immagine leggibile né un modello 3D (.glb)'));
             }
             const format = meta.format;
             if (!(format in FORMATS))
-                throw new MediaError('Formato non supportato: usa JPG, PNG, WebP, AVIF o GIF');
+                throw new MediaError(t('Formato non supportato: usa JPG, PNG, WebP, AVIF o GIF'));
             const ext = FORMATS[format];
             let output = input;
             let width = meta.width;

package/src/offsite.js

@@ -3,6 +3,7 @@ import { mkdtemp, open, readdir, rm, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join, relative, resolve } from 'node:path';
 import { createS3Storage, createWebDavStorage, } from './remote-storage.js';
+import { t } from './t.js';
 export const DEFAULT_OFFSITE = { kind: 'off', keep: 30 };
 const KEY_MARK = 'mzk1-';
 const MAGIC = Buffer.from('MZB1');
@@ -17,7 +18,7 @@ export function parseRecoveryKey(text) {
     const raw = clean.startsWith(KEY_MARK) ? clean.slice(KEY_MARK.length) : clean;
     const key = Buffer.from(raw, 'base64url');
     if (key.length !== 32)
-        throw new Error('La chiave di ripristino non è valida: deve iniziare con mzk1-');
+        throw new Error(t('La chiave di ripristino non è valida: deve iniziare con mzk1-'));
     return key;
 }
 const nonceOf = (prefix, index) => {
@@ -60,19 +61,19 @@ export async function decryptFile(source, target, key) {
         const head = Buffer.alloc(12);
         await input.read(head, 0, 12, 0);
         if (!head.subarray(0, 4).equals(MAGIC))
-            throw new Error('Non è un file di backup cifrato da Materialize');
+            throw new Error(t('Non è un file di backup cifrato da Materialize'));
         const prefix = head.subarray(4, 12);
         let position = 12;
         for (let i = 0;; i++) {
             const length = Buffer.alloc(4);
             if ((await input.read(length, 0, 4, position)).bytesRead < 4)
-                throw new Error('Il file è incompleto');
+                throw new Error(t('Il file è incompleto'));
             const size = length.readUInt32BE();
             if (size > BLOCK)
-                throw new Error('Il file è danneggiato');
+                throw new Error(t('Il file è danneggiato'));
             const sealed = Buffer.alloc(size + 16);
             if ((await input.read(sealed, 0, size + 16, position + 4)).bytesRead < size + 16)
-                throw new Error('Il file è incompleto');
+                throw new Error(t('Il file è incompleto'));
             position += 4 + size + 16;
             const end = position >= (await input.stat()).size;
             const decipher = createDecipheriv('aes-256-gcm', key, nonceOf(prefix, i));
@@ -82,7 +83,9 @@ export async function decryptFile(source, target, key) {
                 await output.write(Buffer.concat([decipher.update(sealed.subarray(0, size)), decipher.final()]));
             }
             catch {
-                throw new Error(end ? 'Chiave sbagliata, oppure il file è stato modificato' : 'Il file è incompleto o è stato modificato');
+                throw new Error(end
+                    ? t('Chiave sbagliata, oppure il file è stato modificato')
+                    : t('Il file è incompleto o è stato modificato'));
             }
             if (end)
                 break;
@@ -144,7 +147,7 @@ export async function runOffsite(s, backups, mediaDir, fresh = false,
 /** For tests: a storage in memory. */
 storage = storageOf(s)) {
     if (!storage || !s.key)
-        throw new Error('La copia fuori dal server non è configurata');
+        throw new Error(t('La copia fuori dal server non è configurata'));
     const key = parseRecoveryKey(s.key);
     const work = await mkdtemp(join(tmpdir(), 'materialize-offsite-'));
     try {
@@ -201,13 +204,13 @@ storage = storageOf(s)) {
 export async function testOffsite(s) {
     const storage = storageOf(s);
     if (!storage)
-        throw new Error('Scegli S3 o WebDAV e compila i campi');
+        throw new Error(t('Scegli S3 o WebDAV e compila i campi'));
     const key = `.materialize-prova-${randomBytes(4).toString('hex')}.txt`;
     const text = `Prova di Materialize, ${new Date().toISOString()}`;
     await storage.putText(key, text);
     try {
         if ((await storage.getText(key)) !== text)
-            throw new Error('Il file di prova è tornato diverso');
+            throw new Error(t('Il file di prova è tornato diverso'));
         await storage.list('');
     }
     finally {

package/src/remote-storage.js

@@ -3,6 +3,7 @@ import { createReadStream, createWriteStream } from 'node:fs';
 import { stat } from 'node:fs/promises';
 import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
+import { t } from './t.js';
 export class RemoteError extends Error {
     status;
     constructor(message, status) {
@@ -13,14 +14,14 @@ export class RemoteError extends Error {
 /** A human reason for an HTTP failure, the same for both kinds of storage. */
 function failure(what, status, detail = '') {
     const why = status === 401 || status === 403
-        ? 'accesso rifiutato: controlla le credenziali e i permessi'
+        ? t('accesso rifiutato: controlla le credenziali e i permessi')
         : status === 404
-            ? 'non trovato: controlla l’indirizzo, il bucket o la cartella'
+            ? t('non trovato: controlla l’indirizzo, il bucket o la cartella')
             : status === 409
-                ? 'una cartella del percorso non esiste: crea almeno quella che contiene la cartella dei backup'
+                ? t('una cartella del percorso non esiste: crea almeno quella che contiene la cartella dei backup')
                 : status === 507 || /QuotaExceeded|InsufficientStorage/i.test(detail)
-                    ? 'spazio esaurito'
-                    : `il servizio ha risposto ${status}`;
+                    ? t('spazio esaurito')
+                    : t('il servizio ha risposto {status}', { status });
     const code = /<Code>([^<]+)<\/Code>/.exec(detail)?.[1];
     return new RemoteError(`${what}: ${why}${code ? ` (${code})` : ''}`, status);
 }
@@ -31,19 +32,19 @@ async function reach(url, init) {
     catch (error) {
         const cause = error.cause?.code;
         throw new RemoteError(cause === 'ENOTFOUND'
-            ? `Il servizio ${new URL(url).host} non si trova: controlla l’indirizzo`
-            : `Il servizio non risponde (${cause ?? error.message})`);
+            ? t('Il servizio {host} non si trova: controlla l’indirizzo', { host: new URL(url).host })
+            : t('Il servizio non risponde ({cause})', { cause: cause ?? error.message }));
     }
 }
 const fileBody = (file) => Readable.toWeb(createReadStream(file));
 async function saveBody(res, file) {
     if (!res.body)
-        throw new RemoteError('Risposta vuota');
+        throw new RemoteError(t('Risposta vuota'));
     try {
         await pipeline(Readable.fromWeb(res.body), createWriteStream(file));
     }
     catch (error) {
-        throw new RemoteError(`Il download si è interrotto (${error.message}): riprova`);
+        throw new RemoteError(t('Il download si è interrotto ({cause}): riprova', { cause: error.message }));
     }
 }
 // ---------- S3 ----------
@@ -121,24 +122,24 @@ export function createS3Storage(target, prefix = '') {
     return {
         async put(key, file) {
             const { size } = await stat(file);
-            await call(`Caricamento di ${key}`, 'PUT', full(key), {
+            await call(t('Caricamento di {key}', { key }), 'PUT', full(key), {
                 headers: { 'content-length': String(size), 'content-type': 'application/octet-stream' },
                 body: fileBody(file),
             });
         },
         async putText(key, text) {
             const body = Buffer.from(text);
-            await call(`Caricamento di ${key}`, 'PUT', full(key), {
+            await call(t('Caricamento di {key}', { key }), 'PUT', full(key), {
                 headers: { 'content-length': String(body.length), 'content-type': 'text/plain; charset=utf-8' },
                 body,
                 payload: sha256(body),
             });
         },
         async get(key, file) {
-            await saveBody(await call(`Download di ${key}`, 'GET', full(key), { payload: EMPTY_HASH }), file);
+            await saveBody(await call(t('Download di {key}', { key }), 'GET', full(key), { payload: EMPTY_HASH }), file);
         },
         async getText(key) {
-            return (await call(`Download di ${key}`, 'GET', full(key), { payload: EMPTY_HASH })).text();
+            return (await call(t('Download di {key}', { key }), 'GET', full(key), { payload: EMPTY_HASH })).text();
         },
         async list(folder) {
             const items = [];
@@ -148,7 +149,7 @@ export function createS3Storage(target, prefix = '') {
                 const query = { 'list-type': '2', prefix: full(folder) };
                 if (token)
                     query['continuation-token'] = token;
-                const xml = await (await call('Elenco dei file', 'GET', '', { query, payload: EMPTY_HASH })).text();
+                const xml = await (await call(t('Elenco dei file'), 'GET', '', { query, payload: EMPTY_HASH })).text();
                 for (const block of xml.match(/<Contents>[\s\S]*?<\/Contents>/g) ?? [])
                     items.push({
                         key: unescapeXml(xmlValue(block, 'Key')).slice(strip),
@@ -160,7 +161,7 @@ export function createS3Storage(target, prefix = '') {
             return items;
         },
         async delete(key) {
-            await call(`Eliminazione di ${key}`, 'DELETE', full(key), { payload: EMPTY_HASH });
+            await call(t('Eliminazione di {key}', { key }), 'DELETE', full(key), { payload: EMPTY_HASH });
         },
     };
 }
@@ -181,7 +182,7 @@ export function createWebDavStorage(target) {
         if (!made.has('')) {
             const res = await reach(root, { method: 'MKCOL', headers: { authorization: auth } });
             if (!res.ok && res.status !== 405)
-                throw failure('Creazione della cartella dei backup', res.status, await res.text());
+                throw failure(t('Creazione della cartella dei backup'), res.status, await res.text());
             made.add('');
         }
         const parts = key.split('/').slice(0, -1);
@@ -192,7 +193,7 @@ export function createWebDavStorage(target) {
             const res = await reach(url(dir), { method: 'MKCOL', headers: { authorization: auth } });
             // 405: it exists already.
             if (!res.ok && res.status !== 405)
-                throw failure(`Creazione della cartella ${dir}`, res.status, await res.text());
+                throw failure(t('Creazione della cartella {dir}', { dir }), res.status, await res.text());
             made.add(dir);
         }
     };
@@ -200,7 +201,7 @@ export function createWebDavStorage(target) {
         async put(key, file) {
             await folders(key);
             const { size } = await stat(file);
-            await call(`Caricamento di ${key}`, 'PUT', key, {
+            await call(t('Caricamento di {key}', { key }), 'PUT', key, {
                 headers: { 'content-length': String(size), 'content-type': 'application/octet-stream' },
                 body: fileBody(file),
                 duplex: 'half',
@@ -208,16 +209,16 @@ export function createWebDavStorage(target) {
         },
         async putText(key, text) {
             await folders(key);
-            await call(`Caricamento di ${key}`, 'PUT', key, {
+            await call(t('Caricamento di {key}', { key }), 'PUT', key, {
                 headers: { 'content-type': 'text/plain; charset=utf-8' },
                 body: text,
             });
         },
         async get(key, file) {
-            await saveBody(await call(`Download di ${key}`, 'GET', key), file);
+            await saveBody(await call(t('Download di {key}', { key }), 'GET', key), file);
         },
         async getText(key) {
-            return (await call(`Download di ${key}`, 'GET', key)).text();
+            return (await call(t('Download di {key}', { key }), 'GET', key)).text();
         },
         async list(folder) {
             const items = [];
@@ -231,7 +232,7 @@ export function createWebDavStorage(target) {
                 if (res.status === 404)
                     return;
                 if (!res.ok)
-                    throw failure('Elenco dei file', res.status, await res.text());
+                    throw failure(t('Elenco dei file'), res.status, await res.text());
                 const xml = await res.text();
                 // Namespaces differ between servers (d:, D:, none): matched by local name.
                 for (const block of xml.match(/<(?:\w+:)?response[\s>][\s\S]*?<\/(?:\w+:)?response>/g) ?? []) {
@@ -258,7 +259,7 @@ export function createWebDavStorage(target) {
             return items;
         },
         async delete(key) {
-            await call(`Eliminazione di ${key}`, 'DELETE', key);
+            await call(t('Eliminazione di {key}', { key }), 'DELETE', key);
         },
     };
 }

package/src/remote.d.ts

@@ -1,6 +1,17 @@
-/** Raised when a remote file cannot be fetched: the message says why, in words. */
+/**
+ * Raised when a remote file cannot be fetched: the message says why, in words (in the reader's
+ * language); `reason` says it to code.
+ */
 export declare class RemoteError extends Error {
+    readonly reason?: 'too_large' | 'private';
+    constructor(message: string, reason?: 'too_large' | 'private');
 }
+/**
+ * Loopback, private, link-local and other addresses a public file never lives at. IPv6 is read
+ * group by group, so the same IPv4 address cannot slip through written another way (mapped as
+ * ::ffff:7f00:1, compatible, NAT64, 6to4). Anything that is not an address counts as private.
+ */
+export declare function isPrivate(address: string): boolean;
 export interface RemoteResponse {
     status: number;
     headers: Headers;
@@ -10,17 +21,23 @@ export interface RemoteResponse {
     name: string;
     url: string;
 }
-/**
- * Fetches from the web: http(s) only, redirects checked one by one, at most `max` bytes. Addresses
- * on this machine or its network are refused, unless `allowPrivate` (an administrator importing
- * from a WordPress on their own network). Headers are sent to the first host only.
- */
-export declare function remoteFetch(url: string, options: {
+export interface RemoteOptions {
     max: number;
     headers?: Record<string, string>;
     allowPrivate?: boolean;
     timeout?: number;
-}): Promise<RemoteResponse>;
+    method?: 'GET' | 'POST';
+    body?: string;
+    /** Redirects followed before giving up; 0 refuses any (a webhook must answer where it was set). */
+    maxRedirects?: number;
+}
+/**
+ * Fetches from the web: http(s) only, redirects checked one by one, at most `max` bytes. Addresses
+ * on this machine or its network are refused, unless `allowPrivate` (an administrator importing
+ * from a WordPress on their own network), and checked when connecting, not before. Headers are
+ * sent to the first host only.
+ */
+export declare function remoteFetch(url: string, options: RemoteOptions): Promise<RemoteResponse>;
 /**
  * Downloads a public file (an image an AI found on the web): http(s) only, never to an address on
  * this machine or its network, redirects checked one by one, at most `max` bytes.