` was turned into a paragraph holding raw table markup. This is what recovers per-section wrappers: compiled MJML nests a body wrapper around one `

` per section around each section's table. - **A one-cell wrapper row is descended instead of becoming a section.** Table-based emails wrap their real layout in one-cell tables; each wrapper became a one-column section and the genuine multi-column row inside it was flattened away. A wrapper row that carries no background and no padding, and whose cell holds nothing but tables, is now descended, so the column count is read off the row that declares it. - **Gutter rows are no longer read as columns.** A row placing an ` ` cell either side of the content, a common centring idiom, became a three-column section whose outer two columns were empty and whose middle column held everything. A false positive, worse than the single column a naive reading gives. - **Column ratios are recovered from declared widths.** `2-1` and `1-2` were unreachable: the layout came from counting cells, so every two-cell row imported as an even `2`. Widths now choose between the layouts of that cell count, snapped to the nearest, and a ratio the model cannot express is reported as `approximated` with a note naming the widths. - **A cell of sibling column `

`s reads as a column set.** This is how hybrid and MJML-compiled emails state columns, and it is the one column shape with no cell count to read — a single `` holding one inline-block `

` per column. Such a row imported as a single column holding every column's blocks in order. - **A heading wrapped in a container is typed as a heading.** The container was mapped instead, so the heading arrived as a paragraph carrying raw `

` markup rather than as a `title` with a level. #### Report changes you can observe - Sections now appear in `report.entries`, with `sourceTag: 'tr'`, or `'body'` for the synthetic section that holds loose top-level content. Only leaf blocks were reported before, so a caller could not reconcile the entries against `content.blocks`. Entry totals rise accordingly. - A lost layout is now an entry, not only a warning. A nested row whose columns a section cannot hold, and a row of more cells than any layout has, each add an `approximated` entry with a note. Previously a flattened row produced a `warnings` string at best, and a nested row's loss was reported nowhere. - New `approximated` notes name a column ratio the model cannot express, giving the measured widths and the layout used instead. - A text anchor no longer produces an entry of its own. It folds into the paragraph its sentence became, reported `converted` under the cell's tag. The `approximated` entry noted `Inline anchor ### Fixes and improvements Send test emails through the configured render provider `@templatical/editor` `testEmail.includeMjml` rendered with the bundled `@templatical/renderer` even when `render.toMjml` was configured, so a consumer with an authoritative backend renderer received a test built from a different pipeline than the real send — the one thing a test email exists to rule out. Anything the backend adds that the browser cannot (a platform footer, a server-composited block) was absent from the test and present in the delivered message. `editor.toMjml()` was always correct; only the test-email payload took the local path. The entry point now hands the editor the same resolution ladder both use, so a test carries byte-identical MJML to an export. The `includeMjml` degradation ladder gains two rows for the provider path. A missing `@templatical/renderer` explains a failed render only when the bundled renderer is what ran, so a consumer whose backend renders — and who therefore has no reason to install the package at all — no longer has their backend's own error read as an absent dependency, swallowed into a JSON-only send and answered with advice to install something that would change nothing. A throwing render provider now fails the send, exactly as a broken template already did. Unaffected: consumers with no `render` provider, those supplying only `compileMjml`, and Cloud, whose `testEmail` key excludes `includeMjml` at the type level. ## 0.33.0 2026-09-08 ### Features Let a consumer choose which template settings the Settings panel exposes `@templatical/editor` · `@templatical/types` The right sidebar's Settings tab offered all eight members of `TemplateSettings` unconditionally. An embedder whose application owns one of them — the content locale chosen before the editor opens, a preheader edited in a field next to the subject line — had no way to take it out, and was left hiding fields with CSS against internal markup. New `templateSettings.fields` on both `init()` and `initCloud()`: ```ts init({ container, templateSettings: { fields: ["width", "backgroundColor", "fontFamily"], }, }); ``` The list only narrows: omit the key, or pass `true`, and every setting stays editable. A card renders while at least one of its settings survives, so excluding `locale` removes the Language card and excluding `preheaderText` removes the Preheader card; `fields: false` (or `[]`) removes the Settings tab itself. The list never reorders — settings sit in fixed cards, so unlike `paletteBlocks` there is no order to express. An entry that isn't a `TemplateSettings` member is a compile error for TypeScript callers, and is warned and skipped at runtime, so a typo narrows the panel rather than restoring every setting. Presentation only. Hiding a setting never changes its value: whatever the loaded content carries keeps rendering and keeps round-tripping through `getContent()` and the export. Set the ones you hide from the content you hand the editor — `init({ content })`, or your own `templates.load`. `templateDefaults` cannot do it, since it applies only when no content is provided. Settings cards now space their contents with a flex gap rather than a bottom margin on every child but the last, because which field is last depends on the allowlist. Every field control and card also carries a `data-testid`. Closes #674. ## 0.32.0 2026-09-07 ### Features Localize the text new blocks start with, and stop the editor's locale being `@templatical/core` · `@templatical/editor` · `@templatical/media-library` ignored by everything `Intl` formats. New blocks carry localized placeholder text (#673). A Button dragged into a German editor read "Click Here", a Paragraph "Enter your text here", and a Title "Enter your title". Which locale a default follows depends on who the text is for: - Author-facing prompts — Title, Paragraph and Button text — follow `init({ locale })`. They exist to be overwritten, so they match the interface around them. - Recipient-facing text — the video `alt`, and the countdown's unit labels and expired message — follows the template's own `settings.locale`, because it ships in the delivered email. A German-speaking author building an English campaign does not get German countdown labels. `blockDefaults` wins over both, and the merge is deep, so overriding `button.backgroundColor` keeps the translated label. With no locale configured the defaults are byte-identical to the factory values, so nothing changes for consumers who never set one. A fresh template declares the editor's language. `init({ locale: 'de' })` now seeds `settings.locale`, so a new template stops rendering `` over German copy — an accessibility defect in the delivered email, not just the editor. A consumer's own `templateDefaults.locale` still wins, and a malformed tag is ignored rather than emitted into a `lang` attribute. Applies only when no `content` is supplied; supplied content owns the language it declares. Absolute dates follow the editor's locale, not the browser's. Version history entries, saved-block tooltips, the template write-time line, and the media library's date captions were formatted by `toLocaleString()` with no locale, so they read in the browser's language beside fully translated chrome. A malformed `locale` falls back instead of throwing. The canvas declares the content language. Every block-rendering surface now carries `settings.locale` as a `lang` attribute, so the browser's spellchecker and hyphenation judge the copy by the rules of the language it is written in rather than the host page's. An unusable `locale` now warns. `init({ locale: 'gr' })` fell back to English in silence, so a typo looked exactly like the option being ignored. It warns once and lists the locales that would have worked, matching what `paletteBlocks` and `colors` already do. The cloud chunk still falls back quietly — it ships fewer locales on purpose. `useBlockActions`' `blockDefaults` option also accepts a getter (`BlockDefaults | (() => BlockDefaults)`), re-read on each insert so a mid-session change to the content language reaches the next block. Passing a plain object behaves as before. Add `@templatical/import-topol`, a converter from Topol.io design JSON to Templatical template JSON. `@templatical/import-topol` `convertTopolTemplate(design)` returns `{ content, report }` with the same shape as the BeeFree, Unlayer, HTML and MJML importers. It resolves Topol's global-style cascade — the per-tag and per-selector defaults on the design root — maps every tag Topol emits, and reports what it approximated: a four-column section folded to three, a GIF block imported as an image, a social platform with no Templatical equivalent. Pass the design object itself, or a JSON string of it. Topol's editor hands it to you directly from its `onSave` callback; its REST APIs wrap it — under `data.definition` on the template endpoint, `json` on the predefined-templates endpoint. ## 0.31.0 2026-09-06 ### Features Add `@templatical/import-mjml`, a converter from MJML documents to `@templatical/import-mjml` Templatical template JSON — alongside the existing BeeFree, Unlayer and HTML importers. `convertMjmlTemplate(mjml)` returns `{ content, report }`, the same shape as the other three importers. It resolves MJML's `mj-attributes` / `mj-class` / `mj-all` attribute cascade before mapping tags, and recovers block visibility and display conditions from the markup `@templatical/renderer` emits for them. Tags with no Templatical equivalent — `mj-hero`, `mj-carousel`, `mj-accordion`, and any custom component — fall back to HTML blocks holding the original markup. MJML produced by `@templatical/renderer` converts back with no approximations, which a round-trip test asserts over a fixture covering every round-trippable block type. ## 0.30.0 2026-09-02 ### Features Match exported rich-text spacing to the editor canvas, and make the paragraph gap settable per block `@templatical/editor` · `@templatical/renderer` · `@templatical/types` MJML's core skeleton gives every `
` a 13px vertical margin, and resets nothing at all for `ul` / `ol` / `li` — those fell through to each mail client's own stylesheet. The canvas used different values for both, so a three-paragraph block measured 99px in the editor and 135px in the delivered email: 13px of unwanted space above the first paragraph, 13px below the last, and 13px rather than 8px between each. Lists were off by 6px vertically and 16px of bullet indent, and being client-dependent could not be matched from the editor side at all. The renderer now emits scoped rules for the elements a rich-text block stores, via `` — so the declarations arrive as real inline styles that hold up in clients which strip `