@rmdes/indiekit-endpoint-activitypub 3.6.5 → 3.6.7

package/lib/mastodon/entities/account.js

@@ -7,6 +7,7 @@
  */
 import { accountId } from "../helpers/id-mapping.js";
 import { sanitizeHtml, stripHtml } from "./sanitize.js";
+import { getCachedAccountStats } from "../helpers/account-cache.js";
 
 /**
  * Serialize an actor as a Mastodon Account entity.
@@ -111,6 +112,20 @@ export function serializeAccount(actor, { baseUrl, isLocal = false, handle = ""
     statuses_count: actor.statusesCount || 0,
     followers_count: actor.followersCount || 0,
     following_count: actor.followingCount || 0,
+    // Enrich from cache if counts are 0 (embedded accounts in statuses lack counts)
+    ...((!actor.statusesCount && !actor.followersCount && !isLocal)
+      ? (() => {
+          const cached = getCachedAccountStats(url);
+          return cached
+            ? {
+                statuses_count: cached.statusesCount || 0,
+                followers_count: cached.followersCount || 0,
+                following_count: cached.followingCount || 0,
+                created_at: cached.createdAt || actor.createdAt || new Date().toISOString(),
+              }
+            : {};
+        })()
+      : {}),
     moved: actor.movedTo || null,
     suspended: false,
     limited: false,

package/lib/mastodon/helpers/account-cache.js

@@ -0,0 +1,51 @@
+/**
+ * In-memory cache for remote account stats (followers, following, statuses).
+ *
+ * Populated by resolveRemoteAccount() when a profile is fetched.
+ * Read by serializeAccount() to enrich embedded account objects in statuses.
+ *
+ * LRU-style with TTL — entries expire after 1 hour.
+ */
+
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+const MAX_ENTRIES = 500;
+
+// Map<actorUrl, { followersCount, followingCount, statusesCount, createdAt, cachedAt }>
+const cache = new Map();
+
+/**
+ * Store account stats in cache.
+ * @param {string} actorUrl - The actor's URL (cache key)
+ * @param {object} stats - { followersCount, followingCount, statusesCount, createdAt }
+ */
+export function cacheAccountStats(actorUrl, stats) {
+  if (!actorUrl) return;
+
+  // Evict oldest if at capacity
+  if (cache.size >= MAX_ENTRIES) {
+    const oldest = cache.keys().next().value;
+    cache.delete(oldest);
+  }
+
+  cache.set(actorUrl, { ...stats, cachedAt: Date.now() });
+}
+
+/**
+ * Get cached account stats.
+ * @param {string} actorUrl - The actor's URL
+ * @returns {object|null} Stats or null if not cached/expired
+ */
+export function getCachedAccountStats(actorUrl) {
+  if (!actorUrl) return null;
+
+  const entry = cache.get(actorUrl);
+  if (!entry) return null;
+
+  // Check TTL
+  if (Date.now() - entry.cachedAt > CACHE_TTL_MS) {
+    cache.delete(actorUrl);
+    return null;
+  }
+
+  return entry;
+}

package/lib/mastodon/helpers/resolve-account.js

@@ -5,6 +5,7 @@
  * Shared by accounts.js (lookup) and search.js (resolve=true).
  */
 import { serializeAccount } from "../entities/account.js";
+import { cacheAccountStats } from "./account-cache.js";
 
 /**
  * @param {string} acct - Account identifier (user@domain or URL)
@@ -115,6 +116,14 @@ export async function resolveRemoteAccount(acct, pluginOptions, baseUrl) {
     account.following_count = followingCount;
     account.statuses_count = statusesCount;
 
+    // Cache stats so embedded account objects in statuses can use them
+    cacheAccountStats(actorUrl, {
+      followersCount,
+      followingCount,
+      statusesCount,
+      createdAt: published || undefined,
+    });
+
     return account;
   } catch (error) {
     console.warn(`[Mastodon API] Remote account resolution failed for ${acct}:`, error.message);

package/lib/mastodon/routes/accounts.js

@@ -155,6 +155,65 @@ router.get("/api/v1/accounts/lookup", async (req, res, next) => {
   }
 });
 
+// ─── GET /api/v1/accounts/relationships ──────────────────────────────────────
+// MUST be before /accounts/:id to prevent Express matching "relationships" as :id
+
+router.get("/api/v1/accounts/relationships", async (req, res, next) => {
+  try {
+    let ids = req.query["id[]"] || req.query.id || [];
+    if (!Array.isArray(ids)) ids = [ids];
+
+    if (ids.length === 0) {
+      return res.json([]);
+    }
+
+    const collections = req.app.locals.mastodonCollections;
+
+    const [followers, following, blocked, muted] = await Promise.all([
+      collections.ap_followers.find({}).toArray(),
+      collections.ap_following.find({}).toArray(),
+      collections.ap_blocked.find({}).toArray(),
+      collections.ap_muted.find({}).toArray(),
+    ]);
+
+    const followerIds = new Set(followers.map((f) => remoteActorId(f.actorUrl)));
+    const followingIds = new Set(following.map((f) => remoteActorId(f.actorUrl)));
+    const blockedIds = new Set(blocked.map((b) => remoteActorId(b.url)));
+    const mutedIds = new Set(muted.filter((m) => m.url).map((m) => remoteActorId(m.url)));
+
+    const relationships = ids.map((id) => ({
+      id,
+      following: followingIds.has(id),
+      showing_reblogs: followingIds.has(id),
+      notifying: false,
+      languages: [],
+      followed_by: followerIds.has(id),
+      blocking: blockedIds.has(id),
+      blocked_by: false,
+      muting: mutedIds.has(id),
+      muting_notifications: mutedIds.has(id),
+      requested: false,
+      requested_by: false,
+      domain_blocking: false,
+      endorsed: false,
+      note: "",
+    }));
+
+    res.json(relationships);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// ─── GET /api/v1/accounts/familiar_followers ─────────────────────────────────
+// MUST be before /accounts/:id
+
+router.get("/api/v1/accounts/familiar_followers", (req, res) => {
+  let ids = req.query["id[]"] || req.query.id || [];
+  if (!Array.isArray(ids)) ids = [ids];
+  res.json(ids.map((id) => ({ id, accounts: [] })));
+});
+
 // ─── GET /api/v1/accounts/:id ────────────────────────────────────────────────
 
 router.get("/api/v1/accounts/:id", async (req, res, next) => {
@@ -183,8 +242,18 @@ router.get("/api/v1/accounts/:id", async (req, res, next) => {
     // Resolve remote actor from followers, following, or timeline
     const { actor, actorUrl } = await resolveActorData(id, collections);
     if (actor) {
+      // Try remote resolution to get real counts (followers, following, statuses)
+      const remoteAccount = await resolveRemoteAccount(
+        actorUrl,
+        pluginOptions,
+        baseUrl,
+      );
+      if (remoteAccount) {
+        return res.json(remoteAccount);
+      }
+
+      // Fallback to local data
       const account = serializeAccount(actor, { baseUrl });
-      // Count this actor's posts in our timeline
       account.statuses_count = await collections.ap_timeline.countDocuments({
         "author.url": actorUrl,
       });
@@ -354,66 +423,6 @@ router.get("/api/v1/accounts/:id/following", async (req, res, next) => {
   }
 });
 
-// ─── GET /api/v1/accounts/relationships ──────────────────────────────────────
-
-router.get("/api/v1/accounts/relationships", async (req, res, next) => {
-  try {
-    // id[] can come as single value or array
-    let ids = req.query["id[]"] || req.query.id || [];
-    if (!Array.isArray(ids)) ids = [ids];
-
-    if (ids.length === 0) {
-      return res.json([]);
-    }
-
-    const collections = req.app.locals.mastodonCollections;
-
-    // Load all followers/following for efficient lookup
-    const [followers, following, blocked, muted] = await Promise.all([
-      collections.ap_followers.find({}).toArray(),
-      collections.ap_following.find({}).toArray(),
-      collections.ap_blocked.find({}).toArray(),
-      collections.ap_muted.find({}).toArray(),
-    ]);
-
-    const followerIds = new Set(followers.map((f) => remoteActorId(f.actorUrl)));
-    const followingIds = new Set(following.map((f) => remoteActorId(f.actorUrl)));
-    const blockedIds = new Set(blocked.map((b) => remoteActorId(b.url)));
-    const mutedIds = new Set(muted.filter((m) => m.url).map((m) => remoteActorId(m.url)));
-
-    const relationships = ids.map((id) => ({
-      id,
-      following: followingIds.has(id),
-      showing_reblogs: followingIds.has(id),
-      notifying: false,
-      languages: [],
-      followed_by: followerIds.has(id),
-      blocking: blockedIds.has(id),
-      blocked_by: false,
-      muting: mutedIds.has(id),
-      muting_notifications: mutedIds.has(id),
-      requested: false,
-      requested_by: false,
-      domain_blocking: false,
-      endorsed: false,
-      note: "",
-    }));
-
-    res.json(relationships);
-  } catch (error) {
-    next(error);
-  }
-});
-
-// ─── GET /api/v1/accounts/familiar_followers ─────────────────────────────────
-
-router.get("/api/v1/accounts/familiar_followers", (req, res) => {
-  // Stub — returns empty for each requested ID
-  let ids = req.query["id[]"] || req.query.id || [];
-  if (!Array.isArray(ids)) ids = [ids];
-  res.json(ids.map((id) => ({ id, accounts: [] })));
-});
-
 // ─── POST /api/v1/accounts/:id/follow ───────────────────────────────────────
 
 router.post("/api/v1/accounts/:id/follow", async (req, res, next) => {

package/locales/de.json

@@ -0,0 +1,358 @@
+{
+  "activitypub": {
+    "title": "ActivityPub",
+    "followers": "Follower",
+    "following": "Folge ich",
+    "activities": "Aktivitätsprotokoll",
+    "featured": "Angeheftete Beiträge",
+    "featuredTags": "Vorgestellte Tags",
+    "recentActivity": "Neueste Aktivität",
+    "noActivity": "Noch keine Aktivität. Sobald dein Akteur föderiert ist, werden Interaktionen hier angezeigt.",
+    "noFollowers": "Noch keine Follower.",
+    "noFollowing": "Folgt noch niemandem.",
+    "pendingFollows": "Ausstehend",
+    "noPendingFollows": "Keine ausstehenden Folgeanfragen.",
+    "approve": "Genehmigen",
+    "reject": "Ablehnen",
+    "followApproved": "Folgeanfrage genehmigt.",
+    "followRejected": "Folgeanfrage abgelehnt.",
+    "followRequest": "möchte dir folgen",
+    "followerCount": "%d Follower",
+    "followerCount_plural": "%d Follower",
+    "followingCount": "%d folge ich",
+    "followedAt": "Gefolgt seit",
+    "source": "Quelle",
+    "sourceImport": "Mastodon-Import",
+    "sourceManual": "Manuell",
+    "sourceFederation": "Föderation",
+    "sourceRefollowPending": "Erneutes Folgen ausstehend",
+    "sourceRefollowFailed": "Erneutes Folgen fehlgeschlagen",
+    "direction": "Richtung",
+    "directionInbound": "Empfangen",
+    "directionOutbound": "Gesendet",
+    "profile": {
+      "title": "Profil",
+      "intro": "Bearbeite, wie dein Akteur anderen Nutzern im Fediverse angezeigt wird. Änderungen werden sofort wirksam.",
+      "nameLabel": "Anzeigename",
+      "nameHint": "Dein Name, wie er auf deinem Fediverse-Profil angezeigt wird",
+      "summaryLabel": "Biografie",
+      "summaryHint": "Eine kurze Beschreibung über dich. HTML ist erlaubt.",
+      "urlLabel": "Website-URL",
+      "urlHint": "Deine Webadresse, als Link auf deinem Profil angezeigt",
+      "iconLabel": "Avatar-URL",
+      "iconHint": "URL zu deinem Profilbild (quadratisch, mindestens 400x400px empfohlen)",
+      "imageLabel": "Header-Bild-URL",
+      "imageHint": "URL zu einem Bannerbild, das oben auf deinem Profil angezeigt wird",
+      "manualApprovalLabel": "Follower manuell genehmigen",
+      "manualApprovalHint": "Wenn aktiviert, müssen Folgeanfragen erst genehmigt werden, bevor sie wirksam werden",
+      "actorTypeLabel": "Akteur-Typ",
+      "actorTypeHint": "Wie dein Konto im Fediverse erscheint. Person für Einzelpersonen, Service für Bots oder automatisierte Konten, Organization für Gruppen oder Unternehmen.",
+      "linksLabel": "Profil-Links",
+      "linksHint": "Links auf deinem Fediverse-Profil. Füge deine Website, soziale Konten oder andere URLs hinzu. Seiten, die mit rel=\"me\" zurückverlinken, werden auf Mastodon als verifiziert angezeigt.",
+      "linkNameLabel": "Bezeichnung",
+      "linkValueLabel": "URL",
+      "addLink": "Link hinzufügen",
+      "removeLink": "Entfernen",
+      "authorizedFetchLabel": "Autorisiertes Abrufen erfordern (sicherer Modus)",
+      "authorizedFetchHint": "Wenn aktiviert, können nur Server mit gültigen HTTP-Signaturen deinen Akteur und Sammlungen abrufen. Dies verbessert die Privatsphäre, kann aber die Kompatibilität mit einigen Clients einschränken.",
+      "save": "Profil speichern",
+      "saved": "Profil gespeichert. Änderungen sind jetzt im Fediverse sichtbar.",
+      "public": {
+        "followPrompt": "Folge mir im Fediverse",
+        "copyHandle": "Handle kopieren",
+        "copied": "Kopiert!",
+        "pinnedPosts": "Angeheftete Beiträge",
+        "recentPosts": "Neueste Beiträge",
+        "joinedDate": "Beigetreten",
+        "posts": "Beiträge",
+        "followers": "Follower",
+        "following": "Folge ich",
+        "viewOnSite": "Auf der Website anzeigen"
+      },
+      "remote": {
+        "follow": "Folgen",
+        "unfollow": "Entfolgen",
+        "viewOn": "Ansehen auf",
+        "postsTitle": "Beiträge",
+        "noPosts": "Noch keine Beiträge von diesem Konto.",
+        "followToSee": "Folge diesem Konto, um dessen Beiträge in deiner Zeitleiste zu sehen.",
+        "notFound": "Dieses Konto konnte nicht gefunden werden. Es wurde möglicherweise gelöscht oder der Server ist nicht erreichbar."
+      }
+    },
+    "migrate": {
+      "title": "Mastodon-Migration",
+      "intro": "Diese Anleitung führt dich durch den Umzug deiner Mastodon-Identität auf deine IndieWeb-Website. Führe jeden Schritt der Reihe nach aus — deine bestehenden Follower werden benachrichtigt und können dir automatisch erneut folgen.",
+      "step1Title": "Schritt 1 — Altes Konto verknüpfen",
+      "step1Desc": "Teile dem Fediverse mit, dass dein altes Mastodon-Konto und diese Website derselben Person gehören. Dies setzt die <code>alsoKnownAs</code>-Eigenschaft auf deinem ActivityPub-Akteur, die Mastodon überprüft, bevor ein Umzug erlaubt wird.",
+      "aliasLabel": "URL des alten Mastodon-Kontos",
+      "aliasHint": "Die vollständige URL deines Mastodon-Profils, z.B. https://mstdn.social/users/rmdes",
+      "aliasSave": "Alias speichern",
+      "aliasCurrent": "Aktueller Alias",
+      "aliasNone": "Noch kein Alias konfiguriert.",
+      "step2Title": "Schritt 2 — Soziales Netzwerk importieren",
+      "step2Desc": "Lade die CSV-Dateien aus deinem Mastodon-Datenexport hoch, um deine Verbindungen zu übernehmen. Gehe zu deiner Mastodon-Instanz → Einstellungen → Import und Export → Datenexport, um sie herunterzuladen.",
+      "importLegend": "Was importieren",
+      "fileLabel": "CSV-Datei",
+      "fileHint": "Wähle eine CSV-Datei aus deinem Mastodon-Datenexport (z.B. following_accounts.csv oder followers.csv)",
+      "importButton": "Importieren",
+      "importFollowing": "Folge-Liste",
+      "importFollowingHint": "Konten, denen du folgst — sie erscheinen sofort in deiner Folge-Liste",
+      "importFollowers": "Follower-Liste",
+      "importFollowersHint": "Deine aktuellen Follower — sie werden als ausstehend erfasst, bis sie dir nach dem Umzug in Schritt 3 erneut folgen",
+      "step3Title": "Schritt 3 — Konto umziehen",
+      "step3Desc": "Sobald du deinen Alias gespeichert und deine Daten importiert hast, gehe zu deiner Mastodon-Instanz → Einstellungen → Konto → <strong>Zu einem anderen Konto umziehen</strong>. Gib dein neues Fediverse-Handle ein und bestätige. Mastodon wird alle deine Follower benachrichtigen, und die, deren Server es unterstützen, werden dir hier automatisch erneut folgen. Dieser Schritt ist unwiderruflich — dein altes Konto wird zu einer Weiterleitung.",
+      "errorNoFile": "Bitte wähle eine CSV-Datei vor dem Import aus.",
+      "success": "%d Folge-ich, %d Follower importiert (%d fehlgeschlagen).",
+      "failedList": "Konnte nicht aufgelöst werden: %s",
+      "failedListSummary": "Fehlgeschlagene Handles",
+      "aliasSuccess": "Alias gespeichert — dein Akteur-Dokument enthält jetzt dieses Konto als alsoKnownAs."
+    },
+    "refollow": {
+      "title": "Stapel-Neufolgen",
+      "progress": "Neufolgen-Fortschritt",
+      "remaining": "Verbleibend",
+      "awaitingAccept": "Warte auf Bestätigung",
+      "accepted": "Bestätigt",
+      "failed": "Fehlgeschlagen",
+      "pause": "Pausieren",
+      "resume": "Fortsetzen",
+      "status": {
+        "idle": "Inaktiv",
+        "running": "Läuft",
+        "paused": "Pausiert",
+        "completed": "Abgeschlossen"
+      }
+    },
+    "moderation": {
+      "title": "Moderation",
+      "blockedTitle": "Blockierte Konten",
+      "mutedActorsTitle": "Stummgeschaltete Konten",
+      "mutedKeywordsTitle": "Stummgeschaltete Schlüsselwörter",
+      "noBlocked": "Keine blockierten Konten.",
+      "noMutedActors": "Keine stummgeschalteten Konten.",
+      "noMutedKeywords": "Keine stummgeschalteten Schlüsselwörter.",
+      "unblock": "Entblocken",
+      "unmute": "Stummschaltung aufheben",
+      "addKeywordTitle": "Stummgeschaltetes Schlüsselwort hinzufügen",
+      "keywordPlaceholder": "Schlüsselwort oder Phrase eingeben…",
+      "addKeyword": "Hinzufügen",
+      "muteActor": "Stummschalten",
+      "blockActor": "Blockieren",
+      "filterModeTitle": "Filtermodus",
+      "filterModeHint": "Wähle, wie stummgeschaltete Inhalte in deiner Zeitleiste behandelt werden. Blockierte Konten werden immer ausgeblendet.",
+      "filterModeHide": "Ausblenden — aus der Zeitleiste entfernen",
+      "filterModeWarn": "Warnen — hinter Inhaltswarnung anzeigen",
+      "cwMutedAccount": "Stummgeschaltetes Konto",
+      "cwMutedKeyword": "Stummgeschaltetes Schlüsselwort:",
+      "cwFiltered": "Gefilterter Inhalt"
+    },
+    "compose": {
+      "title": "Antwort verfassen",
+      "placeholder": "Schreibe deine Antwort…",
+      "syndicateLabel": "Syndizieren an",
+      "submitMicropub": "Antwort veröffentlichen",
+      "cancel": "Abbrechen",
+      "errorEmpty": "Antwortinhalt darf nicht leer sein",
+      "visibilityLabel": "Sichtbarkeit",
+      "visibilityPublic": "Öffentlich",
+      "visibilityUnlisted": "Nicht gelistet",
+      "visibilityFollowers": "Nur Follower",
+      "cwLabel": "Inhaltswarnung",
+      "cwPlaceholder": "Schreibe deine Warnung hier…"
+    },
+    "notifications": {
+      "title": "Benachrichtigungen",
+      "empty": "Noch keine Benachrichtigungen. Interaktionen von anderen Fediverse-Nutzern werden hier angezeigt.",
+      "liked": "hat deinen Beitrag geliked",
+      "boostedPost": "hat deinen Beitrag geboostet",
+      "followedYou": "folgt dir",
+      "repliedTo": "hat auf deinen Beitrag geantwortet",
+      "mentionedYou": "hat dich erwähnt",
+      "markAllRead": "Alle als gelesen markieren",
+      "clearAll": "Alle löschen",
+      "clearConfirm": "Alle Benachrichtigungen löschen? Dies kann nicht rückgängig gemacht werden.",
+      "dismiss": "Verwerfen",
+      "viewThread": "Thread anzeigen",
+      "tabs": {
+        "all": "Alle",
+        "replies": "Antworten",
+        "likes": "Likes",
+        "boosts": "Boosts",
+        "follows": "Folgt",
+        "dms": "DMs",
+        "reports": "Meldungen"
+      },
+      "emptyTab": "Noch keine %s-Benachrichtigungen."
+    },
+    "messages": {
+      "title": "Nachrichten",
+      "empty": "Noch keine Nachrichten. Direktnachrichten von anderen Fediverse-Nutzern werden hier angezeigt.",
+      "allConversations": "Alle Unterhaltungen",
+      "compose": "Neue Nachricht",
+      "send": "Nachricht senden",
+      "delete": "Löschen",
+      "markAllRead": "Alle als gelesen markieren",
+      "clearAll": "Alle löschen",
+      "clearConfirm": "Alle Nachrichten löschen? Dies kann nicht rückgängig gemacht werden.",
+      "recipientLabel": "An",
+      "recipientPlaceholder": "@benutzer@instanz.social",
+      "placeholder": "Schreibe deine Nachricht...",
+      "sentTo": "An",
+      "replyingTo": "Antwort an",
+      "sentYouDM": "hat dir eine Direktnachricht gesendet",
+      "viewMessage": "Nachricht anzeigen",
+      "errorEmpty": "Nachrichteninhalt darf nicht leer sein.",
+      "errorNoRecipient": "Bitte gib einen Empfänger ein.",
+      "errorRecipientNotFound": "Dieser Benutzer konnte nicht gefunden werden. Versuche ein vollständiges @benutzer@domain-Handle."
+    },
+    "reader": {
+      "title": "Leser",
+      "tabs": {
+        "all": "Alle",
+        "notes": "Notizen",
+        "articles": "Artikel",
+        "replies": "Antworten",
+        "boosts": "Boosts",
+        "media": "Medien"
+      },
+      "empty": "Deine Zeitleiste ist leer. Folge einigen Konten, um deren Beiträge hier zu sehen.",
+      "boosted": "geboostet",
+      "replyingTo": "Antwort an",
+      "showContent": "Inhalt anzeigen",
+      "hideContent": "Inhalt ausblenden",
+      "sensitiveContent": "Sensibler Inhalt",
+      "videoNotSupported": "Dein Browser unterstützt das Video-Element nicht.",
+      "audioNotSupported": "Dein Browser unterstützt das Audio-Element nicht.",
+      "actions": {
+        "reply": "Antworten",
+        "boost": "Boosten",
+        "unboost": "Boost rückgängig",
+        "like": "Liken",
+        "unlike": "Like rückgängig",
+        "viewOriginal": "Original anzeigen",
+        "liked": "Geliked",
+        "boosted": "Geboostet",
+        "likeError": "Dieser Beitrag konnte nicht geliked werden",
+        "boostError": "Dieser Beitrag konnte nicht geboostet werden"
+      },
+      "post": {
+        "title": "Beitragsdetails",
+        "notFound": "Beitrag nicht gefunden oder nicht mehr verfügbar.",
+        "openExternal": "Auf der Original-Instanz öffnen",
+        "parentPosts": "Thread",
+        "replies": "Antworten",
+        "back": "Zurück zur Zeitleiste",
+        "loadingThread": "Thread wird geladen...",
+        "threadError": "Vollständiger Thread konnte nicht geladen werden"
+      },
+      "resolve": {
+        "placeholder": "Füge eine Fediverse-URL oder ein @benutzer@domain-Handle ein…",
+        "label": "Fediverse-Beitrag oder -Konto nachschlagen",
+        "button": "Nachschlagen",
+        "notFoundTitle": "Nicht gefunden",
+        "notFound": "Dieser Beitrag oder dieses Konto konnte nicht gefunden werden. Die URL ist möglicherweise ungültig, der Server nicht erreichbar oder der Inhalt wurde gelöscht.",
+        "followersLabel": "Follower"
+      },
+      "linkPreview": {
+        "label": "Linkvorschau"
+      },
+      "explore": {
+        "title": "Entdecken",
+        "description": "Durchsuche öffentliche Zeitleisten von entfernten Mastodon-kompatiblen Instanzen.",
+        "instancePlaceholder": "Gib einen Instanz-Hostnamen ein, z.B. mastodon.social",
+        "browse": "Durchsuchen",
+        "local": "Lokal",
+        "federated": "Föderiert",
+        "loadError": "Zeitleiste von dieser Instanz konnte nicht geladen werden. Sie ist möglicherweise nicht erreichbar oder unterstützt die Mastodon-API nicht.",
+        "timeout": "Zeitüberschreitung. Die Instanz ist möglicherweise langsam oder nicht erreichbar.",
+        "noResults": "Keine Beiträge auf der öffentlichen Zeitleiste dieser Instanz gefunden.",
+        "invalidInstance": "Ungültiger Instanz-Hostname. Bitte gib einen gültigen Domainnamen ein.",
+        "mauLabel": "MAU",
+        "timelineSupported": "Öffentliche Zeitleiste verfügbar",
+        "timelineUnsupported": "Öffentliche Zeitleiste nicht verfügbar",
+        "hashtagLabel": "Hashtag (optional)",
+        "hashtagPlaceholder": "z.B. indieweb",
+        "hashtagHint": "Ergebnisse nach einem bestimmten Hashtag filtern",
+        "tabs": {
+          "label": "Entdecken-Tabs",
+          "search": "Suchen",
+          "pinAsTab": "Als Tab anheften",
+          "pinned": "Angeheftet",
+          "remove": "Tab entfernen",
+          "moveUp": "Nach oben",
+          "moveDown": "Nach unten",
+          "addHashtag": "Hashtag-Tab hinzufügen",
+          "hashtagTabPlaceholder": "Hashtag eingeben",
+          "addTab": "Hinzufügen",
+          "retry": "Erneut versuchen",
+          "noInstances": "Hefte zuerst einige Instanzen an, um Hashtag-Tabs zu verwenden.",
+          "sources": "Suche #%s auf %d Instanz",
+          "sources_plural": "Suche #%s auf %d Instanzen",
+          "sourcesPartial": "%d von %d Instanzen haben geantwortet"
+        }
+      },
+      "tagTimeline": {
+        "postsTagged": "%d Beitrag",
+        "postsTagged_plural": "%d Beiträge",
+        "noPosts": "Keine Beiträge mit #%s in deiner Zeitleiste gefunden.",
+        "followTag": "Hashtag folgen",
+        "unfollowTag": "Hashtag entfolgen",
+        "following": "Folge ich"
+      },
+      "pagination": {
+        "newer": "← Neuere",
+        "older": "Ältere →",
+        "loadMore": "Mehr laden",
+        "loading": "Lädt…",
+        "noMore": "Du bist auf dem neuesten Stand."
+      }
+    },
+    "myProfile": {
+      "title": "Mein Profil",
+      "posts": "Beiträge",
+      "editProfile": "Profil bearbeiten",
+      "empty": "Hier ist noch nichts.",
+      "tabs": {
+        "posts": "Beiträge",
+        "replies": "Antworten",
+        "likes": "Likes",
+        "boosts": "Boosts"
+      }
+    },
+    "poll": {
+      "voters": "Abstimmende",
+      "votes": "Stimmen",
+      "closed": "Abstimmung beendet",
+      "endsAt": "Endet"
+    },
+    "federation": {
+      "deleteSuccess": "Löschaktivität an Follower gesendet",
+      "deleteButton": "Aus dem Fediverse löschen"
+    },
+    "federationMgmt": {
+      "title": "Föderation",
+      "collections": "Sammlungszustand",
+      "quickActions": "Schnellaktionen",
+      "broadcastActor": "Akteur-Update senden",
+      "debugDashboard": "Debug-Dashboard",
+      "objectLookup": "Objekt-Nachschlag",
+      "lookupPlaceholder": "URL oder @benutzer@domain-Handle…",
+      "lookup": "Nachschlagen",
+      "lookupLoading": "Wird aufgelöst…",
+      "postActions": "Beitrags-Föderation",
+      "viewJson": "JSON",
+      "rebroadcast": "Create-Aktivität erneut senden",
+      "rebroadcastShort": "Erneut senden",
+      "broadcastDelete": "Delete-Aktivität senden",
+      "deleteShort": "Löschen",
+      "noPosts": "Keine Beiträge gefunden.",
+      "apJsonTitle": "ActivityStreams JSON-LD",
+      "recentActivity": "Neueste Aktivität",
+      "viewAllActivities": "Alle Aktivitäten anzeigen →"
+    },
+    "reports": {
+      "sentReport": "hat eine Meldung eingereicht",
+      "title": "Meldungen"
+    }
+  }
+}