---
title: "Frontend-SDK"
description: "Oberfläche eines Plugins mit Vue 3 und @quicktribe/sdk: Import-Map, SDK, API-Client, Slots, Seiten, Stores, Typen, UI-Bausteine, Übersetzungen, Stile und Bauen"
---

Die Oberfläche eines Plugins ist ein ES-Modul aus `frontend/index.ts`, geschrieben mit Vue 3 (`<script setup>`) und TypeScript. Es läuft in der Seite von QuickTribe – mit derselben Vue-, Pinia- und Router-Instanz – und hängt sich an festgelegten Stellen (**Slots**) ein oder bringt eigene **Seiten** mit.

## Einstieg

```ts
// frontend/index.ts
import './plugin.css';
import { defineAsyncComponent } from 'vue';
import { definePlugin } from '@quicktribe/sdk';
import en from '../translations/messages.en.json';

export default definePlugin((sdk) => {
  sdk.addMessages('en', en);
  sdk.registerSlot('calendar.list.card.footer', defineAsyncComponent(() => import('./CardFooter.vue')));
  sdk.registerSlot(`settings.plugin.${sdk.id}`, defineAsyncComponent(() => import('./SettingsLink.vue')));
  sdk.registerRoutes([
    { path: '/', component: () => import('./pages/Overview.vue') },
    { path: '/offers/:id', component: () => import('./pages/Offer.vue') },
  ]);
});
```

- Der Standard-Export ist `install(sdk)` (gern über `definePlugin`); er darf `async` sein.
- Slot-Komponenten und Seiten nur **nachgeladen** registrieren (`defineAsyncComponent(() => import(…))` bzw. `component: () => import(…)`). Der Einstieg selbst bleibt höchstens 15 KB groß (gzip) – er lädt auf jeder Seite, auf der das Plugin wirkt.
- Der Kern lädt das Skript nur, wenn das Plugin auf der Seite wirkt: in einer Community nur, wenn es dort eingeschaltet ist; auf Seiten ohne Community (Startseite, Konto, Plattform-Admin, globale Plugin-Seiten) für alle plattformweit aktiven Plugins – auch solche, die nur je Community gelten.

## Erlaubte Importe

Zur Laufzeit importiert ein Plugin nur **`vue`**, **`pinia`**, **`vue-router`**, **`@quicktribe/sdk`** und eigene Dateien. Eine **Import-Map** im Kopf jeder Seite lenkt diese vier Namen auf die Module des Kerns; das Plugin bündelt nie eine eigene Vue-Kopie. Typen kommen per `import type` aus `@quicktribe/sdk/types`. ESLint und `npm run build:plugins` lehnen andere Importe ab (etwa Pfade aus dem Kern wie `@shared/…`).

## Das SDK

`install()` bekommt das SDK als Parameter, Komponenten holen es mit `usePluginSdk()`.

| Teil | Inhalt |
| --- | --- |
| `id` | Plugin-ID |
| `session` | Session-Store der Seite (Nutzer, Community, Mitgliedschaft, Rechte) – nur lesen |
| `data` | Session-Daten des Plugins (`Registry::sessionData`, höchstens 4 KB) |
| `settings` | Community-Einstellungen mit `exposeToMembers()` |
| `api` | Client für die eigenen Endpunkte (unten) |
| `registerSlot(name, component, { order? })` | Komponente in einen [Slot](#slots) hängen; `order` klein zuerst (Standard 100) |
| `registerRoutes(routes)` | Routen der eigenen [Seiten](#seiten) |
| `useRoute`, `useRouter`, `RouterLink`, `RouterView` | Vue Router |
| `addMessages('en', messages)`, `t(key, params?)` | eigene Übersetzungen (siehe [Übersetzungen](#übersetzungen)) |
| `format` | `dateTime(value, { timeZone?, style? })` (`date`, `time`, `dateTime`, `full`; Standard: Zeitzone des Kontos), `relative(value)` („vor 5 Minuten“), `number(value, options?)`, `km(value)` (wie im Kalender), `money(cents, currency?)` |
| `urls` | `page(path)`, `globalPage(path)`, `event(eventId, start?)`, `profile(userId)`, `conversation(id)`, `newMessage(userId)`, `account(anchor)` |
| `ui` | die [UI-Bausteine](#ui-bausteine) (auch direkt aus `@quicktribe/sdk` importierbar) |

## API-Client

```ts
const offers = await sdk.api.get<OfferList>('/offers', { eventId, start });
await sdk.api.post('/offers', { seats: 3 }, { idempotencyKey: true });
const file = await sdk.api.upload<UploadResult>('/documents', files, { field: 'file', onProgress: (p) => (progress.value = p) });
const csvUrl = sdk.api.url('/export.csv', { year: 2026 });   // für <a :href> und Downloads
const status = await sdk.api.global.get<Status>('/status');  // Endpunkte ohne Community
```

- Pfade beginnen mit `/` und sind relativ zu `/api/plugins/<id>/c/<slug>`; `sdk.api.global` gilt für Endpunkte ohne Community (`/api/plugins/<id>`). Auf Seiten ohne Community gibt es nur `api.global`.
- Der Client setzt CSRF-Kopfzeile und Sitzung selbst. `options`: `signal` (Abbrechen) und `idempotencyKey` (eigener Schlüssel oder `true` = zufällig, für Aktionen, die nicht doppelt laufen dürfen).
- `upload()` schickt `multipart/form-data` per POST mit Fortschritt; mehrere Dateien als `<feld>[]`, weitere Felder über `fields`. Die Grenzen prüft der Server (`UploadRule`).
- Fehler kommen als `ApiProblem` (aus `@quicktribe/sdk`) mit `status`, `message`, `violations` (Feldpfad → Meldung, passend für `UiField`) und `retryAfterSeconds` bei `429`.

Typen der eigenen Endpunkte schreibst du von Hand in `frontend/api-types.ts` – passend zu den PHP-Klassen, die der Handler zurückgibt (am besten `readonly`-Klassen mit `\JsonSerializable`). Kern- und Slot-Typen kommen ausschließlich aus dem SDK:

```ts
import type { ApiSchemas, SlotProps } from '@quicktribe/sdk/types';

type EventOccurrence = ApiSchemas['EventOccurrenceResponse'];
```

## Slots

Slots sind feste Stellen in der Oberfläche von QuickTribe. Eine Slot-Komponente bekommt die Props `context` (nur lesen) und `pluginId`:

| Slot | Wo | `context` |
| --- | --- | --- |
| `calendar.event.detail.aside` | Event-Ansicht, neben den Angaben zum Termin | `event` (`EventOccurrenceResponse`), `detail` (`EventDetailResponse`), `occurrenceStart`, `viewerCanManage`, `refresh()` |
| `calendar.event.editor.fields` | Event-Editor, unter den Feldern | `event` (`EventOccurrenceResponse` oder `null`), `mode` (`create`/`edit`), `extra` (reaktiv, beginnt mit `{}`), `violations` |
| `calendar.list.card.footer` | Fuß jeder Event-Karte in der Liste | `event` (`EventOccurrenceResponse`) |
| `members.profile.sections` | Mitgliederprofil, eigene Abschnitte | `member` (`MemberResponse`), `profile` (`MemberProfileResponse`), `self`, `refresh()` |
| `leaderboard.sidebar` | Seitenleiste des Leaderboards | `data` (`LeaderboardResponse`) |
| `leaderboard.row.after` | nach jeder Zeile des Leaderboards | `entry` (`LeaderboardEntryResponse`) |
| `feed.post.editor.fields` *(ab 1.2)* | Beitragseditor, unter den Feldern | `post` (`PostResponse` oder `null`), `mode` (`create`/`edit`), `extra` (reaktiv, beginnt mit `{}`), `violations` |
| `feed.post.footer` *(ab 1.2)* | unter einem Beitrag in Liste und Ansicht (nicht bei Geburtstags-Einträgen) | `post` (`PostResponse`), `detail` (bool) |
| `classroom.course.editor.fields` *(ab 1.2)* | Kurs-Editor, über dem Speichern | `course` (`CourseResponse` oder `null`), `mode`, `extra`, `violations` |
| `classroom.course.detail` *(ab 1.2)* | Kursseite, unter der Beschreibung (nur freigeschaltete Kurse) | `course` (`CourseDetailResponse`), `refresh()` |
| `classroom.lesson.editor.fields` *(ab 1.2)* | Lektions-Editor (Dialog) | `lesson` (`LessonResponse` oder `null`), `courseId`, `mode`, `extra`, `violations` |
| `classroom.lesson.footer` *(ab 1.2)* | unter dem Inhalt einer Lektion | `lesson` (`LessonResponse`), `refresh()` |
| `settings.plugin.<id>` | Einstellungen → Plugins → `<id>`, unter dem generischen Formular – nur das eigene Plugin | `pluginId`, `community` (`id`, `slug`, `name`), `viewer` (`isOwner`, `isManager`), `settings`, `saveSettings(values)` |

```vue
<!-- frontend/CardFooter.vue -->
<script setup lang="ts">
import { computed } from 'vue';
import { UiBadge, usePluginSdk } from '@quicktribe/sdk';
import type { SlotProps } from '@quicktribe/sdk/types';

const props = defineProps<SlotProps<'calendar.list.card.footer'>>();
const sdk = usePluginSdk();
// Angaben aus der eigenen ResponseExtension (extra.<pluginId>)
const offers = computed(() => (props.context.event.extra?.[props.pluginId] as { offers?: number } | undefined)?.offers ?? 0);
</script>

<template>
  <UiBadge v-if="offers > 0">
    {{ offers === 1 ? sdk.t('Eine Mitfahrgelegenheit') : sdk.t('{count} Mitfahrgelegenheiten', { count: offers }) }}
  </UiBadge>
</template>
```

- **Event-Editor:** Was die Komponente unter `context.extra[pluginId]` ablegt, schickt der Editor beim Speichern mit (siehe [Eingaben im Event-Editor](/plugins/erweiterungspunkte#erweiterungen-von-kern-antworten)). `extra` beginnt immer leer – bestehende Werte lädt das Plugin über die eigene Schnittstelle. `violations` enthält nur die Meldungen dieses Plugins, ohne das Präfix `extra.<pluginId>.`.
- **Editoren für Beitrag, Kurs und Lektion (ab 1.2):** gleiche Regeln wie im Event-Editor – der Block geht als `extra` im Request mit, die Eingabe nimmt eine `InputExtension` entgegen (siehe [Eingaben](/plugins/erweiterungspunkte#erweiterungen-von-kern-antworten)). Deklarierte Zusatzfelder zeigt der Editor selbst; der Slot ist für eigene Bedienelemente. Kurse und Lektionen bearbeitet nur die Kursverwaltung.
- **Twig-Seiten:** Formular-Ausfüllseiten und öffentliche Landingpages laufen ohne Plugin-JavaScript; dort wirken nur [Feldtypen und Bausteine](/plugins/erweiterungspunkte#filter-hooks) aus Twig-Vorlagen des Plugins (mit dessen `dist/plugin.css`).
- Die Slots in Event-Ansicht und Event-Liste erscheinen nur bei Terminen, die der Betrachter sehen darf; Slots eines in der Community ausgeschalteten Plugins erscheinen nie.
- Später registrierte Slots erscheinen nachträglich. Unbekannte Slot-Namen (etwa aus einer neueren Version) ignoriert das SDK mit einer Warnung in der Konsole.
- Wirft eine Komponente beim Aufbauen oder Zeichnen einen Fehler, blendet der Kern sie aus (auch in Produktion), meldet den Fehler an den Server, und das Plugin verschwindet aus allen Slots der Seite. Die Seite selbst läuft weiter.

## Seiten

Seiten registriert das Plugin in PHP mit `page()` (siehe [Seiten](/plugins/erweiterungspunkte#seiten)); ihren Inhalt liefert `sdk.registerRoutes()`. Die Routen sind relativ zur Basis der Seite – `/c/<slug>/plugins/<id>` bzw. ohne Community `/plugins/<id>` –, also `path: '/'` für die Startseite des Plugins und `path: '/offers/:id'` für `/c/<slug>/plugins/<id>/offers/<id>`. Der Kern rendert dabei Kopf, Navigation und Fuß der Plattform.

- `registerRoutes()` wirkt nur auf der Seite dieses Plugins und nur während `install()`; auf anderen Seiten wird es ignoriert.
- Passt keine Route, zeigt die Seite eine 404-Ansicht.
- Links innerhalb des Plugins mit `RouterLink`; Links auf andere Bereiche über `sdk.urls` mit `<a href>` (anderer Bereich = neue Seite).

## Stores

Ein Plugin darf eigene Pinia-Stores anlegen – in derselben Pinia wie der Kern, deshalb mit der ID **`plugin.<id>.<name>`**:

```ts
import { ref } from 'vue';
import { defineStore } from 'pinia';
import type { Offer } from './api-types';

export const useOfferStore = defineStore('plugin.carpool.offers', () => {
  const items = ref<Offer[]>([]);
  // …
  return { items };
});
```

Stores, die eine Liste laden und lokal ändern, verwerfen veraltete Antworten (z. B. mit einem Zähler je Ladevorgang), damit eine spät eintreffende Liste keine eben gespeicherte Änderung überschreibt.

## UI-Bausteine

Dieselben Komponenten wie im Kern – gleiche Optik, Themes und Dunkelmodus:

| Baustein | Zweck |
| --- | --- |
| `UiButton`, `UiBadge`, `UiAlert`, `UiSkeleton`, `UiEmptyState`, `UiDialog` | Knöpfe, Schildchen, Meldungen, Ladeplatzhalter, leere Zustände, Dialoge |
| `UiAvatar`, `MemberBadges` | Profilbild und Abzeichen einer Person |
| `RichTextBody` | Rich-Text anzeigen – nur mit Werten aus `html()->sanitize()` |
| `UiField` | Beschriftung, Hinweis und Fehler eines Felds; nimmt `violations` und `name` und zeigt die passende Meldung |
| `UiInput`, `UiTextarea`, `UiSelect`, `UiCheckbox` | Eingaben mit `v-model`; Datum und Uhrzeit über `UiInput type="date" \| "time" \| "datetime-local"` |
| `UiFileUpload` | Dateiauswahl mit Vorabprüfung (`extensions`, `maxBytes`, `maxFiles`) und Fortschritt (`progress`) |
| `UiDocumentPreview` | Vorschau eines Dokuments: Bilder im Dialog, PDF in neuem Tab, sonst Download (`url` auf einen eigenen Endpunkt mit `inline: true`) |
| `UiMemberPicker` | Mitgliedersuche der Community (`v-model` = Liste, `max`, `exclude`, `includeSelf`) |

```vue
<UiField :label="sdk.t('Plätze')" name="seats" :violations="problem?.violations">
  <UiInput v-model="seats" type="number" min="1" max="8" />
</UiField>
```

Rohes HTML (`v-html`) ist in Plugin-Oberflächen verboten (ESLint).

## Übersetzungen

Deutsch ist Quelltext und Schlüssel, Englisch steht in `translations/messages.en.json` – derselben Datei, die auch PHP und die E-Mail-Vorlagen nutzen. Die Oberfläche übernimmt sie mit `sdk.addMessages('en', en)`; `sdk.t('Hallo {name}!', { name })` übersetzt mit Platzhaltern. **ICU-Plurale** (`{count, plural, …}`) kennt die Oberfläche nicht – ein solcher Text wirft einen Fehler, und das Plugin verschwindet aus allen Slots der Seite. Einzahl und Mehrzahl stehen deshalb als eigene Texte, die Auswahl trifft der Code (siehe [Übersetzungen](/plugins/testen#übersetzungen)). Jedes Plugin hat eine eigene Übersetzungs-Instanz, die des Kerns bleibt unberührt. `npm run build:plugins` warnt, `npm run i18n:check` scheitert, wenn ein `t('…')`-Text ohne englische Übersetzung ist.

## Stile mit Tailwind

`frontend/plugin.css` bindet die Utilities von Tailwind gegen das Theme der Plattform ein – mit deren Farben, Tokens (`bg-primary`, `text-ink`, `rounded-card` …), Breakpoints und Dunkelmodus, aber ohne deren eigene Klassen:

```css
@layer theme, base, components, utilities, app;
@reference "../../../assets/styles/tailwind-theme.css";
@import "tailwindcss/utilities.css" layer(utilities) source(none);
@source "./";
@source "../templates/forms";   /* ab 1.2, nur mit Feldtypen */
@source "../templates/blocks";  /* ab 1.2, nur mit Landingpage-Bausteinen */
```

- `index.ts` importiert `plugin.css`. Gebaut entsteht genau eine Datei `dist/plugin.css` mit den Klassen, die das Plugin benutzt.
- **Vorlagen für Feldtypen und Bausteine (ab 1.2):** Ihre Klassen erzeugt Tailwind nur, wenn `plugin.css` die Ordner `../templates/forms` bzw. `../templates/blocks` als `@source` nennt. Nie das ganze `../templates`: PDF- und Mail-Vorlagen enthalten Wörter wie `fixed`, aus denen sonst Klassen entstünden. Der Build und `app:plugin:validate` warnen bei fehlender Angabe.
- **Alle Klassen erlaubt:** `hidden`, `block`, `flex`, `grid-cols-2`, `fixed`, `overflow-x-auto` und jede andere Klasse wirken nur in der Oberfläche des Plugins (siehe [Geltungsbereich](#geltungsbereich-plugin-stile-wirken-nur-im-plugin)) – auch in den Vorlagen für Feldtypen und Bausteine. Tailwind liest weiterhin jedes passende Wort, auch in Code und Texten; solche Klassen landen in `dist/plugin.css`, verändern aber die Plattform nicht.
- `@reference` zeigt immer auf `tailwind-theme.css`, nie auf `tailwind.css` (sonst enthielte die Datei alle Klassen des Kerns).
- `<style scoped>` in Komponenten geht; zur Laufzeit darf ein Plugin aber nie `<style>`-Elemente einfügen oder Regeln per `insertRule` setzen – die Sicherheitsrichtlinie in Produktion blockiert das.
- Bilder und Schriften bettet der Build als `data:`-URI ein; als eigene Datei mit `?no-inline` am Import bzw. in `url()` (der Build warnt bei eingebetteten Dateien über 4 KB).

### Geltungsbereich: Plugin-Stile wirken nur im Plugin

Die Plattform stellt jede Komponente eines Plugins (Slot oder Seite) in ein eigenes Element `<div data-plugin="<id>">`, ebenso jeden Landingpage-Baustein und jeden Feldtyp eines Plugins auf den Twig-Seiten (ab 1.2). Beim Bauen bekommt jeder Selektor in `dist/plugin.css` den Vorsatz `:where([data-plugin="<id>"])` – eine Klasse wie `hidden`, `flex` oder `w-full` wirkt damit nur in der Oberfläche des Plugins, auch wenn das Wort zufällig in einem Variablennamen steht: Selektoren treffen nur das Plugin-DOM, seitenweite At-Regeln lehnt die Prüfung ab (siehe unten). Im Plugin selbst gilt Tailwind wie gewohnt: `hidden md:flex`, `dark:`, `print:`, `group-hover:`, `peer-*` und Zustände der UI-Bausteine verhalten sich wie in der Plattform. In der Entwicklungsumgebung schreibt der Vite-Dev-Server dieselben Selektoren um.

- **Leere Slot-Komponenten:** Rendert eine Komponente nichts (etwa `v-if` ohne Treffer), bleibt ihre Hülle als leeres, ausgeblendetes Element stehen. In Stapeln mit `space-y-*` der Plattform kann eine solche Hülle als letztes Element unter dem letzten sichtbaren Eintrag einen zusätzlichen Abstand bewirken. Wer häufig nichts anzeigt, gibt lieber einen knappen Hinweis aus oder registriert den Slot nur, wenn es etwas zu zeigen gibt.
- **Dialoge:** `UiDialog` zeigt seinen Inhalt am Ende der Seite an, außerhalb des Plugin-Elements – Inhalt und Aktionen bekommen das Element dort erneut, Plugin-Klassen wirken also auch im Dialog.
- **Eigenes `<Teleport>`:** Was ein Plugin selbst an eine andere Stelle der Seite teleportiert, liegt außerhalb seines Elements und bekommt seine Stile nicht. Den teleportierten Inhalt deshalb selbst einhüllen: `<Teleport to="body"><div :data-plugin="sdk.id">…</div></Teleport>`.
- **Vorfahren außerhalb des Plugins greifen nicht:** Ein Selektor wie `.kompakt .karte` oder `[data-theme=dark] .karte` verlangt den Vorfahren *innerhalb* des Plugins; Klassen der Plattform-Elemente drumherum zählen nicht mehr. Dasselbe gilt für die Tailwind-Varianten `in-*` und `[.x_&]:`. Für den Dunkelmodus `dark:` verwenden, in eigenen Regeln `:root[data-theme=dark] .karte` bzw. `html[data-theme=dark] .karte` (Selektoren, die mit `:root`, `:host` oder `html` beginnen, beziehen sich auf die Seite). `group-*` und `peer-*` funktionieren weiter.
- **Eigene Regeln** in `plugin.css` (etwa `.mein-kasten { … }` oder eigene Theme-Variablen mit `@theme`) bekommen denselben Vorsatz; Variablen auf `:root` gelten nur im Plugin. In verschachtelten Regeln steht `&` am Element selbst (`&:hover`, `.x &`, `:is(& > *)`), nicht nur in `:has(&)` oder `:not(&)` – solche Selektoren träfen Vorfahren außerhalb und lehnt der Build ab.
- **Nicht erlaubt** und vom Build abgelehnt: `@scope` (auch verschachtelt), `@import` von außen, andere Anweisungen als `@layer`, `@charset` und `@namespace`, Zeilenumbrüche in Zeichenketten sowie `url(…)` ohne Anführungszeichen mit Anführungszeichen, Klammern oder `/*` darin (dann `url("…")` schreiben). Unter der Hülle selbst (`:root { & ~ * {…} }` bzw. `:root { ~ * {…} }`) kein `+` oder `~` nach `&` – das träfe Elemente neben dem Plugin.
- **Seitenweite At-Regeln:** `@page`, `@view-transition`, `@position-try` und `@font-feature-values` gelten immer für die ganze Seite und sind nicht erlaubt. Namen von `@keyframes`, `@counter-style` und die Schriftfamilie in `@font-face` beginnen mit der Plugin-ID (`<id>-…`), `@font-palette-values` mit `--<id>-…`. Ausnahme: die Tailwind-Animationen `spin`, `ping`, `pulse` und `bounce` (`animate-spin` …) in genau der Fassung von Tailwind. `@property` nur für `--<id>-*` oder für Tailwind-Variablen `--tw-*` in der Fassung, die Tailwind selbst erzeugt – eine abweichende Fassung (etwa ein anderer Startwert von `--tw-border-style`) änderte auch Elemente der Plattform.
- **Woher CSS kommen darf:** aus Dateien im Plugin-Verzeichnis – `frontend/`, andere Ordner des Plugins, eigene `node_modules` des Plugins – und aus `<style>` in Komponenten; auch `?inline` erhält den Geltungsbereich. CSS aus den `node_modules` der Plattform lehnt `npm run build:plugins` ab („CSS von außerhalb des Plugins“), weil es im Dev-Server ohne Geltungsbereich gälte: Datei ins Plugin übernehmen.
- **Ältere Builds:** Ein `dist/plugin.css` ohne Geltungsbereich (gebaut vor dieser Regel) lehnt `app:plugin:validate` ab („… mit einem älteren build-plugins gebaut, neu bauen“); die Plattform lädt es nicht, das Plugin läuft dann ohne seine Stile, und die Plugin-Verwaltung zeigt **Stile nicht geladen – neu bauen**. Abhilfe: mit dem aktuellen Stand neu bauen (`npm run build:plugins <id>`) und einspielen.

## Bauen

```bash
npm run build:plugins             # alle Plugins mit frontend/index.ts
npm run build:plugins carpool     # nur dieses
```

Ergebnis in `plugins/<id>/dist/`: `plugin.js` (Einstieg), `chunks/` (nachgeladene Teile), `plugin.css` und ggf. `assets/`. Der Build prüft anschließend:

- keine eigene Vue- oder Router-Kopie, nur die vier erlaubten Importe und eigene Chunks;
- Einstieg höchstens 15 KB (gzip);
- keine Source-Maps, Dateinamen nur aus `A–Z a–z 0–9 _ . / -`, nur Endungen, die der Webserver ausliefert (`js`, `css`, `woff2`, `png`, `webp`, `svg`, `json`);
- CSS nur mit dem [Geltungsbereich des Plugins](#geltungsbereich-plugin-stile-wirken-nur-im-plugin);
- Warnungen bei eingefügten Styles, großen eingebetteten Dateien und fehlenden englischen Texten.

`app:plugin:validate` prüft `dist/` noch einmal nach denselben Regeln. In der Entwicklungsumgebung ist kein Build nötig – dort lädt die Seite `frontend/index.ts` direkt vom Vite-Dev-Server. In Produktion liefert der Webserver die Dateien unter `/plugin-assets/<id>/<hash>/…` aus; der Hash ändert sich mit jedem neuen Build, Browser speichern die Dateien deshalb dauerhaft zwischen.
