# Konfiguration: Kopf- und Fußzeilen

> Was oben und unten auf jeder Seite gedruckt wird: Text mit Platzhaltern, Linien, Kästen und Bilder, nach Seitenparität, und wo jedes Element steht

- HTML-Fassung: https://postext.dev/de/docs/configuration-headers-footers
- Zuletzt aktualisiert: 2026-10-16
- Lesezeit: 29 min
- Andere Sprachen: [en](https://postext.dev/en/docs/configuration-headers-footers.md), [es](https://postext.dev/es/docs/configuration-headers-footers.md), [ca](https://postext.dev/ca/docs/configuration-headers-footers.md), [fr](https://postext.dev/fr/docs/configuration-headers-footers.md), [it](https://postext.dev/it/docs/configuration-headers-footers.md), [pt](https://postext.dev/pt/docs/configuration-headers-footers.md), [zh](https://postext.dev/zh/docs/configuration-headers-footers.md), [ja](https://postext.dev/ja/docs/configuration-headers-footers.md), [ar](https://postext.dev/ar/docs/configuration-headers-footers.md)

## Kurz gesagt

Diese Seite behandelt, was oben und unten auf jeder Seite gedruckt wird. Eine Kopf- oder Fußzeile kann die Seitenzahl, den Titel des Buchs oder des Kapitels, eine Linie, einen Kasten oder ein kleines Bild enthalten. Linke und rechte Seiten können Verschiedenes zeigen. Jedes Element kann links, in der Mitte oder rechts stehen oder im Rand neben dem Text. Kopf- und Fußzeile liegen innerhalb der Ränder und machen den Textbereich deshalb nie kleiner.

## Kopf- und Fußzeilen

Die Eigenschaften `header` und `footer` steuern die Plätze für Kopf- und Fußzeile jeder Seite. Kopf- und Fußzeilen werden **innerhalb der vorhandenen Seitenränder** dargestellt – sie reservieren keinen zusätzlichen Platz und verkleinern den Inhaltsbereich nicht.

**Container-Rahmen.** Ein Element, das an `'container'` verankert ist, wird in das Randband zwischen dem Satzspiegel und der Schnittkante gesetzt und erstreckt sich über die Breite des Inhaltsbereichs. Der Container der Kopfzeile reicht von der **oberen Schnittkante** bis zur Oberkante des Satzspiegels; der Container der Fußzeile von der Unterkante des Satzspiegels bis zur **unteren Schnittkante**. Anker `top-*` der Kopfzeile und Anker `bottom-*` der Fußzeile messen also von der Schnittkante aus, Anker `bottom-*` der Kopfzeile und Anker `top-*` der Fußzeile dagegen von der Kante des Satzspiegels. Der Container schließt nie den Anschnitt oder das Band der Schnittmarken ein, sodass eine Kopf- oder Fußzeile auf der beschnittenen Seite an derselben Stelle landet, ob `page.cutLines` ein- oder ausgeschaltet ist. Verankern Sie an `'page'` (der Trim-Box) oder `'bleed'`, um über die Breite des Inhaltsbereichs hinaus oder in den Anschnitt zu reichen.

Die Plätze verwenden das einheitliche Modell der **Gestaltungsplätze**: Jedes Element hat eine `placement` mit einem `anchor` (am Container oder über `#id` an einem anderen Element), einem optionalen `offset` und einer optionalen `size`. Die alten flachen Felder `align`, `marginFromBody`, `marginFromEdge` und `width: 'full'` werden bei der Eingabe weiterhin akzeptiert und automatisch in die neue Form überführt; die entsprechende Beschreibung in der neuen Form ist unten dokumentiert.

Jeder Platz enthält eine Liste von Elementen der Arten **Text**, **Linie** und **Kasten**. Die Reihenfolge im Array ist die Zeichenreihenfolge (das erste Element wird zuerst gezeichnet, das letzte obenauf). Das gilt unabhängig von den Ankern: Ein Element kann an einem später aufgeführten verankert sein (`anchor.to: '#ttl'`), sodass ein Hintergrundkasten zuerst kommen und trotzdem an dem Text ausgerichtet werden kann, hinter dem er liegt.

**Mitgelieferte Standardwerte.** Wenn `header` oder `footer` `undefined` ist, wendet postext einen sinnvollen mitgelieferten Standard an statt eines leeren Platzes:

- **Standard-Kopfzeile:** `{title}` rechtsbündig auf ungeraden Seiten, `{chapterTitle}` linksbündig auf geraden Seiten und eine Linie über die ganze Breite – alles in der Hauptfarbe der Palette, Open Sans 8 pt/600, `marginFromBody` `16pt` (Text) / `13pt` (Linie).
- **Standard-Fußzeile:** `{pageNumber}` zentriert auf jeder Seite in der Hauptfarbe der Palette, Open Sans 8 pt/600, `marginFromBody` `16pt`.

Um auf die mitgelieferten Standardwerte zu verzichten, setzen Sie `header: { elements: [] }` (oder `footer: { elements: [] }`). Ein ausdrücklich leeres Array `elements` bleibt als „keine Elemente“ erhalten – nur `undefined` löst die Standardwerte aus.

| Eigenschaft | Typ | Standardwert | Beschreibung |
| --- | --- | --- | --- |
| `elements` | `HeaderFooterElement[]` | mitgelieferte Standardwerte bei `undefined`; `[]` schaltet ab | Geordnete Liste von Text- und Linienelementen. |

### Textelemente

Textelemente stellen eine Vorlagenzeichenkette dar, in der Platzhalter ersetzt werden. Platzhalter verwenden die Syntax `{name}`; `{{` und `}}` geben wörtliche geschweifte Klammern aus.

Die Standardwerte in der folgenden Tabelle sind die eines Textelements, das Sie selbst hinzufügen. Die oben unter **Mitgelieferte Standardwerte** beschriebene Kopf- und Fußzeile sind fertige Elemente mit eigenen Werten (Open Sans 8 pt/600 in der Hauptfarbe der Palette), nicht die Standardwerte der Elemente.

| Eigenschaft | Typ | Standardwert | Beschreibung |
| --- | --- | --- | --- |
| `kind` | `'text'` | — | Unterscheidungsmerkmal. |
| `id` | `string` | — | Stabile ID, eindeutig innerhalb des Platzes. Andere Elemente verankern sich daran mit `anchor.to: '#id'`. Die Sandbox vergibt beim Anlegen eine. |
| `content` | `string` | `''` | Vorlagenzeichenkette. Unterstützt die unten aufgeführten Platzhalter sowie `{attr.<key>}` – ein Attribut, das in der H1-Zeile des aktuellen Kapitels steht (`# Title {author="I. Zango"}`). Ein fehlendes Attribut wird ohne Warnung zu einer leeren Zeichenkette aufgelöst. Ein Zeilenumbruch – oder die beiden Zeichen `\n`, in der Vorlage oder in einem Attributwert geschrieben – beginnt immer eine neue Zeile, gleich welcher `overflow` gilt. Text, den ein Platzhalter aus dem Dokument übernimmt (ein Titel, ein Feld des Frontmatters), wird so gedruckt, wie er geschrieben ist: Dort beginnt nur ein echter Zeilenumbruch, etwa ein Titelumbruch, eine neue Zeile. |
| `align` | `'left' \| 'center' \| 'right' \| 'justify' \| 'start' \| 'end'` | `'center'` | Horizontale Ausrichtung der Zeilen im Kasten des Elements. `'justify'` dehnt die Wortzwischenräume jeder umbrochenen Zeile außer der letzten jedes Absatzes, sodass die Zeile den Kasten füllt; die Zeilen neben einer Initiale füllen den Platz daneben. Mit `hyphenate` wird ein Wort, das nicht in den Rest einer Blocksatzzeile passt, zusätzlich an einer Silbe getrennt, um sie zu füllen. Die letzte Zeile eines Absatzes, eine Zeile ohne dehnbaren Zwischenraum und ein Text, der nicht umbricht, werden linksbündig gesetzt. Text im Blocksatz wird Absatz für Absatz umbrochen, sodass Leerzeilen zwischen Absätzen als eine zählen. Canvas und PDF setzen jedes Wort dorthin, wo das Layout es platziert hat; das HTML vergrößert die Zwischenräume mit `word-spacing`. `'start'` und `'end'` folgen der `direction` des Texts: rechts und links bei einem Text von rechts nach links. `'left'` und `'right'` sind die eigenen Seiten des Kastens; in einer Gestaltung, die im Fluss einer Seite von rechts nach links umbrochen wird (ein Auftaktband, eine Überschriftengestaltung), ist der Fluss gespiegelt, sodass sie dessen Anfang und Ende sind, wie im Fließtext. |
| `direction` | `'ltr' \| 'rtl' \| 'auto'` | die des Dokuments | Grundrichtung des Texts: wohin seine neutralen Zeichen gehen, in welcher Reihenfolge seine Folgen auf einer Zeile stehen und welche Seiten `'start'` und `'end'` bedeuten. `'auto'` liest den ersten stark gerichteten Buchstaben des aufgelösten Texts und greift sonst auf die [`direction`](https://postext.dev/de/docs/configuration-language.md#schreibrichtung) des Dokuments zurück. Arabische und hebräische Folgen laufen unabhängig von der Grundrichtung von rechts nach links. Ein Text, der einen arabischen Buchstaben enthält, wird nie gesperrt (`letterSpacing` wird für den ganzen Text ignoriert), und seine Wörter werden beim Umbrechen oder Kürzen nie getrennt; ein Wort, das breiter als der Kasten ist, läuft über und wird als `unbreakableWordOverflow` gemeldet. |
| `parity` | `'all' \| 'odd' \| 'even'` | `'all'` | Auf welchen Seiten das Element erscheint (Parität der Seitenzahl: Seite 1 ist ungerade). |
| `pages` | `'all' \| 'body' \| 'opener' \| 'part' \| 'blank'` | `'all'` | Auf welchen *Seitenrollen* das Element erscheint, kombiniert mit `parity`. Nach der Platzierung wird jede Seite eingeordnet als `'blank'` (Auffüllung zur Parität oder als Trennseite, oder kein Inhalt), `'part'` (eine Teiltitelseite), `'opener'` (ihr erster Block ist eine Überschrift, deren Ebene über die ganze Seite reicht oder einen Seitenumbruch davor erzwingt – die erste Seite eines Kapitels) oder `'body'` (alles andere). `pages: 'body'` blendet einen Kolumnentitel auf Kapitelauftakten aus; `pages: 'opener'` zeigt eine Pagina nur dort. |
| `fontFamily` | `string` | `'EB Garamond'` | Schriftfamilie. |
| `fontSize` | `Dimension` | `8 pt` | Schriftgröße. |
| `fontWeight` | `number` | `400` | Schriftstärke (100–900). |
| `italic` | `boolean` | `false` | Ob kursiv gesetzt wird. |
| `color` | `ColorValue` | `#000000` | Textfarbe. |
| `overflow` | `'wrap' \| 'ellipsis-start' \| 'ellipsis-middle' \| 'ellipsis-end' \| 'clip'` | `'wrap'` in Überschriften- und Teilgestaltungen, sonst `'ellipsis-end'` | Wie die Engine Text behandelt, der die verfügbare Breite des Elements überschreitet. `'wrap'` bricht die Zeile in mehrere Zeilen um; die Varianten mit Auslassungspunkten halten jede Zeile auf einer Zeile und kürzen sie mit `…` am Anfang, in der Mitte oder am Ende; `'clip'` schneidet hart am Begrenzungsrahmen des Elements ab, ohne ein Zeichen einzufügen. Zeilenumbrüche im Inhalt gelten in jedem Modus: Die Modi mit Auslassungspunkten und Abschneiden kürzen bzw. beschneiden jede Zeile für sich. Ein Element, das `overflow` weglässt, übernimmt den Standardwert seines Platzes: In einer Überschriftengestaltung (`advancedDesign.slot`) oder auf einer Teiltitelseite (`parts.design`, `parts.versoDesign`) bricht es um, in einem Kolumnentitel, einer Pagina oder einer Teilzeile des Inhaltsverzeichnisses (`toc.parts.design`, eine Zeile fester Höhe) endet es mit `…`. Setzen Sie `'wrap'` bei einem Kolumnentitel, der mehrere Zeilen lang werden kann (eine Adresse), oder Auslassungspunkte bei einer Dachzeile, die in einem Auftakt auf einer Zeile bleiben muss. Eine durch Auslassungspunkte gekürzte Zeile oder eine, deren Farbe über den Kasten hinaus abgeschnitten wird, wird als Inhaltswarnung `designTextTruncated` gemeldet, einmal pro Element und Seite (bei einem Kolumnentitel oder einer Pagina einmal pro Element und Kapitel). Eine Konfiguration, die vor postext 1.24 gespeichert wurde (`configVersion` 9 oder älter), wird bei jedem Überschriften- und Teiltext, der keinen Wert setzt, mit `'ellipsis-end'` gelesen, damit sich ihre Seiten nicht verschieben. Ein Text mit einer `dropCap` bricht unabhängig von dieser Einstellung um; mit `'clip'` werden seine Zeilen weiterhin am Rand eines Kastens fester Höhe abgeschnitten. `'ellipsis-end'` und `'ellipsis-start'` kürzen an einer Wortgrenze – *The history of…*, nicht *The history of th…* –, und kein Leerzeichen und kein verbindendes Satzzeichen (Komma, Doppelpunkt, Strich, Schrägstrich, öffnende Klammer) berührt die Auslassungspunkte. Ein Wort wird nur dann an beliebiger Stelle gekürzt, wenn die Wortgrenze ohne dieses Satzzeichen weniger als die Hälfte dessen behielte, was passt: ein einziges langes Wort oder eine URL (*http://exampl…*, nicht *http…*). Ein geschütztes Leerzeichen oder ein geschützter Bindestrich (U+2011, wie in *MS‑DOS*) ist keine Wortgrenze; `'ellipsis-middle'` kürzt an beliebiger Stelle, verwirft aber die Leerzeichen daneben. Bis postext 1.4 kürzte jeder Modus beim letzten Zeichen, das passte, Leerzeichen eingeschlossen. |
| `verticalAlign` | `'top' \| 'middle' \| 'bottom'` | `'middle'` | Wo der Text in einem Kasten steht, der höher ist als seine Zeilen – eine feste `placement.size.height` oder ein Kasten, den ein verankerter Nachbar streckt. Sind die Zeilen höher als der Kasten (eine große Ziffer in einem Kasten fester Höhe, ein knapper `lineHeight`), laufen sie auf der Seite hinaus, die die Ausrichtung frei lässt, wie bei der Flex-Ausrichtung in CSS: `'bottom'` hält den Fuß des letzten Zeilenkastens auf dem Fuß des Kastens und läuft oben hinaus, `'middle'` läuft an beiden Enden gleichmäßig hinaus, `'top'` am Fuß. Bis postext 1.4 hingen solche Zeilen unabhängig von der Ausrichtung immer am oberen Rand. Eine `dropCap` bewegt sich mit ihren Zeilen (bis postext 1.4 blieb sie oben in einem Kasten, in dem `'middle'` oder `'bottom'` die Zeilen nach unten verschob). |
| `lineHeight` | `number \| Dimension` | `1.2` | Zeilenabstand der Zeilen des Elements. Eine Zahl ist ein Vielfaches von `fontSize`. Eine `Dimension` wird ebenfalls akzeptiert, so wie jeder andere Zeilenabstand der Konfiguration geschrieben wird: `em` / `rem` ist dasselbe Vielfache, und eine absolute Länge (`pt`, `mm`, `px` …) ist der Abstand zwischen den Grundlinien – `{ value: 15.5, unit: 'pt' }` setzt 15,5 pt Zeilenabstand unabhängig von der Schriftgröße. Alles andere (null, eine negative Zahl, eine fehlerhafte Dimension) erhält den Standardwert. Bis postext 1.4 machte eine `Dimension` hier die Höhe der Gestaltung unmessbar: Ein Auftakt reservierte dann überhaupt keinen Platz, nicht einmal seine `minHeight`, und der Fließtext lief unter den Titel. |
| `letterSpacing` | `Dimension` | `0` | Laufweite: zusätzlicher Vorschub nach jedem Zeichen, Leerzeichen eingeschlossen, genau wie bei `letter-spacing` in CSS. Gemessene Breiten wachsen mit, sodass ein Kasten mit automatischer Breite eng bleibt. Die Glyphen ändern sich nie: Die Ligaturen der Schrift bleiben im Canvas, im HTML, im EPUB und im PDF erhalten (bis postext 1.27 verwarfen Canvas und HTML sie in gesperrtem Gestaltungstext, der dadurch breiter ausfiel als gemessen). Eine hebräische Folge wird wie lateinischer Text gesperrt; nur ein Text mit arabischen Buchstaben nicht. Die Sperrung nach dem letzten Zeichen einer Zeile bleibt bei ihrer Ausrichtung und bei einem Kasten mit automatischer Breite unberücksichtigt, sodass ein zentrierter gesperrter Titel auf seinen Buchstaben zentriert ist, ein rechtsbündiger an der Kante endet und der letzte Buchstabe einer Blocksatzzeile die Kante erreicht (bis postext 1.4 standen sie eine halbe oder ganze Sperreinheit weiter links, und ein Element, das rechts an einem gesperrten verankert war, stand eine Sperreinheit weiter entfernt). Ein negativer Wert rückt die Buchstaben enger zusammen – ein Displaytitel in 36 pt erhält oft `{ value: -0.3, unit: 'pt' }` –, und die Breiten schrumpfen entsprechend; Canvas, HTML und PDF zeichnen ihn gleich (bis postext 1.4 wurde ein negativer Wert ohne Warnung als `0` gesetzt). |
| `textTransform` | `'none' \| 'uppercase'` | `'none'` | Umwandlung der Groß- und Kleinschreibung, angewendet auf den aufgelösten Text, Platzhalter eingeschlossen – etwa ein Teiltitel, der im Inhaltsverzeichnis in Versalien gesetzt wird. |
| `box` | `ElementBoxStyle` | — | Optionaler Hintergrund und Rahmen, die hinter dem Text gezeichnet werden: `backgroundColor`, `borderColor`, `borderWidth`, `borderRadius` und ein `padding` pro Seite, das den Kasten über den Text hinaus vergrößert (die Felder siehe [Kastenelemente](https://postext.dev/de/docs/configuration-headers-footers.md#kastenelemente)). |
| `dropCap` | `{ lines, fontFamily, fontWeight, fontSize, color, gap }` | — | Initiale: der erste Buchstabe groß neben den ersten `lines` Zeilen gesetzt (Standardwert 2), in eigener Schrift, Schriftstärke und Farbe, im Abstand `gap` vom Text. Der Buchstabe steht auf der Grundlinie der letzten Zeile, die er überspannt, und `fontSize` ist standardmäßig die Größe, die seine Oberkante auf die Höhe der Versalien der ersten Zeile bringt: die Textgröße plus `lines` − 1 Zeilenabstände, wobei die Versalhöhe als 0,72 der Schriftgröße angenommen wird (eine Schrift, deren Versalien deutlich höher oder niedriger sind, braucht eine eigene `fontSize`). Ein Text mit einer Initiale bricht unabhängig von seinem `overflow` um; mit `'clip'` werden seine Zeilen weiterhin am Rand eines Kastens fester Höhe abgeschnitten. Eine mit der Palette verknüpfte `color` folgt wie der Rest der Gestaltung den Paletten von Teilen und Abschnitten. In einer Überschriftengestaltung reserviert der Buchstabe keinen Platz unter dem Text: Der Teil seines Zeilenkastens unter seiner Grundlinie schiebt den Fließtext nicht nach unten. Ein Buchstabe mit Unterlänge (ein Q oder ein J in vielen Schriften) kann dann in den Raum unter der Gestaltung reichen: Geben Sie der Überschrift dafür einen `marginBottom`. Bis postext 1.4 machte die Standardgröße den Buchstaben so hoch wie alle Zeilenkästen, die er überspannt, sodass seine Oberkante über der ersten Zeile stand; ein `overflow` außer `'wrap'` ließ den Buchstaben ohne Warnung weg; eine Palette eines Abschnitts oder Teils ließ seine Farbe unverändert; und ein Buchstabe, der so tief war wie der Text daneben, konnte den Fließtext eine Rasterlinie tiefer schieben. Früher gespeicherte Konfigurationen behalten die Größe von 1.4, ausgeschrieben als `fontSize` (siehe [Pakete, die postext 1.4 oder früher geschrieben hat](https://postext.dev/de/docs/configuration-bundles.md#pakete-die-postext-14-oder-früher-geschrieben-hat)). Eine Initiale im laufenden Text wird stattdessen über die Absatz- und Überschriftenformate eingestellt (siehe [Initialen](https://postext.dev/de/docs/configuration-text.md#initialen)), wobei ihre Versalhöhen aus den Schriften gemessen werden. |
| `paragraphIndent` | `Dimension` | `0` | Erstzeileneinzug jedes Absatzes nach dem ersten. Ein Zeilenumbruch im Inhalt – oder die beiden Zeichen `\n` bei Text aus einem Attributwert – trennt Absätze; aufeinanderfolgende Zeilenumbrüche zählen als einer. |
| `hyphenate` | `boolean` | `false` | Bei `true` und umbrechendem Text (`overflow: 'wrap'` oder eine `dropCap`, die immer umbricht) werden lange Wörter, die nach einem regulären Zeilenumbruch immer noch überlaufen würden, an Silbengrenzen getrennt (mit dem aktiven Silbentrennungs-Locale des Dokuments), mit einem weichen Trennstrich an der Trennstelle. In einem Text im Blocksatz (`align: 'justify'`) wird ein Wort, das nicht in den Rest einer Zeile passt, zusätzlich an seiner letzten passenden Trennstelle getrennt, um die Zeile zu füllen. |
| `inlineMarks` | `boolean` | `false` | Liest den aufgelösten Text – Platzhalterwerte eingeschlossen – als Inline-Markdown: `**bold**`, `*italic*`, `^superscript^`, `~subscript~`. Ausgeschaltet werden die Auszeichnungszeichen so gedruckt, wie sie geschrieben sind. In einer Überschriftengestaltung behält `{titleText}` dann die eigenen fetten, kursiven, hoch- und tiefgestellten Folgen der Überschrift (`*Pneumocystis*`, `CO~2~`), während ihre übrigen Zeichen maskiert werden, damit sie so gedruckt werden, wie sie geschrieben sind (seit postext 1.19). Siehe [Inline-Auszeichnungen und Konturen](https://postext.dev/de/docs/configuration-headers-footers.md#inline-auszeichnungen-und-konturen). |
| `stroke` | `{ width, color?, hollow? }` | — | Kontur um die Buchstaben: `width` (eine `Dimension`, auf den Glyphenkanten zentriert), `color` (Standardwert: die Textfarbe; eine Initiale nimmt ihre eigene Farbe) und `hollow` (`true` zeichnet nur die Kontur). Siehe [Inline-Auszeichnungen und Konturen](https://postext.dev/de/docs/configuration-headers-footers.md#inline-auszeichnungen-und-konturen). |
| `writingMode` | `'horizontal-tb' \| 'vertical-rl'` | `'horizontal-tb'` | `'vertical-rl'` setzt den Text von oben nach unten, die Zeilen von rechts nach links, die Zeichen aufrecht: ein Kolumnentitel am Vorderschnitt entlang, ein vertikaler Titel neben einem horizontalen Kapitel. Siehe [Vertikale Textelemente](https://postext.dev/de/docs/configuration-headers-footers.md#vertikale-textelemente). |
| `reserve` | `boolean` | `true` | Nur Überschriftengestaltungen: ob das Element zur Höhe zählt, die die Überschrift im Textfluss reserviert. `false` für Dekoration, die unter dem Text liegen darf (ein Siegel am Seitenfuß, ein Rahmen, ein seitliches Band). Siehe [Reservierte Höhe](https://postext.dev/de/docs/configuration-headings.md#reservierte-höhe). Kopfzeilen-, Fußzeilen- und Teilgestaltungen ignorieren es. |
| `marginFromBody` | `Dimension` | `6 pt` | Absoluter Abstand zwischen der dem Satzspiegel zugewandten Kante des Elements und der Kante des Satzspiegels. Unabhängig von anderen Elementen. Wird in `placement.offset.y` überführt. |
| `marginFromEdge` | `Dimension` | `0 pt` | Horizontaler Einzug von der ausgerichteten Inhaltskante. Gilt nur, wenn `align` `'left'` oder `'right'` ist. Wird in `placement.offset.x` überführt. |
| `placement` | `ElementPlacement` | abgeleitet aus `align` + `marginFromBody` + `marginFromEdge` | Erweiterte Platzierung (siehe unten). Wenn gesetzt, hat sie Vorrang vor den alten flachen Feldern. |

Verfügbare Platzhalter:

- `{pageNumber}` – Seitenzahl der aktuellen Seite, ab 1 gezählt.
- `{totalPages}` – Gesamtzahl der Seiten des Dokuments. In einem Buch, das Kapitel für Kapitel umbrochen wird (die Sandbox, `buildBundle`), ist jedes Kapitel ein Dokument, dies ist also die eigene Seitenzahl des Kapitels.
- `{bookTotalPages}` – Gesamtzahl der Seiten des ganzen Buchs: jedes Kapitel, Vakatseiten eingeschlossen. Bei einem für sich allein umbrochenen Dokument entspricht sie `{totalPages}`. Siehe [Seitenzahl des ganzen Buchs](https://postext.dev/de/docs/configuration-headers-footers.md#seitenzahl-des-ganzen-buchs) unten.
- `{title}`, `{subtitle}`, `{author}`, `{publishDate}` – Werte aus `content.metadata`. Unbekannte oder leere Metadaten ergeben eine leere Zeichenkette (und lösen in der Sandbox eine Warnung aus).
- `{chapterTitle}` – Text der letzten H1 auf oder vor der aktuellen Seite. Eine H1, deren [Überschriftenformat](https://postext.dev/de/docs/configuration-styles.md#überschriftenstile) `runningChapter: false` setzt (eine Tafel, eine Karte), wird übergangen.
- `{chapterTitleAtTop}`, `{chapterNumberAtTop}` – Titel und Nummer des Kapitels, das am Kopf der Seite gilt; sie unterscheiden sich von `{chapterTitle}` und `{chapterNumber}` auf einer Seite, auf der ein neues Kapitel unterhalb anderen Texts beginnt. Siehe [Kapitel am Kopf der Seite](https://postext.dev/de/docs/configuration-headers-footers.md#kapitel-am-kopf-der-seite) unten.
- `{partTitle}`, `{partNumber}` – Titel und Nummer des aktuellen Teils (die letzte `:::part`-Seite auf oder vor der aktuellen Seite; leere Paritätsseiten direkt vor einer Teiltitelseite gehören bereits zu ihr). Leer vor dem ersten Teil.
- `{firstMark.<key>}`, `{lastMark.<key>}` – das erste und letzte Leitwort der Seite: eine Überschrift einer Ebene (`h1`–`h6`) oder ein Eintrag eines Absatzformats. Siehe [Leitwörter](https://postext.dev/de/docs/configuration-headers-footers.md#leitwörter-erste-und-letzte-marke) unten.

#### Seitenzahl des ganzen Buchs

`{bookTotalPages}` druckt die Seitenzahl des ganzen Buchs, die Zahl, die ein Leser in „Seite 12 von 348“ sieht. Sie zählt physische Seiten, leere eingeschlossen, wie `{totalPages}`, aber über alle Kapitel hinweg:

- **Ein für sich allein umbrochenes Dokument** (`buildDocument` ohne `continuation`) ist das ganze Buch: `{bookTotalPages}` entspricht `{totalPages}`.
- **`buildBundle`** umbricht das Buch, addiert die Seiten aller Kapitel und umbricht es mit dieser Summe ein weiteres Mal, sodass jedes Kapitel dieselbe Zahl druckt. Die Zahl verschiebt nie einen Seitenumbruch, deshalb genügt eine weitere Runde; eine Konfiguration, die `{bookTotalPages}` nicht druckt, kostet nichts.
- **Die Sandbox** übergibt jedem Kapitel die Summe, sobald die Seiten aller Kapitel bekannt sind. Bis dahin druckt ein Kapitel die Seiten bis zu seinem eigenen Ende. Der Export des ganzen Buchs im Tab PDF zählt die Seiten, die er umbricht: Hat ein Kapitel eine andere Zahl gedruckt, weil seine Seiten noch nicht bekannt waren, umbricht er das Buch ein weiteres Mal mit der Zahl, auf die die Kapitel gekommen sind.
- **Eine Host-Anwendung, die Kapitel selbst umbricht,** übergibt die Summe als `continuation.bookPageCount` (auch dem ersten Kapitel). Ohne sie zählt `{bookTotalPages}` die Seiten bis zum Ende des Dokuments (`continuation.pageIndexOffset` plus seine eigenen Seiten), was nur für das letzte Kapitel stimmt.

```ts
footer: {
  elements: [{
    kind: 'text', id: 'folio', content: '{pageNumber} / {bookTotalPages}',
    fontSize: { value: 8, unit: 'pt' },
    placement: { anchor: { to: 'container', edge: 'top' }, size: { width: 'auto', height: 'auto' } },
  }],
}
```

`configUsesPlaceholder(config, 'bookTotalPages')` teilt einer Host-Anwendung mit, ob sich die Berechnung der Zahl lohnt.

#### Leitwörter: erste und letzte Marke

Ein Wörterbuch druckt das erste und letzte Stichwort jeder Seite in ihrem Kolumnentitel („Aback – Anchor“); ein Nachschlagewerk druckt den ersten und letzten Abschnitt. `{firstMark.<key>}` und `{lastMark.<key>}` drucken sie. Der Schlüssel benennt, was eine Seite markiert:

- **`h1` bis `h6`**: eine Überschrift dieser Ebene. Die Marke ist ihr Text, ohne die Nummer.
- **Die ID eines Absatzformats** (`entry`): ein Absatz eines Containers `:::paragraphs{style="entry"}`. Die Marke ist die fette Folge, mit der der Absatz beginnt, das Stichwort, ohne das schließende Satzzeichen: `**Aback.** Said of…` markiert `Aback`. Ein Absatz, der nicht mit fettem Text beginnt, setzt keine Marke.

`{firstMark.<key>}` ist die erste Marke, die auf der Seite beginnt, und `{lastMark.<key>}` die letzte. Eine Seite, auf der keine Marke beginnt (ein langer Eintrag, der weiterläuft), druckt für beide die geltende Marke, die letzte davor. Seiten vor der ersten Marke drucken nichts; in einem Buch, das Kapitel für Kapitel umbrochen wird, ist das die erste Marke des Kapitels, da Marken nicht von einem Kapitel ins nächste übernommen werden. Eine Überschrift oder ein Absatz, der über Seiten geteilt ist, markiert nur die Seite, auf der er beginnt. Der Schlüssel wird nach dem Punkt aus Buchstaben, Ziffern, `_` und `-` geschrieben und beginnt mit einem Buchstaben oder `_`; ein unbekannter Schlüssel druckt nichts.

```md
:::paragraphs{style="entry"}
**Aback.** Said of the sails when pressed back against the mast.

**Abaft.** Towards the stern, or behind a given point.
:::
```

```ts
header: {
  elements: [{
    kind: 'text', id: 'guide', content: '{firstMark.entry} – {lastMark.entry}',
    fontSize: { value: 8, unit: 'pt' },
    placement: { anchor: { to: 'container', edge: 'bottom' }, size: { width: 'auto', height: 'auto' } },
  }],
}
```

Leitwörter sind Kolumnentitel: Sie werden in den Plätzen von Kopf- und Fußzeile aufgelöst (einschließlich `header` und `footer` eines Überschriftenformats) und drucken in Überschriften-, Teil- und Inhaltsverzeichnisgestaltungen nichts; in Überschriften- und Teilgestaltungen markiert das Bedienfeld Prüfungen sie als unbekannte Platzhalter. Um das erste Stichwort auf linken und das letzte auf rechten Seiten zu zeigen, geben Sie zwei Elementen `parity: 'even'` und `parity: 'odd'`. Eine H1, deren Überschriftenformat `runningChapter: false` setzt, setzt keine Marke `h1`.

#### Kapitel am Kopf der Seite

`{chapterTitle}` und `{chapterNumber}` nennen das letzte Kapitel, das auf oder vor der Seite begonnen hat. In einem Buch, dessen Kapitel ohne Seitenumbruch dazwischen fortlaufend gesetzt sind, trägt eine Seite, die ein Kapitel abschließt und das nächste nahe ihrem Fuß beginnt, dann den Titel des neuen Kapitels über Text, der noch zum alten gehört. `{chapterTitleAtTop}` und `{chapterNumberAtTop}` nennen stattdessen das Kapitel, das am Kopf der Seite gilt, wie es Romane mit fortlaufenden Kapiteln und viele Nachschlagewerke tun:

- Eine Seite, deren erster Block die H1 eines Kapitels ist, nennt dieses Kapitel;
- jede andere Seite nennt das Kapitel, aus dem sie weiterläuft, auch wenn weiter unten ein neues Kapitel beginnt;
- eine zur Parität eingefügte Vakatseite gehört zur Seite danach, die Trennseite der Modi `always-*` zur Seite davor (siehe [Zugehörigkeit leerer Seiten](https://postext.dev/de/docs/configuration-headings.md#zugehörigkeit-leerer-seiten)); beginnt die Seite nach einer Paritäts-Vakatseite mit dem Ende eines Kapitels statt mit seiner H1, behält auch die Vakatseite dieses Kapitel;
- eine H1 mit `runningChapter: false` wird übergangen.

```ts
header: {
  elements: [{
    kind: 'text', id: 'chapter', content: '{chapterTitleAtTop}', parity: 'odd', pages: 'body',
    fontSize: { value: 8, unit: 'pt' },
    placement: { anchor: { to: 'container', edge: 'bottom-right' }, size: { width: 'auto', height: 'auto' } },
  }],
}
```

Wie Leitwörter sind beide Kolumnentitel: Sie werden in den Plätzen von Kopf- und Fußzeile aufgelöst und drucken in Überschriften-, Teil- und Inhaltsverzeichnisgestaltungen nichts. `{attr.<key>}` liest immer das zuletzt begonnene Kapitel.

#### Aus der Kante abgeleitete Ausrichtung

Wenn `placement.anchor.to` eines Textelements über `#id` auf ein anderes Element verweist, legt die Ankerkante eine Standardausrichtung für umbrochene Zeilen nahe:

- `right-of` und `align-left` bedeuten Text mit `align: 'left'` – umbrochene Zeilen laufen vom Anker aus nach rechts.
- `left-of` und `align-right` bedeuten `align: 'right'` – umbrochene Zeilen schmiegen sich an die Seite, die dem Ankerziel am nächsten liegt.

Der Überschriftenseditor der Sandbox wendet diese abgeleiteten Ausrichtungen automatisch an, wenn Sie Ankerkante oder Ankerziel ändern. Sie halten mehrzeiligen umbrochenen Text optisch an dem Element verankert, auf das er sich bezieht (sodass z. B. das „P“ eines umbrochenen „Postext“ senkrecht unter dem „I“ von „Introduction“ steht).

#### Inline-Auszeichnungen und Konturen

Ein Textelement setzt seinen Text standardmäßig in einer einzigen Schrift: `**`, `^` und die anderen Markdown-Zeichen werden so gedruckt, wie sie geschrieben sind. Mit `inlineMarks: true` wird der aufgelöste Text als Inline-Markdown gelesen, mit denselben Auszeichnungen, die der Fließtext annimmt (siehe **Dokumentformat → Inline-Formatierung**):

- `**bold**` setzt die Schriftstärke 700 (oder die eigene `fontWeight` des Elements, wenn diese kräftiger ist); `*italic*` kehrt die Neigung des Elements um, sodass eine Hervorhebung in einem kursiven Element aufrecht erscheint; `***both***` tut beides. Die Formen mit Unterstrich (`__bold__`, `_italic_`) funktionieren ebenfalls.
- `^superscript^` und `~subscript~` werden in 58 % der Größe gesetzt, hochgestellt um ein Drittel davon angehoben und tiefgestellt um 0,15 davon abgesenkt; ein tief- und ein hochgestelltes Zeichen, die aneinanderstoßen (`T~0~^2^`), werden übereinander gestapelt, wie im Fließtext.
- Ein Backslash setzt ein Auszeichnungszeichen als solches (`\*`, `\_`, `\^`, `\~`). Ein Link behält seinen Text; Backticks für Code werden verworfen.

Auszeichnungen werden gelesen, nachdem die Platzhalter ausgefüllt sind, sodass ein Wert sie enthalten kann: Eine Autorenzeile in einem Überschriftenattribut erhält ihre Zugehörigkeitsnummern hochgestellt. Umbruch, Blocksatz, die Modi mit Auslassungspunkten, `dropCap` und `paragraphIndent` funktionieren alle mit ausgezeichnetem Text; jede Folge behält die Farbe des Elements.

```json
{ "kind": "text", "id": "authors", "content": "{attr.authors}", "inlineMarks": true, "overflow": "wrap",
  "fontSize": { "value": 11, "unit": "pt" },
  "placement": { "anchor": { "to": "#title", "edge": "below" }, "offset": { "y": { "value": 6, "unit": "pt" } } } }
```

```md
# Snow cover and river flow {authors="Ana Ruiz^1^, Luis Gil^2^ and Marta Sanz^1,3^"}
```

`stroke` zeichnet eine Kontur um die Buchstaben: `width` ist die Linienstärke, auf den Glyphenkanten zentriert (die Hälfte fällt in die Buchstaben, die Hälfte nach außen; die gemessene Textbreite ändert sich nicht), `color` ist standardmäßig die Textfarbe, und `hollow: true` lässt die Buchstaben ungefüllt, sodass nur die Kontur sichtbar ist – eine konturierte Displayziffer, ein Titel, der sich von einem Foto abhebt. Die Kontur wird über die Füllung gezeichnet, auf dieselbe Weise im Canvas, im HTML (`-webkit-text-stroke`) und im PDF (Textdarstellungsmodus 2, oder 1 bei hohlen Buchstaben).

```json
{ "kind": "text", "id": "year", "content": "1863", "fontFamily": "Bitter", "fontSize": { "value": 120, "unit": "pt" }, "fontWeight": 700,
  "color": { "hex": "#1d3557", "model": "hex" },
  "stroke": { "width": { "value": 1.5, "unit": "pt" }, "hollow": true },
  "placement": { "anchor": { "to": "page", "edge": "bottom-right" }, "offset": { "x": { "value": -15, "unit": "mm" }, "y": { "value": -20, "unit": "mm" } } } }
```

Im PDF betten fette und kursive Folgen die passenden Schnitte der Schriftfamilie des Elements ein, der Schriftanbieter muss sie also liefern.

#### Standardwerte für Text und Fallstricke beim Verankern

Ein Textelement, das Sie selbst schreiben, beginnt mit diesen Werten, von denen einige überraschen:

- **`overflow` folgt dem Platz.** In einer Überschriftengestaltung oder auf einer Teiltitelseite bricht ein langer Titel auf weitere Zeilen um; in einem Kolumnentitel, einer Pagina oder einer Teilzeile des Inhaltsverzeichnisses wird ein Text, der für seinen Platz zu breit ist, mit `…` auf eine Zeile gekürzt. Setzen Sie `overflow: 'wrap'` bei einem Kolumnentitel, der lang werden kann (eine Adresse, eine Autorenzeile), und sehen Sie sich die Warnungen `designTextTruncated` für die gekürzten Texte an. Ein Zeilenumbruch im Inhalt (ein Zeilenumbruchzeichen oder `\n` in der Vorlage oder in einem Attributwert) beginnt in jedem Modus eine neue Zeile; die Modi mit Auslassungspunkten kürzen jede Zeile für sich.
- **`align` ist `'center'` und `verticalAlign` ist `'middle'`.** Ein Element mit automatischer Breite schmiegt sich an seine längste Zeile, sodass seine Zeilen zueinander zentriert sind; setzen Sie `align: 'left'` für einen linksbündigen Block (ein Element mit automatischer Breite, das an einem anderen Element verankert ist, richtet seine Zeilen von selbst auf der Seite seines Ankers aus, siehe oben).
- **Die Schrift ist EB Garamond 8 pt, schwarz, `lineHeight` 1,2**, gleich was der Fließtext verwendet. Anders als die übrigen Zeilenabstände der Konfiguration ist der `lineHeight` eines Gestaltungstexts meist ein einfaches Vielfaches (`1.2`); eine `Dimension` funktioniert ebenfalls (siehe oben).

Ein Element ohne `placement.size.width` (oder mit `'auto'`) passt seine Größe an seinen Text an, aber nur innerhalb des Platzes zwischen seinem Ankerpunkt und der Kante des Containers, zu der hin es wächst – bei einem Anker `top` oder `bottom` das Doppelte des Abstands zur näheren Kante. Sein `offset` zählt mit. Ein Versatz weg von dieser Kante kostet nichts: Ein Kolumnentitel mit Anker `top-left` und negativem `x` (der in den linken Rand hängt) verliert keinen Platz, denn er wächst nach rechts. Ein Versatz zu dieser Kante hin verkleinert den Platz um denselben Betrag (bei einem Anker `top` oder `bottom` um das Doppelte), und einer, der den Anker über die Kante hinausschiebt, lässt keinen übrig: ein Anker `top-right`, dessen `x` unter minus der Containerbreite liegt, oder ein Anker `top`, der um mehr als die halbe Breite seitlich verschoben ist. Bleibt kein Platz, druckt ein Modus mit Auslassungspunkten nichts, und `'wrap'` stapelt ein Zeichen pro Zeile. Drei Auswege:

- Geben Sie dem Element eine feste `size.width` – feste Breiten werden nie begrenzt;
- verankern Sie es an `'page'` oder `'bleed'`, wodurch die Seite (oder der Anschnitt) seinen Platz einrahmt;
- verankern Sie es an der gegenüberliegenden Kante des Containers.

Der Container einer Kopfzeile reicht von der oberen Schnittkante bis zum Satzspiegel, der einer Fußzeile vom Satzspiegel bis zur unteren Schnittkante: In einer Kopfzeile messen Anker `top-*` von der Schnittkante und Anker `bottom-*` vom Satzspiegel aus, in einer Fußzeile umgekehrt (siehe **Container-Rahmen** oben). Eine Kopf- oder Fußzeile verschiebt den Fließtext nie und wird über ihn gezeichnet, sodass ein Element, das in den Bereich des Satzspiegels geschoben wird, den Text verdeckt. Ein Auftaktband dagegen wird unter den Fließtext gezeichnet; wie viel Platz es im Fluss einnimmt, ist unter [Reservierte Höhe](https://postext.dev/de/docs/configuration-headings.md#reservierte-höhe) beschrieben.

### Vertikale Textelemente

Ein Textelement mit `writingMode: 'vertical-rl'` wird vertikal in einem Platz gesetzt, dessen Text horizontal ist: die Kolumnentitel und Paginas jedes Buchs, die auf dem Blatt bleiben, und jede Gestaltung einer horizontalen Seite. Es wird als horizontaler Text in einem eigenen Rahmen umbrochen, der eine Vierteldrehung im Uhrzeigersinn gedreht ist, und dann zurück auf die Seite gedreht:

- Sein Kasten bleibt dort, wo die Platzierung ihn hinsetzt. Seine Höhe ist die Länge einer Zeile: `size.height` legt sie fest (oder `'auto'`, die Länge des Texts; `'fill'`, bis zur Kante des Containers), `size.width` legt fest, wie viele Zeilen nebeneinander passen, und `size.maxWidth` begrenzt die Länge einer Zeile.
- `align` setzt die Zeilen entlang des Kastens (`'left'` oben), `verticalAlign` quer dazu (`'top'` rechts, wo die erste Zeile steht), und der Innenabstand eines Kastens bleibt auf der Seite, für die er geschrieben ist.
- Die Zeichen werden wie auf einer vertikalen Seite gemessen und gezeichnet: Han-Zeichen aufrecht, je ein Geviert, Satzzeichen in ihrer vertikalen Form, lateinische Wörter seitwärts, kurze Zahlen in einer Zelle (`cjk.uprightDigits`). Canvas, PDF und HTML setzen es in dasselbe Rechteck.
- Mit `inlineMarks: true` heben die Ausrichtungsauszeichnungen eine Folge wie im Fließtext ab: `第:tcy[3.0]回` setzt 3.0 in eine Zelle, `:upright[GDP]` stellt die Buchstaben aufrecht untereinander, `:sideways[…]` dreht eine Folge; innerhalb einer solchen bricht eine Zeile nie um. Ein horizontales Element ignoriert sie.
- Auf einem vertikalen Element wird keine Initiale gesetzt.
- Im Fluss einer vertikalen Seite (ein Auftakt, eine Teiltitelseite, ein Kastentitel) läuft Text bereits nach unten, und `writingMode` ändert dort nichts.

Vertikal gesetzte chinesische Bücher stellen ihre Kolumnentitel und Paginas an eine von drei Stellen ([clreq §7.2](https://www.w3.org/TR/clreq/#x7-2-page-headers-footers-etc); [JLREQ §2.6](https://www.w3.org/TR/jlreq/#running_heads_and_page_numbers) für Japanisch):

| Konvention | Wo | Einstellung |
| --- | --- | --- |
| Horizontaler Kopf und Fuß | Über und unter dem Satzspiegel, wie in horizontalen Büchern; am häufigsten. | Kopf- und Fußzeile, wie sie sind. |
| Vorderschnitt (Stil 中缝, in Taiwan 邊峰) | Den Außensteg hinunter: der Kapitel- oder Buchtitel ab etwa vier Zeichen unter dem Kopf des Satzspiegels, die Pagina etwa fünf Zeichen über seinem Fuß endend, in chinesischen Zahlzeichen, in etwa 80 % der Grundschriftgröße. | Zwei vertikale Elemente, verankert an `'outer'`, siehe unten. |
| Äußere untere Ecke | Die Pagina am Fuß der Seite, in der äußeren Ecke (die Regeln Taiwans für Bücher im Stil 中式). | Ein horizontales Element in der Fußzeile bei `'bottom-left'` mit `parity: 'odd'` und eines bei `'bottom-right'` mit `parity: 'even'` in einem rechts gebundenen Buch (in einem links gebundenen umgekehrt). |

Die Kolumnentitel am Vorderschnitt, wie die Sandbox sie hinzufügt (**Kopfzeile › Kolumnentitel am Außenrand (vertikal)**), hier für einen Fließtext von 10 pt (die Sandbox setzt sie in 80 % der Grundschriftgröße):

```json
{
  "page": { "pageNumbering": { "format": "trad-chinese-informal" } },
  "header": { "elements": [
    { "kind": "text", "id": "head", "content": "{chapterTitle}", "writingMode": "vertical-rl",
      "fontSize": { "value": 8, "unit": "pt" }, "overflow": "clip", "align": "left",
      "placement": { "anchor": { "to": "outer", "edge": "top" }, "offset": { "y": { "value": 4, "unit": "em" } } } },
    { "kind": "text", "id": "folio", "content": "{pageNumber}", "writingMode": "vertical-rl",
      "fontSize": { "value": 8, "unit": "pt" }, "overflow": "clip", "align": "left",
      "placement": { "anchor": { "to": "outer", "edge": "bottom" }, "offset": { "y": { "value": -5, "unit": "em" } } } }
  ] }
}
```

`anchor.to: 'outer'` (siehe [Platzierung von Elementen](https://postext.dev/de/docs/configuration-headers-footers.md#platzierung-von-elementen)) ist der Außensteg jeder Seite, sodass die beiden Elemente in einem rechts gebundenen Buch (`page.binding`) am linken Rand eines Rectos und am rechten Rand eines Versos hinunterlaufen. `{pageNumber}` wird im Nummernformat der Seiten gedruckt: `trad-chinese-informal` ergibt auf Seite 103 一百零三, `cjk-decimal` 一〇三. Die Regeln pro Platz gelten weiterhin: `pages: 'body'` hält einen Kolumnentitel von den Kapitelauftakten fern. Ein kurzes Ornament zwischen Kolumnentitel und Pagina (ein Fischschwanz ︻, eine Linie) ist ein gewöhnliches Element, das am selben Rahmen verankert ist.

Im VDT trägt ein vertikaler Block `vertical` (`VDTDesignTextBlock.vertical`: die Region, die aufrechten Ziffern und die zentrale Achse jeder Familie); seine Zeilen liegen im eigenen gedrehten Rahmen des Blocks, `xOffset` von der Oberkante des Kastens nach unten, `baselineY` von seinem rechten Rand nach links. Eine Folge einer ausgezeichneten Zeile trägt `tcy` oder `orientation`, wie ein Segment des Fließtexts.

### Linienelemente

Linienelemente zeichnen eine Linie: waagerecht über den Platz oder senkrecht an ihm hinunter.

| Eigenschaft | Typ | Standardwert | Beschreibung |
| --- | --- | --- | --- |
| `kind` | `'rule'` | — | Unterscheidungsmerkmal. |
| `id` | `string` | — | Stabile ID, eindeutig innerhalb des Platzes, für Verweise mit `anchor.to: '#id'`. |
| `direction` | `'horizontal' \| 'vertical'` | `'horizontal'` | Eine waagerechte Linie verläuft entlang `placement.size.width` (`'fill'` = bis zur Kante des Containers) und ist `thickness` hoch. Eine senkrechte Linie verläuft entlang `placement.size.height` nach unten (`'fill'` oder nicht gesetzt = bis zur Kante des Containers) und ist `thickness` breit – eine Trennlinie zwischen Kolumnentitel und Pagina. |
| `color` | `ColorValue` | `#000000` | Linienfarbe. |
| `thickness` | `Dimension` | `0.5 pt` | Linienstärke. Eine Linie, die sie weglässt, wird mit dem Standardwert gezeichnet (bis postext 1.4 zeichnete sie nichts). |
| `width` | `Dimension \| 'full'` | `'full'` | `'full'` reicht über den Inhaltsbereich; eine Dimension begrenzt die Linie auf eine feste Länge, die über `align` positioniert wird. |
| `align` | `'left' \| 'center' \| 'right'` | `'center'` | Ausrichtung, wenn `width` nicht `'full'` ist. |
| `marginFromBody` | `Dimension` | `6 pt` | Absoluter Abstand zwischen der dem Satzspiegel zugewandten Kante der Linie und der Kante des Satzspiegels. Unabhängig von anderen Elementen. |
| `marginFromEdge` | `Dimension` | `0 pt` | Horizontaler Einzug von der ausgerichteten Inhaltskante. Gilt nur, wenn `width` eine feste `Dimension` und `align` `'left'` oder `'right'` ist. |
| `parity` | `'all' \| 'odd' \| 'even'` | `'all'` | Auf welchen Seiten die Linie erscheint. |
| `pages` | `'all' \| 'body' \| 'opener' \| 'part' \| 'blank'` | `'all'` | Seitenrollen, auf denen die Linie erscheint (siehe das Feld `pages` der Textelemente). |
| `reserve` | `boolean` | `true` | Nur Überschriftengestaltungen: ob die Linie zur Höhe zählt, die die Überschrift im Textfluss reserviert (siehe [Reservierte Höhe](https://postext.dev/de/docs/configuration-headings.md#reservierte-höhe)). |
| `placement` | `ElementPlacement` | abgeleitet aus `align` + `marginFromBody` + `marginFromEdge` | Erweiterte Platzierung (siehe [Platzierung von Elementen](https://postext.dev/de/docs/configuration-headers-footers.md#platzierung-von-elementen)). `size.width` / `size.height` legen die Linienlänge fest; `width: 'fill'` ist das alte `'full'`. |

### Kastenelemente

Kastenelemente zeichnen ein abgerundetes Rechteck in den Platz – nützlich als Hintergrund hinter Text in Kapitelauftakten, Randspalten oder Fußzeilen. Kastenelemente werden ausschließlich über das Feld `placement` positioniert; sie haben keine alte flache Kurzform. Füllung, Kontur und Eckenradius stehen im verschachtelten Objekt `style` (`ElementBoxStyle`), wie im JSON-Beispiel unter „Platzierung von Elementen“.

| Eigenschaft | Typ | Standardwert | Beschreibung |
| --- | --- | --- | --- |
| `kind` | `'box'` | — | Unterscheidungsmerkmal. |
| `id` | `string` | — | Stabile ID, eindeutig innerhalb des Platzes. Benachbarte Elemente verankern sich daran mit `anchor.to: '#id'`. Die Sandbox vergibt beim Anlegen eine. |
| `style.backgroundColor` | `ColorValue` | `transparent` | Füllfarbe. Setzen Sie `transparent` für einen Kasten nur mit Kontur. |
| `style.borderColor` | `ColorValue` | `transparent` | Konturfarbe. |
| `style.borderWidth` | `Dimension` | `0 pt` | Konturstärke. Konturen werden an der Innenseite des Begrenzungsrechtecks des Kastens gezeichnet, damit die Außenmaße gleich bleiben: Die Außenkante der Kontur verläuft entlang der Kastenkante, und ein abgerundeter Kasten behält seinen äußeren Radius. Eine Kontur, die so breit ist wie der Kasten, füllt ihn. Canvas, HTML und PDF zeichnen sie gleich (bis postext 1.4 zentrierten Canvas und PDF die Kontur auf der Kante, zur Hälfte außerhalb des Kastens). |
| `style.borderRadius` | `Dimension` | `0 pt` | Eckenradius. Wird beim Zeichnen auf die Hälfte der kürzeren Seite begrenzt. |
| `placement` | `ElementPlacement` | — | Erforderlich. Siehe „Platzierung von Elementen“ unten. |
| `parity` | `'all' \| 'odd' \| 'even'` | `'all'` | Auf welchen Seiten der Kasten erscheint. |
| `pages` | `'all' \| 'body' \| 'opener' \| 'part' \| 'blank'` | `'all'` | Seitenrollen, auf denen der Kasten erscheint (siehe das Feld `pages` der Textelemente). |
| `reserve` | `boolean` | `true` | Nur Überschriftengestaltungen: ob der Kasten zur Höhe zählt, die die Überschrift im Textfluss reserviert (siehe [Reservierte Höhe](https://postext.dev/de/docs/configuration-headings.md#reservierte-höhe)). |

### Bildelemente

Ein Element `image` zeichnet eine Bitmap- oder SVG-Ressource des Dokuments – das Verlagslogo auf einer Titelseite, ein Zeichen in einem Kolumnentitel. Seine Größe ergibt sich aus seiner `placement.size`: Bleibt eine von `width` / `height` auf `'auto'` (dem Standardwert), folgt die andere Seite dem Seitenverhältnis des Bilds; sind beide gesetzt, wird das Bild in den Kasten eingepasst und zentriert. Eine fehlende Ressource oder eine, die kein Bild ist, zeichnet nichts.

```ts
{
  kind: 'image', id: 'logo', resourceId: 'logo-publisher',
  placement: { anchor: { to: 'page', edge: 'top-left' }, offset: { x: { value: 64, unit: 'mm' }, y: { value: 233, unit: 'mm' } }, size: { width: { value: 83, unit: 'mm' }, height: 'auto' } },
}
```

`resourceId` nimmt dieselben Platzhalter an wie `content` eines Textelements, sodass eine Gestaltung für jede Überschrift ein anderes Bild zeichnen kann. Mit `resourceId: '{attr.vignette}'` in einem Überschriftenformat zeichnet `# Chapter I {style="opener" vignette="log"}` die Ressource `log` und `# Chapter II {style="opener" vignette="wig"}` die Ressource `wig`: Die Kapitel teilen sich das Format, statt eines Klons pro Bild. Eine Kopf- oder Fußzeile liest die Attribute des Kapitels der Seite, wie es `{attr.<key>}` in einem Kolumnentitel tut, und auch andere Platzhalter funktionieren (`'map-{chapterNumber}'`). Eine ID, die leer ausfällt, etwa bei einer Überschrift ohne das Attribut, zeichnet nichts. Seit postext 1.8.

| Eigenschaft | Typ | Standardwert | Beschreibung |
| --- | --- | --- | --- |
| `id` | `string` | — | Stabiler Bezeichner; andere Elemente können sich daran als `#id` verankern. |
| `resourceId` | `string` | — | ID einer Bitmap- oder SVG-`Resource` des Dokuments. Sie darf Platzhalter enthalten, darunter `{attr.<key>}`, die pro Überschrift, Teil oder Seite ausgefüllt werden. |
| `decorative` | `boolean` | `false` | Das Bild ist reine Dekoration (ein Ornament, ein Band): Es gibt keinen Alternativtext an die Ausgabe weiter, auch wenn seine Ressource einen hat (siehe unten). |
| `placement` | `ElementPlacement` | — | Anker, Versatz und Größe (siehe [Platzierung von Elementen](https://postext.dev/de/docs/configuration-headers-footers.md#platzierung-von-elementen)). Eine Seite mit `'fill'` reicht bis zur Kante des Containers. |
| `parity`, `pages` | wie oben | `'all'` | Auf welchen Seiten das Bild erscheint. |
| `reserve` | `boolean` | `true` | Nur Überschriftengestaltungen: ob das Bild zur Höhe zählt, die die Überschrift im Textfluss reserviert (siehe [Reservierte Höhe](https://postext.dev/de/docs/configuration-headings.md#reservierte-höhe)). |

Das PDF-Backend bettet die Ressource wie eine Abbildung ein (ein SVG mit einer Druckvorlage verwendet diese); der HTML-Betrachter löst sie über `resourceImageUrl` auf.

Ein Bild, das eine Gestaltung zeichnet, ist Inhalt, wenn seine Ressource es beschreibt: Der `altText` der Ressource, sonst ihre Legende als reiner Text (ein Chip gelesen über seine Beschriftung, ein `:ref` über seinen `text`, wenn er einen hat), kommt in den VDT (`VDTDesignImageBlock.altText`), wird zum `alt` seines `<img>` im HTML und zu einer `Figure` mit `/Alt` in einem getaggten PDF, gelesen direkt nach dem Text seiner Gestaltung (die Tafel eines Kapitels nach dessen Überschrift). Ein Bild, dessen Ressource beides nicht hat, und eines, das als `decorative` gekennzeichnet ist, ist Dekoration: `alt=""` mit `role="presentation"` und ein Artefakt im PDF. Das Bild eines Kolumnentitels oder einer Fußzeile wiederholt sich auf jeder Seite und ist daher Seitenausstattung, gleich was seine Ressource sagt: kein `altText` im VDT, `alt=""` mit `role="presentation"` im HTML, ein Artefakt der Seite im PDF.

### Platzierung von Elementen

`ElementPlacement` ist das einheitliche Positionierungsmodell, das jeder Elementtyp (Text, Linie, Kasten) in jedem Gestaltungsplatz verwendet – Kopfzeile, Fußzeile oder der erweiterte Gestaltungsplatz einer Überschriftenebene. Drei Zustandsangaben beschreiben eine Platzierung:

```ts
interface ElementPlacement {
  /** What this element anchors to and which edge of that target. */
  anchor: {
    to: 'container' | 'page' | 'bleed' | 'outer' | `#${string}`; // container = the slot; page = trim box; bleed = trim box + bleed; outer = the outer margin (header, footer); #id = another element
    edge: AnchorEdge;
  };
  /** Distance from the anchor point. */
  offset?: { x?: Dimension; y?: Dimension };
  /** Optional fixed width / height. Width also accepts 'fill' (span the slot).
   *  `maxWidth` caps an 'auto' width (text): the element still shrink-wraps its
   *  content, so elements anchored to it stay attached, but a long text wraps or
   *  ellipsizes there — a running head can reserve room for the label hanging
   *  off it instead of squeezing that label out. */
  size?: { width?: Dimension | 'fill' | 'auto'; height?: Dimension | 'fill' | 'auto'; maxWidth?: Dimension };
}
```

`AnchorEdge` akzeptiert:

- **Containerkanten** (wenn `anchor.to` `'container'`, `'page'` oder `'bleed'` ist): `top`, `top-left`, `top-right`, `bottom`, `bottom-left`, `bottom-right`, `left`, `right`.
- **Kanten relativ zu einem Element** (wenn `anchor.to === '#someId'`): `right-of`, `left-of`, `below`, `above`, `align-top`, `align-bottom`, `align-left`, `align-right`.

Jede elementrelative Kante setzt eine Ecke des Elements auf eine Ecke des Elements, an dem es verankert ist, und `offset` verschiebt es von dort:

- `right-of`: seine obere linke Ecke auf die obere rechte Ecke des Ziels (daneben, Oberkanten auf gleicher Höhe); `left-of`: seine obere rechte Ecke auf die obere linke Ecke des Ziels;
- `below`: seine obere linke Ecke auf die untere linke Ecke des Ziels (darunter, linke Kanten bündig); `above`: seine untere linke Ecke auf die obere linke Ecke des Ziels;
- `align-top` und `align-left`: seine obere linke Ecke auf die obere linke Ecke des Ziels. Beide Namen ergeben dieselbe Platzierung: Sowohl die Ober- als auch die linken Kanten fluchten;
- `align-bottom`: seine untere linke Ecke auf die untere linke Ecke des Ziels;
- `align-right`: seine obere rechte Ecke auf die obere rechte Ecke des Ziels.

Eine elementrelative Kante zusammen mit `'container'`, `'page'` oder `'bleed'` und eine Containerkante zusammen mit `'#id'` werden als obere linke Ecke gelesen.

`anchor.to: 'page'` verankert das Element an der **Trim-Box** (der physischen Seite nach dem Beschnitt) und `'bleed'` an der Trim-Box, die auf jeder Seite um `cutLines.bleed` vergrößert ist (identisch mit der Trim-Box, solange Schnittmarken ausgeschaltet sind). Beide Rahmen werden außerdem zum Bezug für `size: 'fill'` und für die automatische Breitenbegrenzung, sodass ein farbiges Band unabhängig von den Seitenrändern von Kante zu Kante laufen kann:

```json
{ "kind": "box", "id": "band", "placement": { "anchor": { "to": "bleed", "edge": "top-left" }, "size": { "width": "fill", "height": { "value": 6, "unit": "cm" } } }, "style": { "backgroundColor": { "hex": "#1d3557", "model": "hex" } } }
```

Bei eingeschalteten Schnittmarken wird alles, was ein Element über die Anschnittbox hinaus zeichnet, abgeschnitten (siehe [Schnittmarken](https://postext.dev/de/docs/configuration-page-layout.md#schnittmarken)).

`anchor.to: 'outer'` (Plätze von Kopf- und Fußzeile) verankert das Element am **Außensteg** der Seite: von der Kante des Satzspiegels bis zur Schnittkante auf der vom Bund abgewandten Seite und vom Kopf des Satzspiegels bis zu seinem Fuß. Er liegt in einem links gebundenen Buch rechts auf einem Recto und links auf einem Verso, in einem rechts gebundenen umgekehrt (`page.binding`), sodass ein Element beiden Seiten einer Doppelseite dient: ein Kolumnentitel am Vorderschnitt entlang (siehe [Vertikale Textelemente](https://postext.dev/de/docs/configuration-headers-footers.md#vertikale-textelemente)). In jedem anderen Platz gilt es als `'container'`. Der `offset` eines Textelements kann in `em` angegeben werden, Geviert seiner eigenen `fontSize`: vier Zeichen unter dem Kopf des Satzspiegels sind `{ "y": { "value": 4, "unit": "em" } }`.

Im erweiterten Gestaltungsplatz einer Überschrift vergrößern Elemente, die an Seite oder Anschnitt verankert sind, die für die Überschrift reservierte Höhe nicht, es sei denn, sie reichen unter die Oberkante der Überschrift (ein Band über den Kopf der Seite liegt hinter dem Auftakt; ein Band, das unter die Überschrift reicht, schiebt den Fließtext nach unten). Verwenden Sie `advancedDesign.minHeight`, um unabhängig davon eine feste Auftakthöhe zu reservieren, und `reserve: false` bei einem Element, das den Text überhaupt nicht verschieben soll. Die vollständigen Regeln stehen unter [Reservierte Höhe](https://postext.dev/de/docs/configuration-headings.md#reservierte-höhe).

Jedes Element hat eine stabile `id` (von der Sandbox automatisch vergeben; Sie können sie auch von Hand setzen). Elemente, die an anderen Elementen verankert sind, bilden einen kleinen Abhängigkeitsgraphen, den die Engine vor dem Messen auflöst, sodass ein Element sich ohne manuelle Koordinaten an ein anderes anhängen kann.

Die alte Form aus `align` + `marginFromBody` + `marginFromEdge` wird bei der Eingabe geparst und beim Auflösen der Konfiguration in eine Platzierung umgeschrieben, sodass bestehende Konfigurationen unverändert weiter funktionieren.