# News und Publikationen

Schreibe chronologische Beiträge in Markdown oder MDX mit gemeinsamen Autoren, responsiven Bildern und vollständigen Feeds.

Source: https://ardo-docs.dev/v6/de/guide/publications

Aktiviere eine Publikation in `ardo.config.ts`. Bewahre die maßgeblichen Beiträge in einem lokalen Verzeichnis auf; Ardo generiert einen chronologischen Index und eine statische Seite pro veröffentlichtem Beitrag.

```ts
import { defineArdoConfig } from "ardo/config"

export default defineArdoConfig({
  title: "Example project",
  siteUrl: "https://example.com",
  publication: {
    from: "posts",
    to: "news", // Default: news
    name: "News",
    description: "Updates from the project.",
    authors: {
      alex: {
        name: "Alex Morgan",
        title: "Software engineer",
        description: "Working on the project and writing about its design.",
        avatar: "app/assets/alex.jpg", // Local paths are relative to the project root.
        url: "https://example.com/team/alex",
        links: [{ name: "Personal site", url: "https://alex.example.com" }],
        did: "did:plc:example", // Optional; no AT account is needed.
      },
    },
  },
})
```

Die `url` eines Autors ist eine absolute `http:`- oder `https:`-Profil-URL. Ardo nutzt sie für den Autorenlink, das `<uri>`-Element im Atom-Feed und die `url` der Person in den strukturierten Daten des Beitrags. Ein Wert, der keine absolute `http:`- oder `https:`-URL ist, erzeugt eine Build-Warnung und bleibt aus den strukturierten Daten heraus; Autorenlink und Atom-Feed werden wie bisher ausgegeben.

`siteUrl` ist erforderlich, da Feeds absolute Artikel- und Bild-URLs benötigen. Das generierte Verzeichnis `app/routes/news/` wird von Ardo verwaltet. Wähle ein ungenutztes `to`-Verzeichnis; Ardo ersetzt keine handgeschriebenen Routen. Dateien und Verzeichnisse im Quellverzeichnis, die mit `_` oder `.` beginnen, werden nicht als Beiträge erfasst. Hilfsdateien können daher neben Beiträgen liegen.

## Einen Beitrag schreiben {#author-a-post}

Erstelle `posts/a-readable-update.mdx`:

```mdx
---
id: 9c31001a-52ee-4e54-9197-2ff227388cce
title: A readable update
description: What changed, and why it matters.
publishedAt: 2026-10-20T09:00:00Z
authors: [alex]
tags: [Engineering]
coverImage:
  src: ./landscape.jpg
  alt: A person standing beside a mountain trail.
  caption: A quiet moment along the trail.
---

The article starts here. Use ordinary Markdown, or MDX components when the story needs them.

## A useful detail

![A closer view of the trail](./detail.jpg)
```

Die URL lautet `/news/a-readable-update/`. Ein verschachteltes `posts/design/typography.mdx` wird zu `/news/design/typography/`. Setze `path: /news/a-permanent-address`, um eine Adresse unabhängig vom Quelldateinamen zu wählen. Eigene Pfade müssen innerhalb des Publikations-Unterbaums bleiben. Die websiteweite Einstellung [`trailingSlash`](<https://ardo-docs.dev/v6/de/guide/configuration/#trailingslash>) entscheidet, ob diese URLs mit einem Schrägstrich enden. Sie schreibt `url` der Publikation, ihrer Beiträge und Tag-Archive, deren Canonical-Links, die Sitemap und die Feed-Links einheitlich. Ohne die Einstellung behalten Publikations-URLs den Schrägstrich, während Sitemap-Einträge und die Standard-Canonical-Links von Beiträgen und Tag-Archiven ihn nicht haben, wie in früheren Versionen.

Vergib `id` einmal und behalte den Wert bei Änderungen am Dateinamen, Titel oder der URL bei. Eine UUID erzeugst du mit:

```sh
node -e "console.log(require('node:crypto').randomUUID())"
```

`publishedAt` bestimmt die chronologische Reihenfolge. Setze `updatedAt` für eine spätere Überarbeitung; Änderungen verschieben einen Beitrag nicht nach oben. Beide Zeitstempel benötigen eine Zeitzone. `authors` verweist auf ein oder mehrere gemeinsame Profile aus der Konfiguration. Autoren können Namen, Porträts, Berufsbezeichnungen, Biografien, Links und optionale AT-DIDs haben.

Setze `draft: true`, um einen Beitrag aus generierten Seiten, JavaScript, Feeds, Suche und Sitemaps auszuschließen. Auch ein zukünftiges `publishedAt` schließt den Beitrag aus. Ein Build zu diesem Zeitpunkt oder später nimmt ihn auf; eine bereits bereitgestellte statische Website veröffentlicht sich nicht selbst, wenn das Datum erreicht ist. Wenn [`buildTime`](<https://ardo-docs.dev/v6/de/guide/configuration/#buildtime>) gesetzt ist, entscheidet Ardo anhand dieses fixierten Zeitpunkts statt der aktuellen Zeit, welche geplanten Beiträge sichtbar sind. Entwürfe bleiben in jedem Fall verborgen.

## Lokale Bilder und Ausschnitte {#local-images-and-framing}

Ardo verarbeitet lokale Titelbilder und Markdown-Bilder beim Build. Lege Bilder neben den Beitrag und verwende relative Pfade oder verweise mit einem wurzelrelativen Pfad auf eine Datei in `public/`. Relative MDX-Importe werden weiterhin anhand der ursprünglichen Quelldatei aufgelöst.

Ohne Ausschnitt-Metadaten behalten die erzeugten Auflösungen die ursprüngliche Bildkomposition bei. Mit einem Kernbereich oder Wunschausschnitt erzeugt Ardo zwei Ausschnittfamilien: **16:10** und **4:3**. Jede Familie enthält mehrere Auflösungen; der Browser wählt über `srcset` und `sizes` eine aus. Ardo erhält die Quelldateien und skaliert nicht hoch.

```yaml
coverImage:
  src: ./portrait.jpg
  alt: Alex beside a window.
  core: { x: 0.65, y: 0.45, size: 0.3 }
  margin: 0.15
  frame: { x: 0.3, y: 0.1, width: 0.6, height: 0.8 }
```

- **`core` (A)** definiert ein Quadrat, das sichtbar bleiben muss. `x` und `y` sind sein Mittelpunkt, jeweils auf 0 bis 1 normiert. `size` ist ein Anteil der kürzeren Seite des ausgerichteten Quellbilds, sodass der Bereich sowohl bei Quer- als auch bei Hochformatbildern physisch quadratisch bleibt.
- **`frame` (B)** beschreibt die gewünschte Bildkomposition. Die normierten Werte `x`/`y` geben die obere linke Ecke an; `width`/`height` sind Anteile der jeweiligen Quellabmessungen.
- Mit A allein schneidet Ardo eng um diesen Bereich mit dem gewünschten Rand zu. Mit B verwendet Ardo B als bevorzugte Bildkomposition und erhält A vollständig, sofern angegeben. B lässt sich auch allein verwenden.
- **`margin`** beträgt standardmäßig `0.15` pro Seite, bezogen auf den resultierenden Ausschnitt. Ardo verschiebt den Ausschnitt und verringert den Rand, wenn das Quellbild nicht genug Umgebung bietet.

Quellgrenzen, das Zielseitenverhältnis und der vollständige Erhalt von A sind zwingende Vorgaben. Kann ein benötigter Ausschnitt den gesamten Kernbereich nicht enthalten, schlägt der Build mit Bildpfad und Zielformat fehl. Ein zu kleiner Wunschrand allein führt nicht zu einem Build-Fehler. Die EXIF-Ausrichtung wird vor der Interpretation der Koordinaten angewendet.

Für eingebettete Markdown-Bilder hinterlegst du Ausschnitt-Metadaten im Frontmatter des Beitrags. Verwende die exakte Bildreferenz als Schlüssel:

```yaml
images:
  ./detail.jpg:
    core: { x: 0.5, y: 0.5, size: 0.25 }
    preset: article
```

SVG und animierte Bilder werden ohne Skalierung durchgereicht und unterstützen keine Ausschnitt-Metadaten. Extern gehostete HTTP-Bilder bleiben extern; Ardo lädt sie weder herunter noch optimiert es sie.

Gemeinsame Einstellungen und optionale Auslieferung über URLs beschreibt [Bilder](<https://ardo-docs.dev/v6/de/guide/images/>). Die folgenden Standardwerte gelten ohne konfigurierten Provider.

## Ausgabeformate {#output-formats}

Ardo erzeugt **AVIF** für jede Auflösung eines lokalen, unbewegten Beitragsbilds und erhält dabei die Transparenz. Pro Bild entsteht außerdem ein **JPEG** mit höchstens 1280 Pixeln Breite, ohne Hochskalierung. Das JPEG verwendet den Fallback-Zuschnitt des Bild-Presets oder bei einem Bild ohne Zuschnitt die ursprüngliche Komposition. Nur im JPEG werden transparente Bereiche auf Weiß gelegt.

Das `picture`-Element wählt AVIF-Quellen anhand von Medienbedingungen; jedes `srcset` enthält die Auflösungen. Sein `img`-Element verwendet das einzelne JPEG als Fallback, ohne JPEG-`srcset`. Feeds nutzen dasselbe JPEG, Social-Metadaten ebenfalls, sofern der Beitrag kein [`ogImage`](<https://ardo-docs.dev/v6/de/guide/publications#share-images>) setzt. Autorenporträts werden direkt als AVIF ausgeliefert.

Sharp/libvips übernimmt Zuschnitt, Skalierung, AVIF und JPEG beim Build oder bei der Vorbereitung im Entwicklungsmodus. Ein zusätzliches Codec-Paket oder eine WebAssembly-Laufzeit ist nicht erforderlich. SVGs, animierte und externe Bilder werden weiterhin unverändert durchgereicht.

## Bilder zum Teilen {#share-images}

Open-Graph- und Twitter-Tags nutzen das JPEG des Titelbilds. Um stattdessen ein vorbereitetes Bild zu teilen, etwa eine Karte mit 1200 × 630 Pixeln und dem Titel, setze `ogImage`:

```yaml
coverImage:
  src: ./landscape.jpg
  alt: A person standing beside a mountain trail.
ogImage: ./social.png
```

Ein relatives `ogImage` verweist auf ein JPEG oder PNG neben dem Beitrag. Ardo veröffentlicht es in Originalgröße und -format, ohne EXIF- oder andere Metadaten. URLs und wurzelrelative Pfade in `public/` bleiben unverändert. Hat ein Beitrag keines der beiden Bilder, nutzt er das [`metadata.image`](<https://ardo-docs.dev/v6/de/guide/configuration/#metadata>) der Website.

## Eine Darstellungsvorlage auswählen {#select-a-presentation-preset}

Ausschnittangaben beschreiben das Quellbild. Eine Vorlage beschreibt den Einsatz eines Bilds: die Bildkomposition, geordnete Viewport-Medienbedingungen und die erwartete Anzeigebreite.

Ardo bietet austauschbare Vorlagen für `article` und `card`. Die Standardvorlage für Artikel verwendet ab einer Viewport-Breite von `52rem` das Format 16:10 und ansonsten 4:3; Karten verwenden 4:3. Diese Regeln gelten für Bilder mit Ausschnittangaben. Ohne Ausschnittangaben bleibt die ursprüngliche Bildkomposition erhalten.

```ts
publication: {
  // from, authors, ...
  images: {
    widths: [384, 640, 960, 1280, 1920],
    presets: {
      article: {
        fallback: "4:3",
        sizes: "(min-width: 64rem) 48rem, 100vw",
        sources: [{ media: "(min-width: 64rem)", composition: "16:10" }],
      },
      card: { fallback: "4:3", sizes: "(min-width: 48rem) 20rem, 100vw" },
    },
  },
}
```

`picture` wählt die erste passende Quelle aus. Das `srcset` jeder Quelle enthält Auflösungen einer einzigen Bildkomposition. Medienbedingungen beziehen sich auf den Viewport und die Umgebung, nicht auf die Breite der umgebenden Karte. Wähle eine zum Einsatz passende Vorlage, statt für alle Bilder dieselben Breakpoints anzunehmen.

## Vollständige Feeds und MDX {#full-content-feeds-and-mdx}

Ardo generiert `/news/atom.xml` und `/news/rss.xml` mit dem vollständigen portablen Artikel, Autoren, Tags und absoluten Bild-URLs. Der Index verlinkt beide Feeds und enthält Metadaten zur Feed-Erkennung. Stabile Beitrags-IDs bleiben auch bei einer URL-Änderung die Identität im Feed. Beide Feeds nennen die Sprache der Publikation: ihre Sprach-ID oder das `lang` der Website. Setze `lang` auf einer einsprachigen Website, denn sonst gilt `en`.

Eine Eintrags-ID enthält standardmäßig nur die Beitrags-ID. Wenn mehrere Websites oder Publikationen Beitrags-IDs teilen, etwa bei einem übersetzten Beitrag auf zwei einsprachigen Websites, setze `feeds: { entryIds: "publication" }`. Die ID enthält dann Host und Pfad der Publikation, sodass Feedreader beide Einträge behalten. Feedreader behandeln Einträge mit neuen IDs als neue Beiträge. Wähle die Option daher vor der ersten Veröffentlichung oder nimm einmalig wiederholte Einträge in Kauf.

Gewöhnliches Markdown wird direkt exportiert. Enthält MDX Komponenten, Ausdrücke, Modulanweisungen oder HTML, die bei der statischen Projektion entfallen würden, gib den vollständigen portablen Artikel als Markdown in `feedContent` an. Der Build meldet fehlende Ersatzinhalte.

```mdx
---
id: c4977b7e-b283-4da3-83f0-071f978a1e25
title: An interactive example
publishedAt: 2026-10-20T09:00:00Z
authors: [alex]
feedContent: |
  The website contains an interactive counter. It starts at zero;
  pressing the button adds one. This text explains the complete example.
---

import { Counter } from "./_Counter"

The website contains an interactive counter.

<Counter />
```

Die standardmäßige MDX-Komponente `Image` rendert vorbereitete Bildmetadaten, zum Beispiel `<Image src="./detail.jpg" alt="The trail" />`. JSX-Komponenten benötigen außerdem eine portable Darstellung in `feedContent`. Wörtliche, kleingeschriebene `<img>`-Elemente folgen dem normalen JSX-Verhalten; verwende Markdown-Bilder oder `Image` für die automatische Bildverarbeitung von Publikationen.

## Dokumentationsversionen und Sprachen {#documentation-versions-and-locales}

Publikations-URLs bleiben unabhängig von Dokumentationsversionen. Wähle bei aktivierter Versionierung vollständige Dokumentationsverzeichnisse aus und halte die Publikation außerhalb dieser Verzeichnisse:

```ts
versioning: {
  current: "v2",
  versions: [{ id: "v2", path: "/v2/" }, { id: "v1", path: "/v1/" }],
  directories: ["guide", "api-reference"],
}
```

Damit erhält die Website-Startseite `/`, Beiträge `/news/...` und Guides `/v2/guide/...`. Alle URLs berücksichtigen auch eine Deployment-`base`. Ohne `directories` behalten bestehende Projekte die Versionierung der gesamten Website bei. Das Migrationsverhalten beschreibt die [Konfiguration](<https://ardo-docs.dev/v6/de/guide/configuration/#versioning>).

Bei aktivierter strikter Lokalisierung liegen Beiträge unter `posts/<locale>/`. Ardo erzeugt `/<locale>/news/` und die zugehörigen Feeds für jede konfigurierte Sprache. Die vorhandene Validierung vollständiger Routenbäume gilt weiterhin; diese Funktion führt keine Übersetzungs-Fallbacks ein. Übergib übersetzte UI-Texte über `labels.publication` von `ArdoRoot`.

## Tag-Archive {#tag-archives}

Setze `tags: true`, um für jedes Tag eine Seite unter `/news/tags/<key>` zu generieren. Die Sitemap führt diese Seiten auf. Tag-Schlüssel müssen kleingeschriebene Slugs mit Bindestrichen sein, etwa `release-notes`. Der Build schlägt fehl, wenn ein Schlüssel nicht passt, ein Beitrag einen Schlüssel doppelt nennt oder ein Beitragspfad unter `/news/tags` liegt. Feeds behalten den Schlüssel als Kategorie. Mit Archiven verlinken die Tags eines Beitrags auf ihr Archiv. Ohne Archive sind Tags beliebiger Text. Mit `i18n` braucht jede Sprache dieselben Tag-Schlüssel, weil jede lokalisierte Seite in jeder Sprache existieren muss.

### Tag-Bezeichnungen {#tag-labels}

Ein Tag-Schlüssel ist die Identität des Tags in URLs, der Sitemap und Feeds und bleibt deshalb in jeder Sprache gleich. Um stattdessen eine lesbare oder übersetzte Bezeichnung zu zeigen, setze `tagLabel` auf ein Modul, dessen Default-Export einen Schlüssel auf seine Bezeichnung abbildet:

```ts
publication: {
  // from, authors, ...
  tags: true,
  tagLabel: "app/blog/tag-label.ts",
}
```

Ardo ruft die Funktion beim Rendern einer Seite auf, innerhalb des [Server-Render-Kontexts](<https://ardo-docs.dev/v6/de/guide/internationalization/#server-render-context>), sodass sie die Übersetzungen der Website nutzen kann. Gib mit Palamedes jedem Schlüssel eine Nachricht, damit `i18n:extract` sie findet:

```ts
// app/blog/tag-label.ts
import { t } from "@palamedes/core/macro"
import type { PublicationTagLabel } from "ardo/config"

const tagLabel: PublicationTagLabel = (key) => {
  switch (key) {
    case "design":
      return t`Design`
    case "release-notes":
      return t`Release notes`
    default:
      return key
  }
}

export default tagLabel
```

Die Bezeichnung erscheint in der Überschrift und im Standardtitel des Tag-Archivs sowie in der Tag-Liste eines Beitrags. Eigene Komponenten erhalten sie als `label` oder lesen sie mit `useArdoPublicationTags()` aus `ardo/ui`. Nur die generierten Publikationsseiten importieren das Modul. Feeds behalten den Schlüssel, weil Ardo sie ohne aktive Sprache baut. Ohne `tagLabel` zeigen Seiten den Schlüssel.

## Eigene Darstellung und Metadaten {#own-presentation-and-metadata}

Eine Website mit eigenem Design kann die generierten Seiten mit eigenen Routenmodulen rendern. Pfade sind relativ zum Projektstamm:

```ts
publication: {
  // from, authors, ...
  tags: true,
  components: {
    index: "app/blog/BlogIndex.tsx",
    post: "app/blog/BlogPost.tsx",
    tag: "app/blog/BlogTag.tsx",
  },
}
```

Jedes Modul exportiert standardmäßig eine React-Komponente. `index` erhält `{ publication }`, `post` erhält `{ post, children }` und umschließt den gerenderten Artikel anstelle von `ArdoPost`, und `tag` erhält `{ publication, tag, label, posts }`. Ein Modul kann außerdem `meta` exportieren. Ardo ruft es beim Rendern der Route auf, wie den `meta`-Export jeder Route, mit den Daten der Route und `defaults`, den Deskriptoren, die Ardo ohne den Export rendern würde. Die zurückgegebene Liste ersetzt die Standardwerte einschließlich Canonical-Link, Open-Graph-, Twitter- und JSON-LD-Tags; verteile `defaults` in die Liste, um sie zu behalten. Ohne `meta`-Export gelten Ardos Metadaten.

Die `defaults` eines Beitrags enthalten einen `BlogPosting`-JSON-LD-Eintrag, `{ "script:ld+json": … }`, mit Überschrift, Beschreibung, kanonischer URL, Sprache, Datumsangaben, Autoren, dem eigenen Bild des Beitrags und der Website. Verteilst du `defaults` in die Liste, bleibt er erhalten. Ein Filter, der Deskriptoren entfernt, muss Einträge behalten, für die `"script:ld+json" in entry` gilt, wie im folgenden Beispiel. `seo.jsonLd: false` schaltet den Eintrag ab. Sein `mainEntityOfPage` verweist auf die kanonische URL von Ardo; ersetzt ein Modul den Canonical-Link, sollte es daher auch `BlogPosting` ersetzen oder weglassen.

```tsx
// app/blog/BlogPost.tsx
import type { PublicationPostMetaArgs, PublicationPostProps } from "ardo/config"
import type { ArdoMetaDescriptor } from "ardo/runtime"

export default function BlogPost({ post, children }: PublicationPostProps) {
  return (
    <article>
      <h1>{post.title}</h1>
      {children}
    </article>
  )
}

// Link descriptors can have a `title` attribute; keep them.
// The JSON-LD entry has no `title`, so the last check keeps it already;
// `"script:ld+json" in entry` keeps it even if that title check changes.
const keep = (entry: ArdoMetaDescriptor) =>
  "tagName" in entry || "script:ld+json" in entry || !("title" in entry)

export function meta({ post, publication, defaults }: PublicationPostMetaArgs) {
  return [{ title: `${post.title} – ${publication.name}` }, ...defaults.filter(keep)]
}
```

```tsx
// app/blog/BlogTag.tsx
import { t } from "@palamedes/core/macro"
import type { PublicationTagMetaArgs, PublicationTagProps } from "ardo/config"
import type { ArdoMetaDescriptor } from "ardo/runtime"

export default function BlogTag({ label, posts }: PublicationTagProps) {
  return (
    <main>
      <h1>{label}</h1>
      <ul>
        {posts.map((post) => (
          <li key={post.id}>
            <a href={post.url}>{post.title}</a>
          </li>
        ))}
      </ul>
    </main>
  )
}

const notTitle = (descriptor: ArdoMetaDescriptor) =>
  "tagName" in descriptor || !("title" in descriptor)

export function meta({ label, defaults }: PublicationTagMetaArgs) {
  return [{ title: t`Posts about ${label}` }, ...defaults.filter(notTitle)]
}
```

Die Funktion `meta` läuft beim Rendern und kann deshalb wie `label` übersetzen. Die Modultypen `PublicationIndexModule`, `PublicationPostModule` und `PublicationTagModule` aus `ardo/config` beschreiben die Exporte. Passt ein Export nicht zu seinem Typ, schlägt die Typprüfung der Website in der generierten Route fehl. Alle Seiten und Module teilen die Publikationsdaten, deshalb friert Ardo sie ein, und ihre Listen sind schreibgeschützt: Sortiere eine Kopie, etwa `[...publication.posts].sort(…)`. `defaults` ist bei jedem Aufruf eine neue Liste. Die Standardwerte von Index, Beiträgen und Tag-Archiven enden alle mit den Atom- und RSS-Discovery-Links der Publikation. Mit einem Beitragsmodul schlägt der Build fehl, wenn ein Beitrag ein eigenes `meta` exportiert, weil das die Canonical-, Open-Graph- und Feed-Links des Beitrags verwerfen würde; variiere die Metadaten stattdessen im `meta` des Moduls. Ohne Beitragsmodul ersetzt ein eigenes `meta` eines Beitrags Ardos Metadaten, wie auf jeder Seite.

### Eigene Beitragsfelder {#custom-post-fields}

Frontmatter-Felder, die Ardo nicht liest, erreichen den Beitrag als `post.data`, zum Beispiel `nextStep: /contact`. Das Beitragsmodul erhält sie in seinen Props und in `meta`; prüfe den Typ jedes Werts vor der Verwendung. Sie bleiben auf der eigenen Seite des Beitrags: Die Beiträge von Listen und von `virtual:ardo/publication` haben ein leeres `data`, damit die Felder eines Beitrags nicht mit jeder anderen Seite ausgeliefert werden. Der Root liest dieselben Felder mit `useArdoPage().frontmatter`.

Nur die generierten Publikationsrouten importieren diese Module. Der Beitragsrahmen gehört zu Beitragsseiten und nicht zur Dokumentation oder zu anderen Seiten. Mit `i18n` ergänzt Ardo weiterhin die Sprachalternativen jeder Seite und einen Canonical-Link, wenn die zurückgegebenen Metadaten keinen enthalten.

### Seitendaten für den Root {#page-data-for-the-root}

Der Index und die Tag-Archive haben kein eigenes Frontmatter. Ihre Module können `frontmatter` exportieren, um dem Root Seitendaten zu geben, etwa einen Link auf dieselbe Seite in einer anderen Sprache. Ardo ruft die Funktion beim Rendern der Seite auf, wie `meta`, mit `{ publication }` für den Index und `{ publication, tag, label, posts }` für jedes Tag-Archiv. Der Root liest das Ergebnis mit `useArdoPage().frontmatter`, auf dem Server und während der Hydration, so wie er die Felder eines Beitrags liest. Ohne den Export haben diese Seiten kein Frontmatter.

```tsx
// app/blog/BlogTag.tsx
import type { PublicationTagFrontmatterArgs } from "ardo/config"

export function frontmatter({ tag }: PublicationTagFrontmatterArgs) {
  return { counterpart: `https://de.example.com/blog/tags/${tag.key}/` }
}
```

```tsx
// app/root.tsx
const counterpart = useArdoPage().frontmatter?.counterpart
```

Ardo schreibt keine Seitendaten ins Bundle. Die Route jedes Archivs enthält ihren eigenen Tag und ihre Beiträge und übergibt sie der Funktion. Was das Modul importiert, etwa eine Liste übersetzter Tags, wird mit dem Modul an jedes Archiv ausgeliefert.

## Eigene Layouts und AT-Metadaten {#custom-layouts-and-at-metadata}

Importiere die Publikationsdaten aus `virtual:ardo/publication`, um sie an anderer Stelle zu verwenden. Der Standardexport ist die Publikation der Standardsprache; `publications` ordnet Sprach-IDs (oder `default` ohne Lokalisierung) ihren Daten zu. `ArdoPostList`, `ArdoPost`, `ArdoImage` und `ardoImagePresets` sind über `ardo/ui` verfügbar. Der Quelltext der Beiträge bleibt MDX; der öffentliche Datenexport enthält Metadaten und vorbereitete Bildbeschreibungen. Mit Tag-Archiven listet `publication.tags` Schlüssel, Pfad und URL jedes Tags; übergib eines davon als `tag` an `ArdoPostList`, um nur dessen Beiträge aufzulisten.

Verwende `ArdoPostNavigation` aus `ardo/ui` für eine kompakte Artikelnavigation. Übergib die Publikation der aktuellen Sprache über die Prop `mobileMenuContent` von `ArdoHeader`, um das mobile Menü einer News-Seite zu füllen. Die Komponente zeigt standardmäßig die zehn neuesten veröffentlichten Artikel, hebt die aktuelle Seite hervor und verlinkt über „Alle Artikel“ auf den vollständigen Publikationsindex. Mit `limit` änderst du die Länge der Liste. Übersetze `labels.publication.recentPosts` und `labels.publication.allPosts` zusammen mit den übrigen Publikationsbezeichnungen.

Metadatennamen folgen, soweit anwendbar, [dem Dokument-Lexikon von Standard.site](https://standard.site/docs/lexicons/document): `title`, `description`, `publishedAt`, `updatedAt`, `tags`, `coverImage` und `path`. Lokale Autorenschlüssel, Bildquellpfade, Ausschnitt-Metadaten, `id`, `draft` und `feedContent` sind Ardo-Felder für die Inhaltserstellung. Eine spätere AT-Publikationsfunktion wird sie beim Export übersetzen. Normale Builds erzeugen die statische Website und Feeds; sie veröffentlichen nichts auf einem AT-Konto.
