@seliseblocks/mailcraft 0.2.0 → 0.2.2

package/src/core/i18n/et.js

@@ -102,7 +102,6 @@ export const ET = {
   'storage.uploading': 'Laadin üles {count}…',
   'storage.errLoadFailed': 'Failikogu laadimine ebaõnnestus — {reason}',
   'storage.errNoLimits': 'Üleslaadimine on välja lülitatud: see rakendus pole määranud üleslaadimispiiranguid.',
-  'storage.errNoAccept': 'Üleslaadimine on välja lülitatud: ühtegi failivormingut pole lubatud.',
   'storage.errNoMaxBytes': 'Üleslaadimine on välja lülitatud: faili suurimat lubatud mahtu pole määratud.',
   'storage.errTooLarge': '{name} on {size} — piir on {max}.',
   'storage.errFormat': '{name} on {type}-fail, mis pole siin lubatud.',

package/src/core/i18n/fi.js

@@ -102,7 +102,6 @@ export const FI = {
   'storage.uploading': 'Ladataan {count}…',
   'storage.errLoadFailed': 'Tiedostokirjastoa ei voitu ladata — {reason}',
   'storage.errNoLimits': 'Lataukset on poistettu käytöstä: tämä sovellus ei ole asettanut latausrajoja.',
-  'storage.errNoAccept': 'Lataukset on poistettu käytöstä: yhtään tiedostomuotoa ei ole sallittu.',
   'storage.errNoMaxBytes': 'Lataukset on poistettu käytöstä: tiedoston enimmäiskokoa ei ole asetettu.',
   'storage.errTooLarge': '{name} on {size} — raja on {max}.',
   'storage.errFormat': '{name} on {type}-tiedosto, jota ei sallita tässä.',

package/src/core/i18n/fr.js

@@ -102,7 +102,6 @@ export const FR = {
   'storage.uploading': 'Envoi de {count}…',
   'storage.errLoadFailed': 'La bibliothèque de fichiers n’a pas pu être chargée — {reason}',
   'storage.errNoLimits': 'Les envois sont désactivés : cette application n’a défini aucune limite d’envoi.',
-  'storage.errNoAccept': 'Les envois sont désactivés : aucun format de fichier n’a été autorisé.',
   'storage.errNoMaxBytes': 'Les envois sont désactivés : aucune taille maximale de fichier n’a été définie.',
   'storage.errTooLarge': '{name} fait {size} — la limite est {max}.',
   'storage.errFormat': '{name} est un fichier {type}, non autorisé ici.',

package/src/core/i18n/hr.js

@@ -102,7 +102,6 @@ export const HR = {
   'storage.uploading': 'Prijenos {count}…',
   'storage.errLoadFailed': 'Knjižnicu datoteka nije moguće učitati — {reason}',
   'storage.errNoLimits': 'Prijenos je isključen: ova aplikacija nije postavila nikakva ograničenja prijenosa.',
-  'storage.errNoAccept': 'Prijenos je isključen: nije dopušten nijedan format datoteke.',
   'storage.errNoMaxBytes': 'Prijenos je isključen: nije postavljena najveća veličina datoteke.',
   'storage.errTooLarge': '{name} je {size} — ograničenje je {max}.',
   'storage.errFormat': '{name} je datoteka vrste {type}, koja ovdje nije dopuštena.',

package/src/core/i18n/hu.js

@@ -102,7 +102,6 @@ export const HU = {
   'storage.uploading': '{count} feltöltése…',
   'storage.errLoadFailed': 'A fájlkönyvtár nem tölthető be — {reason}',
   'storage.errNoLimits': 'A feltöltés ki van kapcsolva: ez az alkalmazás nem állított be feltöltési korlátokat.',
-  'storage.errNoAccept': 'A feltöltés ki van kapcsolva: nincs engedélyezett fájlformátum.',
   'storage.errNoMaxBytes': 'A feltöltés ki van kapcsolva: nincs beállítva maximális fájlméret.',
   'storage.errTooLarge': 'A(z) {name} mérete {size} — a korlát {max}.',
   'storage.errFormat': 'A(z) {name} egy {type} fájl, ami itt nem engedélyezett.',

package/src/core/i18n/it.js

@@ -102,7 +102,6 @@ export const IT = {
   'storage.uploading': 'Caricamento di {count}…',
   'storage.errLoadFailed': 'Impossibile caricare la libreria file — {reason}',
   'storage.errNoLimits': 'I caricamenti sono disattivati: questa applicazione non ha impostato limiti di caricamento.',
-  'storage.errNoAccept': 'I caricamenti sono disattivati: nessun formato di file è stato consentito.',
   'storage.errNoMaxBytes': 'I caricamenti sono disattivati: non è stata impostata una dimensione massima del file.',
   'storage.errTooLarge': '{name} è {size} — il limite è {max}.',
   'storage.errFormat': '{name} è un file {type}, non consentito qui.',

package/src/core/i18n/loaders.js

@@ -0,0 +1,78 @@
+import { EN } from './en.js';
+
+/**
+ * Lazy per-locale loading -- the code-splitting counterpart to tables.js.
+ *
+ * The 30 non-English tables are over half of everything under src/ (about
+ * 82 KB gzipped once minified), and the eager `LOCALE_TABLES` map forces all
+ * of them into any bundle that includes the element, whatever language the
+ * host actually renders. Each entry here is a *literal* dynamic import, which
+ * is the shape every bundler code-splits on: an app that never sets `locale`
+ * ships no tables at all, and one that sets `locale="fr"` fetches one small
+ * chunk on demand. tables.js stays exported for a host that wants the whole
+ * map eagerly (a language switcher with instant previews, say).
+ *
+ * The single-file demo bundle is unaffected: build.js rewrites `import(...)`
+ * onto its synchronous module map, so attribute-driven switching keeps
+ * working from `file://` with no network fetch.
+ */
+export const LOCALE_LOADERS = {
+  en: () => import('./en.js').then((m) => m.EN),
+  ar: () => import('./ar.js').then((m) => m.AR),
+  bg: () => import('./bg.js').then((m) => m.BG),
+  bn: () => import('./bn.js').then((m) => m.BN),
+  ca: () => import('./ca.js').then((m) => m.CA),
+  cs: () => import('./cs.js').then((m) => m.CS),
+  da: () => import('./da.js').then((m) => m.DA),
+  de: () => import('./de.js').then((m) => m.DE),
+  'de-CH': () => import('./de-CH.js').then((m) => m.DE_CH),
+  dz: () => import('./dz.js').then((m) => m.DZ),
+  el: () => import('./el.js').then((m) => m.EL),
+  es: () => import('./es.js').then((m) => m.ES),
+  et: () => import('./et.js').then((m) => m.ET),
+  fi: () => import('./fi.js').then((m) => m.FI),
+  fr: () => import('./fr.js').then((m) => m.FR),
+  hr: () => import('./hr.js').then((m) => m.HR),
+  hu: () => import('./hu.js').then((m) => m.HU),
+  it: () => import('./it.js').then((m) => m.IT),
+  lt: () => import('./lt.js').then((m) => m.LT),
+  lv: () => import('./lv.js').then((m) => m.LV),
+  nb: () => import('./nb.js').then((m) => m.NB),
+  nl: () => import('./nl.js').then((m) => m.NL),
+  pl: () => import('./pl.js').then((m) => m.PL),
+  pt: () => import('./pt.js').then((m) => m.PT),
+  ro: () => import('./ro.js').then((m) => m.RO),
+  ru: () => import('./ru.js').then((m) => m.RU),
+  sk: () => import('./sk.js').then((m) => m.SK),
+  sl: () => import('./sl.js').then((m) => m.SL),
+  sv: () => import('./sv.js').then((m) => m.SV),
+  tr: () => import('./tr.js').then((m) => m.TR),
+  uk: () => import('./uk.js').then((m) => m.UK),
+};
+
+// Module-level (not per-element): two editors on one page asking for the same
+// locale should trigger one fetch and share the parsed table. English is
+// seeded -- it is the translator's built-in base, always statically present.
+const cache = { en: EN };
+const pending = {};
+
+/**
+ * The already-loaded table for a tag. `undefined` means "shipped but not
+ * loaded yet" (call `loadLocale` and re-render when it lands); `null` means
+ * "no such locale" -- render the English base, exactly what the old eager
+ * `LOCALE_TABLES[tag] || null` lookup did for an unknown tag.
+ */
+export function localeTable(tag) {
+  if (Object.prototype.hasOwnProperty.call(cache, tag)) return cache[tag];
+  return LOCALE_LOADERS[tag] ? undefined : null;
+}
+
+/** Fetches (once) and caches a locale's table; resolves null for a tag that does not ship. */
+export function loadLocale(tag) {
+  const load = LOCALE_LOADERS[tag];
+  if (!load) return Promise.resolve(null);
+  if (!pending[tag]) {
+    pending[tag] = load().then((table) => { cache[tag] = table; return table; });
+  }
+  return pending[tag];
+}

package/src/core/i18n/lt.js

@@ -102,7 +102,6 @@ export const LT = {
   'storage.uploading': 'Įkeliama {count}…',
   'storage.errLoadFailed': 'Nepavyko įkelti failų bibliotekos — {reason}',
   'storage.errNoLimits': 'Įkėlimai išjungti: ši programa nenustatė jokių įkėlimo ribų.',
-  'storage.errNoAccept': 'Įkėlimai išjungti: neleidžiamas nė vienas failo formatas.',
   'storage.errNoMaxBytes': 'Įkėlimai išjungti: nenustatytas didžiausias failo dydis.',
   'storage.errTooLarge': '{name} yra {size} — riba yra {max}.',
   'storage.errFormat': '{name} yra {type} failas, kuris čia neleidžiamas.',

package/src/core/i18n/lv.js

@@ -102,7 +102,6 @@ export const LV = {
   'storage.uploading': 'Notiek {count} augšupielāde…',
   'storage.errLoadFailed': 'Neizdevās ielādēt failu bibliotēku — {reason}',
   'storage.errNoLimits': 'Augšupielāde ir izslēgta: šī lietotne nav noteikusi augšupielādes ierobežojumus.',
-  'storage.errNoAccept': 'Augšupielāde ir izslēgta: nav atļauts neviens faila formāts.',
   'storage.errNoMaxBytes': 'Augšupielāde ir izslēgta: nav noteikts maksimālais faila izmērs.',
   'storage.errTooLarge': '{name} ir {size} — ierobežojums ir {max}.',
   'storage.errFormat': '{name} ir {type} fails, kas šeit nav atļauts.',

package/src/core/i18n/nb.js

@@ -102,7 +102,6 @@ export const NB = {
   'storage.uploading': 'Laster opp {count}…',
   'storage.errLoadFailed': 'Filbiblioteket kunne ikke lastes — {reason}',
   'storage.errNoLimits': 'Opplasting er slått av: denne appen har ikke satt noen opplastingsgrenser.',
-  'storage.errNoAccept': 'Opplasting er slått av: ingen filformater er tillatt.',
   'storage.errNoMaxBytes': 'Opplasting er slått av: ingen maksimal filstørrelse er satt.',
   'storage.errTooLarge': '{name} er {size} — grensen er {max}.',
   'storage.errFormat': '{name} er en {type}-fil, som ikke er tillatt her.',

package/src/core/i18n/nl.js

@@ -102,7 +102,6 @@ export const NL = {
   'storage.uploading': '{count} uploaden…',
   'storage.errLoadFailed': 'De bestandsbibliotheek kon niet worden geladen — {reason}',
   'storage.errNoLimits': 'Uploaden staat uit: deze app heeft geen uploadlimieten ingesteld.',
-  'storage.errNoAccept': 'Uploaden staat uit: er zijn geen bestandsformaten toegestaan.',
   'storage.errNoMaxBytes': 'Uploaden staat uit: er is geen maximale bestandsgrootte ingesteld.',
   'storage.errTooLarge': '{name} is {size} — de limiet is {max}.',
   'storage.errFormat': '{name} is een {type}-bestand, dat hier niet is toegestaan.',

package/src/core/i18n/pl.js

@@ -102,7 +102,6 @@ export const PL = {
   'storage.uploading': 'Przesyłanie {count}…',
   'storage.errLoadFailed': 'Nie udało się wczytać biblioteki plików — {reason}',
   'storage.errNoLimits': 'Przesyłanie jest wyłączone: ta aplikacja nie ustawiła żadnych limitów przesyłania.',
-  'storage.errNoAccept': 'Przesyłanie jest wyłączone: nie dopuszczono żadnego formatu pliku.',
   'storage.errNoMaxBytes': 'Przesyłanie jest wyłączone: nie ustawiono maksymalnego rozmiaru pliku.',
   'storage.errTooLarge': '{name} ma {size} — limit to {max}.',
   'storage.errFormat': '{name} to plik {type}, który nie jest tu dozwolony.',

package/src/core/i18n/pt.js

@@ -102,7 +102,6 @@ export const PT = {
   'storage.uploading': 'A carregar {count}…',
   'storage.errLoadFailed': 'Não foi possível carregar a biblioteca de ficheiros — {reason}',
   'storage.errNoLimits': 'Os carregamentos estão desativados: esta aplicação não definiu limites de carregamento.',
-  'storage.errNoAccept': 'Os carregamentos estão desativados: não foi permitido nenhum formato de ficheiro.',
   'storage.errNoMaxBytes': 'Os carregamentos estão desativados: não foi definido um tamanho máximo de ficheiro.',
   'storage.errTooLarge': '{name} tem {size} — o limite é {max}.',
   'storage.errFormat': '{name} é um ficheiro {type}, que não é permitido aqui.',

package/src/core/i18n/ro.js

@@ -102,7 +102,6 @@ export const RO = {
   'storage.uploading': 'Se încarcă {count}…',
   'storage.errLoadFailed': 'Biblioteca de fișiere nu a putut fi încărcată — {reason}',
   'storage.errNoLimits': 'Încărcările sunt oprite: această aplicație nu a stabilit nicio limită de încărcare.',
-  'storage.errNoAccept': 'Încărcările sunt oprite: nu a fost permis niciun format de fișier.',
   'storage.errNoMaxBytes': 'Încărcările sunt oprite: nu a fost stabilită o dimensiune maximă a fișierului.',
   'storage.errTooLarge': '{name} are {size} — limita este {max}.',
   'storage.errFormat': '{name} este un fișier {type}, care nu este permis aici.',

package/src/core/i18n/ru.js

@@ -102,7 +102,6 @@ export const RU = {
   'storage.uploading': 'Загрузка {count}…',
   'storage.errLoadFailed': 'Не удалось загрузить библиотеку файлов — {reason}',
   'storage.errNoLimits': 'Загрузка выключена: это приложение не задало ограничения на загрузку.',
-  'storage.errNoAccept': 'Загрузка выключена: ни один формат файлов не разрешён.',
   'storage.errNoMaxBytes': 'Загрузка выключена: не задан максимальный размер файла.',
   'storage.errTooLarge': '{name} весит {size} — предел {max}.',
   'storage.errFormat': '{name} — файл {type}, который здесь не разрешён.',

package/src/core/i18n/sk.js

@@ -102,7 +102,6 @@ export const SK = {
   'storage.uploading': 'Nahrávanie {count}…',
   'storage.errLoadFailed': 'Knižnicu súborov sa nepodarilo načítať — {reason}',
   'storage.errNoLimits': 'Nahrávanie je vypnuté: táto aplikácia nenastavila žiadne limity nahrávania.',
-  'storage.errNoAccept': 'Nahrávanie je vypnuté: nebol povolený žiadny formát súboru.',
   'storage.errNoMaxBytes': 'Nahrávanie je vypnuté: nie je nastavená maximálna veľkosť súboru.',
   'storage.errTooLarge': '{name} má {size} — limit je {max}.',
   'storage.errFormat': '{name} je súbor typu {type}, ktorý tu nie je povolený.',

package/src/core/i18n/sl.js

@@ -102,7 +102,6 @@ export const SL = {
   'storage.uploading': 'Nalaganje {count}…',
   'storage.errLoadFailed': 'Knjižnice datotek ni bilo mogoče naložiti — {reason}',
   'storage.errNoLimits': 'Nalaganje je izklopljeno: ta aplikacija ni določila omejitev nalaganja.',
-  'storage.errNoAccept': 'Nalaganje je izklopljeno: dovoljena ni nobena vrsta datoteke.',
   'storage.errNoMaxBytes': 'Nalaganje je izklopljeno: največja velikost datoteke ni določena.',
   'storage.errTooLarge': '{name} je {size} — omejitev je {max}.',
   'storage.errFormat': '{name} je datoteka vrste {type}, ki tu ni dovoljena.',

package/src/core/i18n/sv.js

@@ -102,7 +102,6 @@ export const SV = {
   'storage.uploading': 'Laddar upp {count}…',
   'storage.errLoadFailed': 'Filbiblioteket kunde inte laddas — {reason}',
   'storage.errNoLimits': 'Uppladdning är avstängd: den här appen har inte satt några uppladdningsgränser.',
-  'storage.errNoAccept': 'Uppladdning är avstängd: inga filformat har tillåtits.',
   'storage.errNoMaxBytes': 'Uppladdning är avstängd: ingen maximal filstorlek har angetts.',
   'storage.errTooLarge': '{name} är {size} — gränsen är {max}.',
   'storage.errFormat': '{name} är en {type}-fil, som inte tillåts här.',

package/src/core/i18n/tables.js

@@ -37,10 +37,11 @@ import { UK } from './uk.js';
  * importing and assigning a table by hand.
  *
  * Deliberately a separate module from index.js's metadata-only `LOCALES`:
- * importing this one pulls all translations in. The element accepts that
- * (host-driven language is worth it, and the demo bundle carries every module
- * anyway); a size-sensitive host that bypasses the attribute can still
- * deep-import a single `core/i18n/<tag>.js` and assign `.messages` itself.
+ * importing this one pulls all translations in, eagerly. The element itself
+ * no longer does -- it resolves the `locale` attribute through the lazy
+ * per-tag loaders (loaders.js), so a bundled app ships only the locales it
+ * actually renders. This eager map remains for a host that wants every table
+ * up front (an instant-preview language switcher, a server-side pass).
  */
 export const LOCALE_TABLES = {
   en: EN, ar: AR, bg: BG, bn: BN, ca: CA, cs: CS, da: DA, de: DE, 'de-CH': DE_CH,

package/src/core/i18n/tr.js

@@ -102,7 +102,6 @@ export const TR = {
   'storage.uploading': '{count} yükleniyor…',
   'storage.errLoadFailed': 'Dosya kitaplığı yüklenemedi — {reason}',
   'storage.errNoLimits': 'Yüklemeler kapalı: bu uygulama hiçbir yükleme sınırı belirlemedi.',
-  'storage.errNoAccept': 'Yüklemeler kapalı: hiçbir dosya biçimine izin verilmedi.',
   'storage.errNoMaxBytes': 'Yüklemeler kapalı: en büyük dosya boyutu belirlenmedi.',
   'storage.errTooLarge': '{name} {size} — sınır {max}.',
   'storage.errFormat': '{name} bir {type} dosyası ve burada izin verilmiyor.',

package/src/core/i18n/uk.js

@@ -102,7 +102,6 @@ export const UK = {
   'storage.uploading': 'Завантаження {count}…',
   'storage.errLoadFailed': 'Не вдалося завантажити бібліотеку файлів — {reason}',
   'storage.errNoLimits': 'Завантаження вимкнено: цей застосунок не задав обмежень на завантаження.',
-  'storage.errNoAccept': 'Завантаження вимкнено: не дозволено жодного формату файлів.',
   'storage.errNoMaxBytes': 'Завантаження вимкнено: не задано максимальний розмір файлу.',
   'storage.errTooLarge': '{name} важить {size} — обмеження {max}.',
   'storage.errFormat': '{name} — файл {type}, який тут не дозволено.',

package/src/core/import-html.js

@@ -955,6 +955,37 @@ function themeFromParsedDoc(doc) {
   });
   const bestWidth = Object.keys(widthCounts).sort((a, b) => widthCounts[b] - widthCounts[a])[0];
   if (bestWidth) theme.width = Number(bestWidth);
+  // Page padding and content shape, read off the same content table the
+  // width vote just picked: the padding on the cell that centers it is the
+  // band the template sits in, and the table's own radius is the content
+  // column's corner. Without this an import flattened both, and the next
+  // export silently squared the template off and closed the gap around it.
+  if (bestWidth) {
+    const content = Array.from(body.querySelectorAll('table')).find((tb) => {
+      const w = tb.getAttribute('width') || (tb.style && tb.style.width) || '';
+      return w && !String(w).endsWith('%') && PX(w) === Number(bestWidth);
+    });
+    if (content) {
+      // The content column's own background -- including the literal
+      // `transparent` the exporter always writes for a see-through column.
+      // Without this the round trip lost it: export wrote
+      // `background:transparent`, the import never read it back, and the
+      // blank-doc default repainted the content area white on every
+      // save/reload. Only an explicit value is taken, so a foreign email
+      // whose content table declares nothing keeps the white default.
+      const cbg = bgOf(content);
+      if (cbg) theme.contentBg = cbg;
+      const r = PX(content.style && content.style.borderRadius);
+      if (r > 0) theme.radius = r;
+      const cell = content.closest ? content.closest('td') : null;
+      if (cell && cell.style) {
+        const padY = PX(cell.style.paddingTop);
+        const padX = PX(cell.style.paddingLeft);
+        if (padY > 0) theme.padY = padY;
+        if (padX > 0) theme.padX = padX;
+      }
+    }
+  }
   // Prefer the first *real* stack (has a comma or quotes) over a lone generic
   // keyword: builders wrap everything in a `font-family:sans-serif` shim div
   // with the actual `'DM Sans', Arial, ...` declared a level deeper.

package/src/core/storage-limits.js

@@ -1,12 +1,13 @@
 /**
  * Upload validation -- mechanism only, no policy.
  *
- * Deliberately ships no default ceilings. What an email template may carry
- * depends on the sending platform (ESP attachment caps), the audience's
- * clients (Outlook's Word engine won't render WebP; nothing renders AVIF) and
- * the host's own product rules, so the numbers are the host's to set:
- * `editor.storageLimits`, or `limits` on the provider. With a provider wired
- * and no limits declared, uploads are refused rather than waved through.
+ * Sizes and counts stay undefaulted: what an email template may carry depends
+ * on the sending platform (ESP attachment caps) and the host's own product
+ * rules, so those numbers are the host's to set -- `editor.storageLimits`, or
+ * `limits` on the provider. Formats are the one axis with a default: every
+ * image type the sniffer can name is allowed unless the host narrows `accept`.
+ * With a provider wired and no `maxBytes` declared, uploads are refused rather
+ * than waved through.
  *
  * Checks run *before* the provider is called, so a rejected file never reaches
  * the backend. That matters for any store where minting an upload URL also
@@ -96,10 +97,9 @@ export function sanitizeName(name) {
   return clean.slice(0, 120 - ext.length) + ext;
 }
 
-/** The host has to have said what's allowed. Format and size are the two that matter; the rest are optional tightenings. */
+/** The host has to have said how big a file may be; the format list is optional and defaults to all of these. */
 export function limitsProblem(limits) {
   if (!limits) return 'storage.errNoLimits';
-  if (!Array.isArray(limits.accept) || !limits.accept.length) return 'storage.errNoAccept';
   if (!(Number(limits.maxBytes) > 0)) return 'storage.errNoMaxBytes';
   return null;
 }
@@ -121,7 +121,12 @@ export async function validateFiles(list, limits) {
   const problem = limitsProblem(limits);
   if (problem) return { accepted, rejected: files.map((f) => ({ name: f.name, key: problem, params: {} })) };
 
-  const accept = limits.accept.map((m) => String(m).toLowerCase());
+  // An omitted or empty `accept` means every image type the sniffer can name,
+  // not "nothing" -- a host that wants a narrower list has to say so, but the
+  // starting point is that an image is uploadable.
+  const accept = Array.isArray(limits.accept) && limits.accept.length
+    ? limits.accept.map((m) => String(m).toLowerCase())
+    : null;
   const max = Number(limits.maxBytes);
   const maxW = Number(limits.maxWidth) || 0;
   const maxH = Number(limits.maxHeight) || 0;
@@ -146,7 +151,7 @@ export async function validateFiles(list, limits) {
       rejected.push({ name, key: 'storage.errUnreadable', params: { name } });
       continue;
     }
-    if (!accept.includes(type)) {
+    if (accept && !accept.includes(type)) {
       rejected.push({ name, key: 'storage.errFormat', params: { name, type: type.replace(/^image\//, '').toUpperCase() } });
       continue;
     }
@@ -181,4 +186,4 @@ export async function validateFiles(list, limits) {
 export function acceptAttribute(limits) {
   if (!limits || !Array.isArray(limits.accept) || !limits.accept.length) return 'image/*';
   return limits.accept.join(',');
-}
+}

package/src/core/storage.js

@@ -35,7 +35,7 @@
  *   Provider-declared ceilings. `editor.storageLimits` wins over these.
  *
  * @typedef {Object} StorageLimits
- * @property {string[]} accept   Allowed MIME types, e.g. `['image/jpeg','image/png','image/gif']`. Required.
+ * @property {string[]} [accept]   Allowed MIME types. Omitted or empty means every image type the validator recognizes.
  * @property {number} maxBytes   Per-file byte ceiling. Required.
  * @property {number} [maxWidth]
  * @property {number} [maxHeight]

package/src/core/theme.js

@@ -1 +1,15 @@
-export const THEME = () => ({ bg: '#eef2f7', contentBg: '#ffffff', width: 620, font: '"Helvetica Neue", Helvetica, Arial, sans-serif', text: '#172033', link: '#0065b3' });
+/**
+ * The document's page-level model. `bg` paints the full-width area the email
+ * sits on (what a mail client shows around the content column), `contentBg`
+ * paints the content column itself, and `padY`/`padX`/`radius` shape the gap
+ * between the two -- the band that is otherwise an unstyleable strip around
+ * every template.
+ *
+ * They default to 0 rather than to the 24px/12px band the exporter used to
+ * hard-code: that band was in every sent template with no way to reach it,
+ * which is the strip around the content column that looked like a rendering
+ * fault. Now it is off unless a document asks for it. Both background keys
+ * accept the literal `transparent` (and any rgba()/#rrggbbaa value) as well
+ * as a hex colour.
+ */
+export const THEME = () => ({ bg: '#eef2f7', contentBg: '#ffffff', width: 620, padY: 0, padX: 0, radius: 0, font: '"Helvetica Neue", Helvetica, Arial, sans-serif', text: '#172033', link: '#0065b3' });

package/src/index.js

@@ -5,5 +5,6 @@ export { renderDoc } from './render/canvas.js';
 export { BLOCKS, GROUPS, LAYOUTS, PALETTE } from './core/blocks.js';
 export { createTranslator, defineMessages, missingKeys, LOCALES, isRtl, EN, MESSAGE_KEYS } from './core/i18n/index.js';
 export { LOCALE_TABLES } from './core/i18n/tables.js';
+export { LOCALE_LOADERS, loadLocale, localeTable } from './core/i18n/loaders.js';
 export { ALL_FOLDER_ID, normalizeAsset, resolveLimits } from './core/storage.js';
 export { validateFiles, sanitizeName, acceptAttribute, limitsProblem } from './core/storage-limits.js';