# Configurazione: pagine composte

> I modelli delle pagine composte: cornici, gruppi, decorazione, ereditarietà e varianti recto/verso, gli stili delle etichette degli ancoraggi delle immagini e gli avvisi che un modello può dare

- Versione HTML: https://postext.dev/it/docs/configuration-composed-pages
- Ultimo aggiornamento: 2026-10-16
- Tempo di lettura: 6 min
- Altre lingue: [en](https://postext.dev/en/docs/configuration-composed-pages.md), [es](https://postext.dev/es/docs/configuration-composed-pages.md), [ca](https://postext.dev/ca/docs/configuration-composed-pages.md), [de](https://postext.dev/de/docs/configuration-composed-pages.md), [fr](https://postext.dev/fr/docs/configuration-composed-pages.md), [pt](https://postext.dev/pt/docs/configuration-composed-pages.md), [zh](https://postext.dev/zh/docs/configuration-composed-pages.md), [ja](https://postext.dev/ja/docs/configuration-composed-pages.md), [ar](https://postext.dev/ar/docs/configuration-composed-pages.md)

## In breve

Questa pagina presenta i modelli di pagina. Un modello è una pagina disegnata nelle impostazioni: riquadri con un nome, chiamati cornici, dove sta ciascuno, quanto può crescere e che aspetto ha. Il Markdown di una pagina composta riempie poi le cornici per nome, così il testo non contiene mai posizioni e le impostazioni non contengono mai testo. Un modello può partire da un altro e cambiare solo alcune cornici, e può essere diverso sulle pagine di sinistra e di destra. La pagina elenca anche gli stili delle etichette per le parole messe sulle immagini, e ogni avviso che un modello può dare insieme al modo di correggerlo.

## Modelli di pagina

Una pagina composta è una pagina la cui forma viene da un **modello** della configurazione e il cui contenuto viene dal Markdown di un blocco `::::page{template="…"}`. Il modello dà un nome a dei rettangoli, chiamati **cornici**; il Markdown manda ogni parte del contenuto a una cornice per nome (il suo slot). La geometria non compare mai nel Markdown, e il testo del contenuto non compare mai nel modello. La proprietà `pageTemplates` contiene i modelli del libro:

```ts
const config: PostextConfig = {
  calloutStyles: [{ id: 'caja-azul' }, { id: 'tab-titulo' }],
  pageTemplates: [
    {
      id: 'tema-cajas',
      decoration: {
        elements: [
          { kind: 'image', id: 'fondo', resourceId: '{attr.fondo}', decorative: true,
            placement: { anchor: { to: 'bleed', edge: 'top-left' }, size: { width: 'fill', height: 'fill' } } },
        ],
      },
      frames: [
        { name: 'titulo', takes: 'h1', style: 'tab-titulo' },
        { name: 'texto', flow: true },
        { name: 'dinero', style: 'caja-azul', padding: { right: { value: 62, unit: 'mm' } } },
        { name: 'dinero-fotos', layer: 2, width: { value: 60, unit: 'mm' },
          placement: { anchor: { to: '#dinero', edge: 'top-right' } } },
      ],
      groups: [
        { name: 'pagina', kind: 'stack', gap: { value: 6, unit: 'mm' }, frames: ['titulo', 'texto', 'dinero'] },
      ],
    },
  ],
};
```

Un modello che imposta solo il suo `id` e una cornice è una pagina intera in cui quella cornice riempie l’area del contenuto. Tutti gli altri campi sono facoltativi:

| Proprietà | Tipo | Predefinito | Descrizione |
| --- | --- | --- | --- |
| `id` | `string` | obbligatorio | Il nome che chiede un blocco di pagina (`template="tema-cajas"`). Unico tra i modelli: un secondo modello con lo stesso id viene ignorato. |
| `name` | `string` | l’id | Il nome mostrato nella Sandbox. L’impaginazione non lo legge mai. |
| `extends` | `string` | nessuno | L’id del modello da cui parte questo. Vedi [Ereditarietà e varianti](https://postext.dev/it/docs/configuration-composed-pages.md#ereditarietà-e-varianti). |
| `area` | `'content' \| 'trim' \| 'bleed'` | `'content'` | Il rettangolo a cui si riferiscono le posizioni delle cornici. `'content'` è l’area del contenuto della pagina, speculare sulle pagine di sinistra e di destra come il testo corrente; `'trim'` è la pagina rifilata; `'bleed'` la pagina con la sua abbondanza. |
| `grid` | `{ columns, rows, columnGap?, rowGap? }` | nessuna | Divide l’area in celle, così una cornice o un gruppo si può collocare per cella (`grid: { col: 2, row: 1, cols: 2 }`, contando da 1) invece che con `placement`. Gli spazi valgono `0` per impostazione predefinita. |
| `frames` | `FrameConfig[]` | `[]` | Le cornici, nell’ordine del modello: quello in cui vengono misurate e quello che decide i pareggi. Vedi [Cornici](https://postext.dev/it/docs/configuration-composed-pages.md#cornici). |
| `groups` | `FrameGroupConfig[]` | `[]` | Pile e file di cornici che si dividono lo spazio. Vedi [Gruppi](https://postext.dev/it/docs/configuration-composed-pages.md#gruppi). |
| `decoration` | `DesignSlot` | nessuna | Immagini, filetti e riquadri dipinti con la pagina, nel linguaggio di elementi di [intestazioni e piè di pagina](https://postext.dev/it/docs/configuration-headers-footers.md#intestazioni-e-piè-di-pagina). Gli elementi di testo contengono solo segnaposto (`{pageNumber}`, `{chapterTitle}`, `{attr.x}` per un attributo del blocco di pagina). Un elemento si può ancorare a una cornice o a un gruppo (`'#dinero'`) e allora si sposta con esso. La decorazione si colloca dopo le cornici e non spinge mai il testo. |
| `header`, `footer` | `DesignSlot \| false` | ereditati | Il titolo corrente e il numero di pagina. Se non sono impostati, la pagina tiene quelli del suo capitolo; `false` li nasconde. |
| `spread` | `boolean` | `false` | Il modello descrive due pagine affiancate disposte come un unico foglio. Una doppia pagina comincia sempre su una pagina di sinistra in un libro da sinistra a destra (su una pagina di destra in uno da destra a sinistra), con una pagina bianca aggiunta prima quando serve. |
| `gutter` | `Dimension` | `0` | In una doppia pagina, la fascia sul dorso che le cornici lasciano libera, a meno che impostino `crossGutter: true`. |
| `variants` | `{ recto?, verso? }` | nessuna | Modifiche per una pagina di destra (`recto`) o di sinistra (`verso`), scritte come il modello stesso. Il lato è quello fisico, quindi funzionano sia i libri da sinistra a destra sia quelli da destra a sinistra. |
| `overflowTemplate` | `string` | questo modello | Il modello delle pagine aggiunte quando una cornice continua nella pagina successiva (`overflow.continueIn: 'next-page'`). Se non è impostato, la pagina aggiunta usa questo modello con riempite solo le cornici che continuano. |
| `bodyStyle` | `string` | nessuno | Uno stile di paragrafo per il testo della pagina, come quello degli stili dei titoli. |
| `palette` | `string` | nessuna | Una tavolozza sostitutiva per la pagina, come quella degli stili dei titoli e delle parti. |
| `role` | `string` | `'composed'` | Il ruolo di pagina che vedono gli elementi di progetto grafico con un filtro `pages`. |

### Cornici

Una cornice è un rettangolo con un nome che riceve contenuto composto. Il suo `name` è lo slot che chiede il Markdown, ed è unico nel suo modello (nemmeno un gruppo può prendere il nome di una cornice, perché gli ancoraggi indicano entrambi allo stesso modo).

Una cornice si colloca con la sua cella `grid` quando il modello ha una griglia, altrimenti con il suo `placement`, che funziona come quello di un elemento di progetto grafico: un ancoraggio (`'container'` è l’area, `'page'`, `'bleed'`, o `'#name'` per un’altra cornice o un altro gruppo), un bordo, uno scostamento e una dimensione. Una cornice ancorata a un’altra si sposta con essa. Senza né l’una né l’altro, la cornice parte dall’angolo in alto a sinistra dell’area, larga quanto l’area e alta quanto dice la sua regola di altezza. Come il contenuto viene versato nelle cornici, concatenato e tagliato è descritto in [Pagine composte › Come si compone la pagina](https://postext.dev/it/docs/composed-pages.md#come-si-compone-la-pagina).

| Proprietà | Tipo | Predefinito | Descrizione |
| --- | --- | --- | --- |
| `name` | `string` | obbligatorio | Il nome dello slot. |
| `placement` | `ElementPlacement` | tutta l’area | Ancoraggio, bordo, scostamento e dimensione, come nella [collocazione degli elementi](https://postext.dev/it/docs/configuration-headers-footers.md#collocazione-degli-elementi). Ignorato quando una cella della griglia colloca la cornice. |
| `grid` | `{ col, row, cols?, rows? }` | nessuna | Una cella della griglia del modello, contando da 1, estesa su `cols` × `rows` celle (1 per impostazione predefinita). Una cella oltre la griglia viene riportata al suo interno. Ignorato quando il modello non ha una griglia. |
| `width`, `height` | `Dimension \| { percent } \| 'auto' \| 'fill'` | `'fill'`, `'auto'` | Una lunghezza fissa, una percentuale dell’area (da 0 a 100), `'auto'` (la dimensione propria del contenuto) o `'fill'` (quanto resta fino al bordo a cui la cornice è ancorata). Se non è impostata, la cornice legge `placement.size` e poi il valore predefinito: tutta la larghezza, alta quanto il suo contenuto. Una cornice di testo ha bisogno di una giustezza, quindi una larghezza `'auto'` ha senso solo per una cornice che contiene una sola immagine (la larghezza dell’immagine all’altezza della cornice). Un valore che il motore non può usare (una lunghezza negativa, un’unità sconosciuta) vale come il predefinito. |
| `minWidth`, `maxWidth`, `minHeight`, `maxHeight` | `Dimension` | nessuno | Limiti per una dimensione `'auto'` o `'fill'` e per lo spazio che un gruppo cede o prende. Il minimo prevale sul massimo, e una dimensione fissa fuori dai limiti viene riportata tra di essi (`frameMinMax` avvisa di entrambi i casi). |
| `style` | `string` | senza riquadro | L’id di uno [stile dei riquadri](https://postext.dev/it/docs/configuration-callouts.md#stili-dei-riquadri): le cornici si disegnano con gli stili dei riquadri (sfondo, bordo, spaziatura interna, fascia, icona, linguetta dell’etichetta, titolo). Le parole di una linguetta vengono dal Markdown (`:::frame{slot="dinero" label="El dinero"}`). Le impostazioni dei riquadri che decidono dove va un riquadro nel testo corrente (`placement`, `span`, `columns`, `width`, `fixed`…) non valgono per una cornice. |
| `padding` | `{ top?, right?, bottom?, left? }` | quella dello stile | Sostituisce la spaziatura interna dello stile lato per lato: lo spazio per le foto che stanno sopra un riquadro, per esempio. |
| `layer` | `number` | `1` | L’ordine di pittura. La decorazione è il livello 0; un livello negativo si dipinge sotto di essa. |
| `rotate` | `number` | `0` | Gradi, in senso orario. Il riquadro e il suo contenuto ruotano insieme. |
| `verticalAlign` | `'top' \| 'middle' \| 'bottom' \| 'justify'` | `'top'` | Dove sta il contenuto in una cornice più alta di lui. |
| `columns`, `columnGap` | `number`, `Dimension` | `1`, quello dello stile | Colonne dentro la cornice. |
| `exclude` | `'none' \| 'push'` | `'none'` | `'push'`: il testo delle altre cornici scorre attorno al rettangolo di questa. |
| `flow` | `boolean` | `false` | La cornice riceve il contenuto che non indica nessuno slot. |
| `takes` | `'h1'` … `'h6'` | nessuno | La cornice riceve il primo titolo di quel livello che non indica nessuno slot, quindi il titolo di una pagina è solo `# Title` in cima al blocco. |
| `next` | `string` | nessuno | Una catena: il contenuto che non entra continua nella cornice con quel nome, nella stessa pagina. |
| `overflow.continueIn` | `string` | nessuno | Dove prosegue il contenuto che non entra: `'#frame'` (un’altra cornice della pagina, come `next`), `'next-page'` (la stessa cornice in una pagina aggiunta dopo questa) o `'template:<id>'` (una pagina di quel modello). |
| `overflow.mark` | `string \| false` | quello della lingua | Il segno alla fine di un pezzo tagliato. Se non è impostato, la parola di continuazione della lingua del documento (quella delle tabelle divise); `false` non ne mette nessuno. |
| `fit.shrinkText` | `boolean` | `true` | Quando nient’altro fa entrare il contenuto, il suo testo si può comporre più piccolo. |
| `fit.minScale` | `number` | `0.9` | La scala minima del testo, sopra 0 e al massimo 1 (un valore maggiore vale 1). |
| `fit.scaleImages`, `fit.imageMinScale` | `boolean`, `number` | `true`, `0.8` | Se le immagini della cornice si possono rimpicciolire, e fino a quale scala. |
| `pin` | `boolean` | `false` | La cornice non si sposta né cambia dimensione, per un riquadro che deve restare allineato con l’illustrazione. Un gruppo si dispone attorno a essa. |
| `grow`, `shrink`, `priority` | `number` | `0` | Come la cornice divide lo spazio del suo gruppo: `grow` prende una parte dello spazio libero, `shrink` permette alla cornice di cedere spazio, e le cornici con `priority` più bassa lo cedono per prime. |
| `optional` | `boolean` | `false` | Nessun avviso quando il Markdown non manda nulla alla cornice. |
| `crossGutter` | `boolean` | `false` | In una doppia pagina, la cornice può attraversare la fascia del dorso. |
| `writingMode`, `direction` | `'horizontal-tb' \| 'vertical-rl'`, `'ltr' \| 'rtl'` | quelli della pagina | Un riquadro verticale su una pagina orizzontale, o il contrario. |
| `remove` | `boolean` | `false` | In un modello che ne estende un altro, o in una variante: elimina la cornice ereditata con quel nome. |

### Gruppi

Un gruppo è una pila (dall’alto in basso) o una fila (dall’inizio alla fine) di cornici che si dividono lo spazio e si spostano insieme. Dentro un gruppo, la posizione propria delle cornici lungo la direzione del gruppo viene ignorata: il gruppo le dispone in ordine, con `gap` tra l’una e l’altra. Quando il testo di una cornice cresce, le cornici che la seguono si spostano. Un gruppo è un riquadro a cui si possono ancorare cornici e decorazione (`'#pagina'`).

| Proprietà | Tipo | Predefinito | Descrizione |
| --- | --- | --- | --- |
| `name` | `string` | obbligatorio | Unico tra le cornici e i gruppi del modello. |
| `kind` | `'stack' \| 'row'` | `'stack'` | Dall’alto in basso, o dall’inizio alla fine. |
| `frames` | `string[]` | `[]` | Le cornici del gruppo, nel loro ordine sulla pagina. Una cornice appartiene al massimo a un gruppo; un nome che non è una cornice del modello, o una cornice già elencata, viene saltato. |
| `gap` | `Dimension` | `0` | Lo spazio tra due cornici del gruppo. |
| `placement`, `grid` | come le cornici | il riquadro delle sue cornici | Il riquadro proprio del gruppo. Se non è impostato, il riquadro che racchiude i riquadri dichiarati delle sue cornici. |
| `align` | `'start' \| 'center' \| 'end' \| 'space-between'` | `'start'` | Dove va lo spazio libero quando nessuna cornice del gruppo cresce. |
| `remove` | `boolean` | `false` | In un modello che ne estende un altro, o in una variante: elimina il gruppo ereditato. |

### Ereditarietà e varianti

Un modello con `extends` parte dal modello che indica (che a sua volta può estenderne un altro) e cambia solo ciò che scrive:

- Un campo come `area`, `header` o `overflowTemplate` sostituisce quello del genitore. `grid` si unisce chiave per chiave. Anche `spread`, `gutter` e `role` si ereditano; `id`, `name` ed `extends` sono propri del modello.
- `frames` e `groups` si uniscono **per nome**: una voce con il nome di una ereditata cambia i campi che scrive e tiene gli altri (`fit`, `overflow` e `padding` si uniscono chiave per chiave; `placement` si sostituisce per intero); `remove: true` la elimina; un nome nuovo si aggiunge dopo quelli ereditati.
- Gli elementi della decorazione si uniscono per `id` allo stesso modo; un elemento con un id nuovo, o senza id, si aggiunge.

`variants.recto` e `variants.verso` si scrivono come un modello e si uniscono allo stesso modo, su una pagina di destra o di sinistra. Si applicano dopo tutta la catena di `extends`, prima la variante della radice. Una doppia pagina ha entrambi i lati, quindi nessuna variante vale per essa.

```ts
pageTemplates: [
  { id: 'tema', frames: [{ name: 'texto', flow: true }, { name: 'margen', width: { value: 30, unit: 'mm' },
      placement: { anchor: { to: 'container', edge: 'top-left' } } }],
    variants: { recto: { frames: [{ name: 'margen', placement: { anchor: { to: 'container', edge: 'top-right' } } }] } } },
  { id: 'tema-sin-margen', extends: 'tema', frames: [{ name: 'margen', remove: true }] },
]
```

Un valore uguale a un predefinito non viene mai scartato quando la Sandbox salva un modello: in un modello che ne estende un altro, o in una variante, sostituisce il valore del genitore.

Dal codice, `resolvePageTemplate(config, id, { parity })` restituisce un modello con la catena unita, la variante del lato applicata, ogni valore predefinito compilato e ogni riferimento risolto come descrivono gli avvisi più sotto; `validatePageTemplates(config)` restituisce gli avvisi.

### Che cosa applica l’impaginazione

L’impaginazione applica la collocazione e le dimensioni di ogni cornice (griglia, ancoraggi, `min`/`max`, `verticalAlign`), il suo stile e il suo `padding`, `columns`, `layer`, `rotate`, `exclude`, `flow`, `takes`, `next` e `overflow.continueIn: "#frame"`, oltre ad `area`, `grid`, `decoration`, `header`, `footer` e `variants` del modello. Vengono letti e controllati, ma non ancora applicati: la ripartizione dello spazio in un gruppo (`grow`, `shrink`, `priority`, `pin`, e il `gap` e l’`align` di un gruppo; le sue cornici mantengono la propria collocazione), `fit`, `overflow.continueIn: "next-page"` e `overflowTemplate`, `spread` e `crossGutter`, il `writingMode` e la `direction` di una cornice, e il `bodyStyle` e la `palette` del modello. Una larghezza `'auto'` si legge come `'fill'`.

## Stili delle etichette

La proprietà `labelStyles` dà un nome agli aspetti delle etichette messe su un’immagine: i mari e le città di una carta, le parti di uno schema. Un’etichetta sta in un ancoraggio dell’immagine (un punto salvato con la risorsa, come i personaggi dei fumetti) e prende lo stile che indica l’ancoraggio o l’etichetta.

```ts
labelStyles: [
  { id: 'mar', fontStyle: 'italic', textTransform: 'uppercase', letterSpacing: 0.12,
    color: { hex: '#2b6ca3', model: 'hex' } },
  { id: 'ciudad', fontWeight: 600, halo: { color: { hex: '#ffffff', model: 'hex' }, width: { value: 0.6, unit: 'pt' } } },
]
```

| Proprietà | Tipo | Predefinito | Descrizione |
| --- | --- | --- | --- |
| `id` | `string` | obbligatorio | Il nome che usano ancoraggi ed etichette. |
| `name` | `string` | l’id | Il nome mostrato nella Sandbox. |
| `paragraphStyle` | `string` | nessuno | Uno stile di paragrafo da cui l’etichetta prende il carattere; i campi qui sotto lo sostituiscono. |
| `fontFamily`, `fontSize`, `fontWeight` | `string`, `Dimension`, `number` | quelli del testo corrente | Il carattere dell’etichetta. |
| `fontStyle` | `'normal' \| 'italic'` | `'normal'` | Tondo o corsivo. |
| `color` | `ColorValue` | colore del testo corrente | Il colore delle lettere. |
| `textTransform` | `'none' \| 'uppercase'` | `'none'` | Maiuscole, come le carte scrivono mari e paesi. |
| `letterSpacing` | `number` | `0` | Spazio in più tra le lettere, in em. |
| `halo` | `{ color, width }` | nessuno | Un contorno dietro le lettere, perché si leggano su un’immagine carica di dettagli. |
| `background`, `padding` | `ColorValue`, `Dimension` | nessuno | Una campitura dietro l’etichetta, e lo spazio attorno al suo testo. |
| `minScale` | `number` | `0.85` | Quanto si può rimpicciolire un’etichetta che non entra nella sua larghezza. |

### Campi di etichetta di un ancoraggio

Gli ancoraggi di un’immagine (`Resource.anchors`, i punti che i fumetti usano per i personaggi) accettano alcuni campi facoltativi per le etichette. Sono frazioni dell’immagine, quindi valgono in ogni lingua e con qualunque ritaglio dell’immagine. I fumetti li ignorano.

| Campo | Tipo | Predefinito | Descrizione |
| --- | --- | --- | --- |
| `width` | `number` | quella dell’etichetta | La giustezza dell’etichetta, come frazione della larghezza dell’immagine: un nome lungo va a capo su due righe al suo interno. |
| `align` | `'start' \| 'center' \| 'end'` | `'center'` | Quale lato dell’etichetta sta sul punto dell’ancoraggio. |
| `verticalAlign` | `'top' \| 'middle' \| 'bottom'` | `'middle'` | Quale bordo dell’etichetta sta all’altezza dell’ancoraggio. |
| `rotate` | `number` | `0` | Gradi, in senso orario, attorno al punto dell’ancoraggio: il nome di un fiume lungo il suo corso. |
| `style` | `string` | nessuno | Un id di `labelStyles`. Un’etichetta che indica il proprio stile lo sostituisce. |

## Avvisi dei modelli di pagina

Altrove il motore ignora una chiave che non conosce. I modelli di pagina e gli stili delle etichette invece vengono verificati, e ogni problema diventa un avviso di configurazione in `postext check` e nel pannello Verifiche della Sandbox. Il `path` di questi avvisi è un puntatore JSON al campo in errore: `/pageTemplates/3/frames/2/style`, `/pageTemplates/0/variants/recto/frames/1/next`, `/resources/4/anchors/0/style`. Quando il campo è stato ereditato, il puntatore indica il modello che l’ha scritto. Un avviso che cita un id o un nome inesistente suggerisce anche quello esistente più vicino.

Una chiave scritta male di un modello, di una cornice, di un gruppo, di una griglia, di `fit`, di `overflow`, di una variante o di uno stile di etichetta è un `unknownConfigKey`; una parola fuori dalle scelte di un’impostazione (`area`, `verticalAlign`, `exclude`, `takes`, `kind`, `align`, `writingMode`, `direction`, `fontStyle`, `textTransform`) è un `unknownConfigValue`, e l’impostazione tiene il suo valore predefinito. Un modello senza `id`, o una cornice o un gruppo senza `name`, viene ignorato con un `unknownConfigValue` su quel campo.

| Avviso | Causa | Rimedio |
| --- | --- | --- |
| `templateDuplicate` | Due modelli hanno lo stesso `id`. Si usa il primo e quello successivo viene ignorato. | Rinomina uno dei due, o elimina la copia. |
| `templateExtendsCycle` | Seguendo `extends` si torna allo stesso modello (`a → b → a`). Tutti i modelli del ciclo, e tutti quelli che ne estendono uno, vengono scartati: nessuna pagina li può usare. | Togli l’`extends` di un modello del ciclo. |
| `templateExtendsUnknown` | `extends` indica un id che nessun modello ha. Il modello si usa da solo, senza ereditare nulla. | Correggi l’id (l’avviso suggerisce quello più vicino), o aggiungi il modello genitore. |
| `frameDuplicate` | Due cornici, o due gruppi, di uno stesso elenco hanno lo stesso `name`, oppure un gruppo ha il nome di una cornice. La voce successiva viene ignorata; un ancoraggio a quel nome legge la cornice. | Dai a ogni cornice e a ogni gruppo un nome proprio. Per cambiare una cornice ereditata, scrivi una sola voce con il suo nome. |
| `frameStyleUnknown` | Lo `style` di una cornice non indica nessuno stile dei riquadri. La cornice si disegna senza riquadro. | Correggi l’id, o aggiungi lo stile a `calloutStyles`. |
| `frameAnchorUnknown` | Una cornice, un gruppo o un elemento della decorazione è ancorato a `'#name'` e il modello non ha cornici, gruppi o elementi con quel nome; oppure cornici e gruppi sono ancorati l’uno all’altro in un ciclo (anche attraverso un gruppo senza un proprio ancoraggio, il cui riquadro è quello delle sue cornici). L’ancoraggio vale come `'container'`, l’area. | Ancora a una cornice o a un gruppo che esiste, o rompi il ciclo ancorandone uno all’area. |
| `frameMinMax` | Un minimo è maggiore del suo massimo (`minHeight 40mm > maxHeight 30mm`), oppure una `width` o una `height` fissa sta fuori dai limiti. Il minimo prevale, una dimensione fissa viene riportata tra i limiti, e `used` dice cosa prende la cornice. Le lunghezze in unità diverse si confrontano alla risoluzione della pagina, gli em al corpo del testo corrente. | Rendi il minimo non maggiore del massimo, o togli il limite che la dimensione fissa contraddice. |
| `groupFrameUnknown` | Le `frames` di un gruppo elencano un nome che non è una cornice del modello (forse eliminata da un modello figlio o da una variante). Il gruppo lo salta. | Correggi il nome, o toglilo dall’elenco. |
| `groupFrameTwice` | Una cornice è elencata in due gruppi, o due volte nello stesso. Una cornice appartiene a un solo gruppo: la voce successiva viene saltata. | Tieni la cornice nell’unico gruppo con cui si sposta. |
| `frameChainLoop` | Le cornici continuano l’una nell’altra in un ciclo tramite `next` o `overflow.continueIn: '#frame'` (`a → b → a`). Il collegamento che chiude il ciclo viene scartato, quindi la catena finisce nella cornice che lo precede. | Chiudi la catena nella sua ultima cornice: togli il suo `next`, o falla continuare nella pagina successiva. |
| `overflowTargetUnknown` | Un `next` non indica nessuna cornice del modello; un `overflow.continueIn` non indica nessuna cornice (`'#x'`) o nessun modello (`'template:x'`), oppure non ha nessuna delle forme `'#frame'`, `'next-page'` e `'template:<id>'`; oppure `overflowTemplate` non indica nessun modello. Il contenuto che non entra non prosegue lì. | Correggi il nome o l’id, o scrivi una delle tre forme. |
| `labelStyleUnknown` | Un ancoraggio di un’immagine indica uno `style` che `labelStyles` non ha. L’avviso cita la risorsa. Le etichette in quell’ancoraggio prendono l’aspetto predefinito. | Correggi l’id dello stile nell’ancoraggio, o aggiungi lo stile a `labelStyles`. |

La versione della configurazione è la 15 dai modelli di pagina in poi (i bundle scritti prima continuano a caricarsi senza modifiche: niente di ciò che dice una configurazione più vecchia cambia significato).