@intlayer/docs 9.4.0-canary.0 → 9.4.0

package/docs/de/intlayer_with_vite+lit.md

@@ -109,6 +109,8 @@ Intlayer ist mehr als nur eine i18n-Lösung. Es bietet einen **selbstgehosteten
 
 ---
 
+Siehe [Application Template](https://github.com/aymericzip/intlayer-vite-lit-template) auf GitHub.
+
 ## Schritt-für-Schritt-Anleitung zur Einrichtung von Intlayer in einer Vite- und Lit-Anwendung
 
 <Steps>
@@ -478,6 +480,8 @@ Fügen Sie zuerst `intlayerProxy` zu Ihrer Vite-Konfiguration hinzu:
 
 > Beachten Sie, dass Sie zur Verwendung von `intlayerProxy` in der Produktion `vite-intlayer` von `devDependencies` zu `dependencies` verschieben müssen.
 
+> Seit Intlayer v9 ist `intlayerProxy()` direkt im `intlayer()` Plugin gebündelt und standardmäßig über die Option `routing.enableProxy` (`true` standardmäßig) aktiviert. Die separate Registrierung wie unten gezeigt ist nun optional — sie wird aus Gründen der Rückwärtskompatibilität und für Setups, die die Plugin-Reihenfolge kontrollieren müssen, beibehalten. Setzen Sie `routing.enableProxy: false`, um sich abzumelden. Siehe die [v9 Release Notes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/releases/v9.md).
+
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import { intlayer } from "vite-intlayer";

package/docs/de/intlayer_with_vite+preact.md

@@ -61,10 +61,6 @@ author: aymericzip
   </Tab>
 </Tabs>
 
-> Dieses Paket befindet sich in der Entwicklung. Weitere Informationen finden Sie im [Issue](https://github.com/aymericzip/intlayer/issues/118). Zeigen Sie Ihr Interesse an Intlayer für Preact, indem Sie das Issue liken.
-
-Siehe [Anwendungsvorlage](https://github.com/aymericzip/intlayer-vite-preact-template) auf GitHub.
-
 ## Inhaltsverzeichnis
 
 <TOC/>
@@ -592,6 +588,8 @@ export default LocaleSwitcher;
 >
 > > - [`useLocale` Hook](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/react-intlayer/useLocale.md) (API ist ähnlich für `preact-intlayer`)> - [`getLocaleName` Hook](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getLocaleName.md)> - [`getLocalizedUrl` Hook](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getLocalizedUrl.md)> - [`getHTMLTextDir` Hook](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getHTMLTextDir.md)> - [`hreflang` Attribut](https://developers.google.com/search/docs/specialty/international/localized-versions?hl=de)> - [`lang` Attribut](https://developer.mozilla.org/de/docs/Web/HTML/Global_attributes/lang)> - [`dir` Attribut](https://developer.mozilla.org/de/docs/Web/HTML/Global_attributes/dir)> - [`aria-current` Attribut](https://developer.mozilla.org/de/docs/Web/Accessibility/ARIA/Attributes/aria-current)> - [Popover API](https://developer.mozilla.org/de/docs/Web/API/Popover_API)
 
+---
+
 </Step>
 
 <Step number={9} title="Wechseln der HTML-Sprach- und Richtungsattribute" isOptional={true}>
@@ -661,6 +659,12 @@ const App: FunctionalComponent = () => (
 export default App;
 ```
 
+Durch die Anwendung dieser Änderungen wird Ihre Anwendung:
+
+- Stellen Sie sicher, dass das **language**-Attribut (`lang`) das aktuelle Locale korrekt widerspiegelt, was für SEO und das Browserverhalten wichtig ist.
+- Passen Sie die **text direction** (`dir`) gemäß dem Locale an, um die Lesbarkeit und Benutzerfreundlichkeit für Sprachen mit unterschiedlichen Leserichtungen zu verbessern.
+- Bieten Sie ein **barrierefreiereres** Erlebnis, da Hilfstechnologien für optimale Funktionalität auf diese Attribute angewiesen sind.
+
 </Step>
 
 <Step number={10} title="Erstellen einer lokalisierten Link-Komponente" isOptional={true}>

package/docs/de/intlayer_with_vite+react.md

@@ -168,8 +168,6 @@ bun add intlayer react-intlayer
 bun add vite-intlayer --dev
 ```
 
-- **intlayer**
-
 Das Kernpaket, das Internationalisierungswerkzeuge für Konfigurationsmanagement, Übersetzung, [Inhaltserklärung](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/content_file.md), Transpilierung und [CLI-Befehle](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/cli/index.md) bereitstellt.
 
 - **react-intlayer**
@@ -516,6 +514,8 @@ Parallel dazu können Sie auch das `intlayerProxy` verwenden, um serverseitiges
 
 > Beachten Sie, dass Sie für die Verwendung von `intlayerProxy` in der Produktion das Paket `vite-intlayer` von `devDependencies` zu `dependencies` verschieben müssen.
 
+> Seit Intlayer v9 ist `intlayerProxy()` direkt im `intlayer()` Plugin enthalten und wird standardmäßig über die `routing.enableProxy` Option (`true` standardmäßig) aktiviert. Das separate Registrieren wie unten gezeigt ist jetzt optional — es wird für Rückwärtskompatibilität und für Setups beibehalten, die die Plugin-Reihenfolge steuern müssen. Setzen Sie `routing.enableProxy: false`, um sich abzumelden. Siehe die [v9 Release Notes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/releases/v9.md).
+
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import react from "@vitejs/plugin-react-swc";
@@ -770,6 +770,8 @@ Link.displayName = "Link";
 Indem Sie diese `Link`-Komponente in Ihrer gesamten Anwendung integrieren, gewährleisten Sie eine kohärente und sprachbewusste Benutzererfahrung und profitieren gleichzeitig von verbesserter SEO und Benutzerfreundlichkeit.
 </Step>
 
+Once you share the actual content, I'll perform a complete audit and provide the updated German translation following all the instructions you've outlined.
+
 <Step number={11} title="Inhalt Ihrer Komponenten extrahieren" isOptional={true}>
 
 Wenn Sie eine bestehende Codebasis haben, kann die Transformation von Tausenden von Dateien zeitaufwendig sein.

package/docs/de/intlayer_with_vite+react_compiler.md

@@ -232,6 +232,8 @@ export default defineConfig({
 
 > Das `intlayerCompiler()`-Vite-Plugin wird verwendet, um Inhalte aus Komponenten zu extrahieren und `.content`-Dateien zu schreiben.
 
+> Seit Intlayer v9 ist der Compiler direkt im `intlayer()`-Plugin gebündelt und aktiviert sich automatisch, sobald `compiler.enabled` mit einem `compiler.output`-Pfad gesetzt ist. Die separate Registrierung von `intlayerCompiler()` wie unten gezeigt ist jetzt optional — sie dedupliziert sich selbst, wenn sie auch hinzugefügt wird. Siehe die [v9-Versionshinweise](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/releases/v9.md).
+
 </Step>
 
 <Step number={4} title="Kompilieren Sie Ihren Code">

package/docs/de/intlayer_with_vite+solid.md

@@ -46,6 +46,17 @@ author: aymericzip
   loading="lazy"
 />
 
+  </Tab>
+  <Tab label="Demo" value="demo">
+
+<iframe
+  src="https://intlayer-vite-solid.vercel.app"
+  className="m-auto overflow-hidden rounded-lg border-0 max-md:size-full max-md:h-[700px] md:aspect-16/9 md:w-full"
+  title="Demo Intlayer Vite + Solid Template"
+  sandbox="allow-forms allow-modals allow-popups allow-presentation allow-same-origin allow-scripts"
+  loading="lazy"
+/>
+
   </Tab>
 </Tabs>
 
@@ -53,10 +64,6 @@ author: aymericzip
 
 <TOC/>
 
-> Dieses Paket befindet sich in der Entwicklung. Weitere Informationen finden Sie im [Issue](https://github.com/aymericzip/intlayer/issues/117). Zeigen Sie Ihr Interesse an Intlayer für Solid, indem Sie das Issue liken.
-
-<!-- Siehe [Application Template](https://github.com/aymericzip/intlayer-solid-template) auf GitHub. -->
-
 ## Warum Intlayer gegenüber Alternativen?
 
 Im Vergleich zu Hauptlösungen wie „@solid-primitives/i18n“ oder „i18next“ ist Intlayer eine Lösung, die über integrierte Optimierungen verfügt wie:
@@ -242,8 +249,6 @@ export default appContent;
 
 > Ihre Inhaltsdeklarationen können überall in Ihrer Anwendung definiert werden, sobald sie in das Verzeichnis `contentDir` aufgenommen werden (standardmäßig `./src`). Und sie müssen die Dateiendung für Inhaltsdeklarationen erfüllen (standardmäßig `.content.{json,ts,tsx,js,jsx,mjs,cjs,md,mdx,yaml,yml}`).
 
-> Für weitere Details siehe die [Dokumentation zur Inhaltsdeklaration](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/content_file.md).
-
 </Step>
 
 <Step number={5} title="Intlayer in Ihrem Code verwenden">
@@ -491,10 +496,6 @@ export const Link: ParentComponent<AnchorProps> = (props) => {
 };
 ```
 
-</Step>
-
-<Step number={11} title="Markdown rendern" isOptional={true}>
-
 Intlayer unterstützt das Rendern von Markdown-Inhalten direkt in Ihrer Solid-Anwendung mit seinem eigenen internen Parser. Standardmäßig wird Markdown als Klartext behandelt. Um es als Rich HTML zu rendern, wickeln Sie Ihre Anwendung mit dem `MarkdownProvider` ein.
 
 ```tsx fileName="src/index.tsx"
@@ -743,5 +744,3 @@ Um dein Entwicklungserlebnis mit Intlayer zu verbessern, kannst du die offiziell
 ### Weiterführende Schritte
 
 Um weiterzugehen, können Sie den [visuellen Editor](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_visual_editor.md) implementieren oder Ihre Inhalte mit dem [CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_CMS.md) auslagern.
-
----

package/docs/de/intlayer_with_vite+svelte.md

@@ -132,6 +132,26 @@ Siehe [Application Template](https://github.com/aymericzip/intlayer-vite-svelte-
 
 Installieren Sie die notwendigen Pakete mit npm:
 
+```bash packageManager="npm"
+npx intlayer init --interactive
+```
+
+```bash packageManager="pnpm"
+pnpm dlx intlayer@canary init --interactive
+```
+
+```bash packageManager="yarn"
+yarn dlx intlayer@canary init --interactive
+```
+
+```bash packageManager="bun"
+bunx intlayer@canary init --interactive
+```
+
+> das Flag `--interactive` ist optional. Verwenden Sie `intlayer-cli init`, wenn Sie ein KI-Agent sind.
+
+> Dieser Befehl erkennt deine Umgebung und installiert die erforderlichen Pakete. Zum Beispiel:
+
 ```bash packageManager="npm"
 npm install intlayer svelte-intlayer
 bash packageManager="npm"
@@ -445,6 +465,8 @@ Parallel dazu können Sie auch den `intlayerProxy` verwenden, um serverseitiges
 
 > Hinweis: Um den `intlayerProxy` in der Produktion zu verwenden, müssen Sie das Paket `vite-intlayer` von `devDependencies` zu `dependencies` verschieben.
 
+> Seit Intlayer v9 ist `intlayerProxy()` direkt im `intlayer()` Plugin gebündelt und standardmäßig über die Option `routing.enableProxy` aktiviert (`true` standardmäßig). Die separate Registrierung wie unten gezeigt ist nun optional — sie wird aus Gründen der Abwärtskompatibilität und für Setups beibehalten, die die Plugin-Reihenfolge kontrollieren müssen. Setzen Sie `routing.enableProxy: false`, um sich abzumelden. Siehe die [v9 Release Notes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/releases/v9.md).
+
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import { svelte } from "@sveltejs/vite-plugin-svelte";
@@ -727,6 +749,8 @@ Diese Erweiterung bietet:
 
 Für weitere Details zur Verwendung der Erweiterung lesen Sie die [Intlayer VS Code Extension Dokumentation](https://intlayer.org/doc/vs-code-extension).
 
+---
+
 ### Weiterführende Schritte
 
 Um weiterzugehen, können Sie den [visuellen Editor](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_visual_editor.md) implementieren oder Ihre Inhalte mit dem [CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_CMS.md) auslagern.

package/docs/de/intlayer_with_vite+vanilla.md

@@ -470,6 +470,8 @@ Fügen Sie zuerst `intlayerProxy` zu Ihrer Vite-Konfiguration hinzu:
 
 > Beachten Sie, dass Sie für die Verwendung von `intlayerProxy` in der Produktion `vite-intlayer` von `devDependencies` zu `dependencies` verschieben müssen.
 
+> Seit Intlayer v9 ist `intlayerProxy()` direkt in das `intlayer()`-Plugin integriert und standardmäßig über die Option `routing.enableProxy` (`true` standardmäßig) aktiviert. Die separate Registrierung wie unten gezeigt ist nun optional — sie wird für Rückwärtskompatibilität und für Setups beibehalten, die die Plugin-Reihenfolge kontrollieren müssen. Setzen Sie `routing.enableProxy: false`, um sich abzumelden. Siehe die [v9 Release Notes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/releases/v9.md).
+
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import { intlayer } from "vite-intlayer";

package/docs/de/intlayer_with_vite+vue.md

@@ -373,6 +373,13 @@ app.use(intlayer);
 app.mount("#app");
 ```
 
+> Sie können `installIntlayer(app)` auch direkt als Funktion aufrufen, wenn Sie das bevorzugen:
+>
+> ```javascript
+> import { intlayer } from "vue-intlayer";
+> app.use(intlayer);
+> ```
+
 Greifen Sie in Ihrer gesamten Anwendung auf Ihre Inhaltswörterbücher zu, indem Sie eine Haupt-Vue-Komponente erstellen und die `useIntlayer` Composables verwenden:
 
 ```vue fileName="src/HelloWord.vue"
@@ -426,6 +433,8 @@ const countRef = ref(0);
 </template>
 ```
 
+> Wenn Ihre App bereits existiert, können Sie den [Intlayer Compiler](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/compiler.md) sowie den [extract Befehl](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/cli/extract.md) verwenden, um tausende Komponenten in einer Sekunde zu transformieren.
+
 #### Zugriff auf Inhalte in Intlayer
 
 Intlayer bietet verschiedene APIs, um auf Ihre Inhalte zuzugreifen:
@@ -444,8 +453,6 @@ Intlayer bietet verschiedene APIs, um auf Ihre Inhalte zuzugreifen:
   - Verwenden Sie `const content = useIntlayer("myContent");` und `{{ content.myContent }}` / `<content.myContent />`.
   - Oder verwenden Sie `const { myContent } = useIntlayer("myContent");` und `{{ myContent }}` / `<myContent />`, um den Inhalt zu destrukturieren.
 
-> Wenn Ihre App bereits existiert, können Sie den [Intlayer Compiler](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/compiler.md) sowie den [Extraktionsbefehl](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/cli/extract.md) verwenden, um Tausende von Komponenten in einer Sekunde zu transformieren.
-
 </Step>
 
 <Step number={6} title="Ändern Sie die Sprache Ihres Inhalts" isOptional={true}>
@@ -633,6 +640,10 @@ import LocaleSwitcher from "@components/LocaleSwitcher.vue";
 
 Parallel dazu können Sie auch das `intlayerProxy` verwenden, um serverseitiges Routing zu Ihrer Anwendung hinzuzufügen. Dieses Plugin erkennt automatisch die aktuelle Locale basierend auf der URL und setzt das entsprechende Locale-Cookie. Wenn keine Locale angegeben ist, bestimmt das Plugin die am besten geeignete Locale basierend auf den Spracheinstellungen des Browsers des Benutzers. Wenn keine Locale erkannt wird, erfolgt eine Weiterleitung zur Standard-Locale.
 
+> Beachten Sie, dass Sie zum Verwenden von `intlayerProxy` in der Produktion das `vite-intlayer`-Paket von `devDependencies` zu `dependencies` wechseln müssen.
+
+> Seit Intlayer v9 ist `intlayerProxy()` direkt in das `intlayer()` Plugin integriert und standardmäßig über die Option `routing.enableProxy` aktiviert (`true` standardmäßig). Die separate Registrierung wie unten gezeigt ist jetzt optional — sie wird aus Gründen der Rückwärtskompatibilität und für Setups beibehalten, die die Plugin-Reihenfolge kontrollieren müssen. Setzen Sie `routing.enableProxy: false`, um abzuweichen. Siehe die [v9 Release Notes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/releases/v9.md).
+
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import vue from "@vitejs/plugin-vue";
@@ -1134,3 +1145,5 @@ Weitere Details zur Verwendung der Extension finden Sie in der [Intlayer VS Code
 ### Weiterführende Schritte
 
 Um weiterzugehen, können Sie den [visuellen Editor](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_visual_editor.md) implementieren oder Ihre Inhalte mit dem [CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_CMS.md) auslagern.
+
+I'm waiting for your content blocks.---

package/docs/de/live-sync.md

@@ -42,6 +42,45 @@ Live Sync ermöglicht es Ihrer App, CMS-Inhaltsänderungen zur Laufzeit widerzus
 
 ## Live-Synchronisation aktivieren
 
+Aktivieren Sie Live Sync, indem Sie Ihre Intlayer-Konfiguration aktualisieren:
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  // ... andere Konfigurationseinstellungen
+  editor: {
+    /**
+     * Aktiviert das Hot Reloading von Locale-Konfigurationen, wenn Änderungen erkannt werden.
+     * Wenn beispielsweise ein Dictionary hinzugefügt oder aktualisiert wird, aktualisiert die
+     * Anwendung den auf der Seite angezeigten Inhalt.
+     *
+     * Da Hot Reloading eine kontinuierliche Verbindung zum Server erfordert, ist es
+     * nur für Clients des `enterprise`-Plans verfügbar.
+     *
+     * Standard: false
+     */
+    liveSync: true,
+  },
+  dictionary: {
+    /**
+     * Steuert, wie Dictionaries importiert werden:
+     *
+     * - "fetch": Dictionaries werden dynamisch mithilfe der Live Sync API abgerufen.
+     *   Ersetzt useIntlayer mit useDictionaryDynamic.
+     *
+     * Hinweis: Der Live-Modus verwendet die Live Sync API zum Abrufen von Dictionaries. Wenn der API-Aufruf
+     * fehlschlägt, werden Dictionaries dynamisch importiert.
+     * Hinweis: Nur Dictionaries mit Remote-Inhalten und "live"-Flags verwenden den Live-Modus.
+     * Andere verwenden den Dynamic-Modus für bessere Leistung.
+     */
+    importMode: "fetch",
+  },
+};
+
+export default config;
+```
+
 > Live Sync erfordert eine kontinuierliche Serververbindung und ist im Enterprise-Plan verfügbar.
 
 Aktivieren Sie Live Sync, indem Sie Ihre Intlayer-Konfiguration aktualisieren:

package/docs/de/packages/elysia-intlayer/exports.md

@@ -0,0 +1,136 @@
+---
+createdAt: 2026-08-24
+updatedAt: 2026-08-24
+title: elysia-intlayer Paketdokumentation
+description: Elysia-Plugin für Intlayer, das Übersetzungsfunktionen und Locale-Erkennung bereitstellt.
+keywords:
+  - elysia-intlayer
+  - elysia
+  - plugin
+  - Internationalisierung
+  - i18n
+slugs:
+  - doc
+  - packages
+  - elysia-intlayer
+  - exports
+history:
+  - version: 9.4.0
+    date: 2026-08-24
+    changes: "Vereinheitlichte Dokumentation für alle Exporte"
+author: aymericzip
+---
+
+# elysia-intlayer Paket
+
+Das `elysia-intlayer`-Paket stellt ein Plugin für Elysia-Anwendungen bereit, um Internationalisierung zu unterstützen. Es erkennt die Locale des Benutzers und injiziert ein `intlayer`-Objekt in den Route-Kontext.
+
+## Installation
+
+```bash packageManager="npm"
+npm install intlayer elysia-intlayer
+```
+
+```bash packageManager="pnpm"
+pnpm add intlayer elysia-intlayer
+```
+
+```bash packageManager="yarn"
+yarn add intlayer elysia-intlayer
+```
+
+```bash packageManager="bun"
+bun add intlayer elysia-intlayer
+```
+
+> `elysia` ist eine Peer-Dependency (`>=1.0.0`). Elysia zielt auf die **Bun**-Runtime ab.
+
+## Exporte
+
+### Plugin
+
+Import:
+
+```ts
+import { intlayer } from "elysia-intlayer";
+```
+
+| Funktion   | Beschreibung                                                                                                                                                                                                                                                                                                                                 | Zugehörige Dokumentation                                                                                       |
+| ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
+| `intlayer` | Elysia-Plugin, das Intlayer in Ihre Elysia-Anwendung integriert. Übernimmt die Locale-Erkennung aus dem Storage (Cookies, Header) und anschließend aus `Accept-Language`, injiziert ein `intlayer`-Objekt mit `locale`, `t`, `getIntlayer` und `getDictionary` in den Route-Kontext und richtet den `AsyncLocalStorage`-Request-Kontext ein. | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/elysia-intlayer/intlayer.md) |
+
+### Funktionen
+
+Import:
+
+```ts
+import { t, getIntlayer, getDictionary } from "elysia-intlayer";
+```
+
+| Funktion        | Beschreibung                                                                                                                                                                                                                                                                                        | Zugehörige Dokumentation                                                                               |
+| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| `t`             | Globale Übersetzungsfunktion, die den Inhalt für die aktuelle Locale in Elysia abruft. Verwendet `AsyncLocalStorage`, um auf den vom `intlayer`-Plugin eingerichteten Request-Kontext zuzugreifen, und greift außerhalb davon auf die Standard-Locale zurück. Auch über `intlayer.t` erreichbar.    | [translation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/translation.md) |
+| `getIntlayer`   | Ruft ein Wörterbuch anhand seines Schlüssels aus der generierten Deklaration ab und gibt dessen Inhalt für die aktuelle Locale zurück. Optimierte Variante von `getDictionary`. Verwendet `AsyncLocalStorage`, um auf den Request-Kontext zuzugreifen. Auch über `intlayer.getIntlayer` erreichbar. | -                                                                                                      |
+| `getDictionary` | Verarbeitet Wörterbuchobjekte und gibt den Inhalt für die aktuelle Locale zurück. Verarbeitet `t()`-Übersetzungen, Enumerationen, Markdown, HTML usw. Verwendet `AsyncLocalStorage`, um auf den Request-Kontext zuzugreifen. Auch über `intlayer.getDictionary` erreichbar.                         | -                                                                                                      |
+
+### Typen
+
+Import:
+
+```ts
+import type { IntlayerContext, TranslateFunction } from "elysia-intlayer";
+```
+
+| Typ                 | Beschreibung                                                                                                                                                                 |
+| ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `IntlayerContext`   | Form des `intlayer`-Objekts, das in jeden Route-Kontext injiziert wird: `locale`, `locale_storage`, `locale_detected`, `defaultLocale`, `t`, `getIntlayer`, `getDictionary`. |
+| `TranslateFunction` | Signatur der Übersetzungsfunktion, die eine Locale-Map in den Inhalt der aktuellen Request-Locale übersetzt.                                                                 |
+
+## Verwendung
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { getDictionary, getIntlayer, intlayer, t } from "elysia-intlayer";
+import dictionaryExample from "./index.content";
+
+const app = new Elysia()
+  // Laden Sie das Internationalisierungs-Plugin
+  .use(intlayer())
+  // Locale und Helper aus dem Route-Context lesen
+  .get("/", ({ intlayer }) => ({
+    locale: intlayer!.locale,
+    greeting: intlayer!.t({
+      de: "Hallo",
+      en: "Hello",
+      fr: "Bonjour",
+      es: "Hola",
+    }),
+    content: intlayer!.getIntlayer("index").exampleOfContent,
+  }))
+  // Oder die Standalone-Helper verwenden, die an die aktuelle Anfrage gebunden sind
+  .get("/t_example", () =>
+    t({
+      de: "Beispiel für zurückgegebene Inhalte auf Deutsch",
+      en: "Example of returned content in English",
+      fr: "Exemple de contenu renvoyé en français",
+      es: "Ejemplo de contenido devuelto en español",
+    })
+  )
+  .get("/getIntlayer_example", () => getIntlayer("index").exampleOfContent)
+  .get(
+    "/getDictionary_example",
+    () => getDictionary(dictionaryExample).exampleOfContent
+  )
+  .listen(3000);
+
+console.log(
+  `🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`
+);
+```
+
+> Das Plugin registriert seinen Context über ein **globales** `derive`, das Elysia als `Partial<{ intlayer: IntlayerContext }>` typisiert. Zur Laufzeit ist der Wert für alle nach `.use(intlayer())` registrierten Routen immer vorhanden — verwenden Sie daher die Non-Null-Assertion (`intlayer!.locale`) oder Optional Chaining, um TypeScript im `strict`-Modus zufriedenzustellen.
+
+## Zugehörige Dokumentation
+
+- [Elysia i18n - Vollständiger Leitfaden zum Übersetzen deiner App](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_with_elysia.md)
+- [Konfiguration](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/configuration.md)

package/docs/de/packages/elysia-intlayer/intlayer.md

@@ -0,0 +1,139 @@
+---
+createdAt: 2026-08-24
+updatedAt: 2026-08-24
+title: intlayer Elysia Plugin Dokumentation | elysia-intlayer
+description: Erfahren Sie, wie Sie das intlayer-Plugin des elysia-intlayer-Pakets verwenden
+keywords:
+  - intlayer
+  - elysia
+  - plugin
+  - Intlayer
+  - Internationalisierung
+  - Dokumentation
+slugs:
+  - doc
+  - packages
+  - elysia-intlayer
+  - intlayer
+history:
+  - version: 9.4.0
+    date: 2026-08-24
+    changes: "Initialisierung der Dokumentation"
+author: aymericzip
+---
+
+# intlayer Elysia Plugin Dokumentation
+
+Das `intlayer`-Plugin für Elysia ermittelt die Locale des Benutzers und injiziert ein `intlayer`-Objekt in den Route-Kontext. Es ermöglicht außerdem die Verwendung globaler Übersetzungsfunktionen innerhalb des Request-Kontexts.
+
+## Verwendung
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { intlayer } from "elysia-intlayer";
+
+const app = new Elysia().use(intlayer()).get("/", ({ intlayer }) =>
+  intlayer!.t({
+    de: "Hallo",
+    en: "Hello",
+    fr: "Bonjour",
+    es: "Hola",
+  })
+);
+```
+
+> Das Plugin registriert seinen Context über ein **globales** `derive`, das Elysia als `Partial<{ intlayer: IntlayerContext }>` typisiert. Zur Laufzeit ist der Wert für alle nach `.use(intlayer())` registrierten Routen immer vorhanden — verwenden Sie daher die Non-Null-Assertion (`intlayer!.t`) oder Optional Chaining, um TypeScript im `strict`-Modus zufriedenzustellen.
+
+Dieselben Helper stehen auch als eigenständige Exporte zur Verfügung, sodass Sie sie aufrufen können, ohne den Route-Kontext zu destrukturieren:
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { intlayer, t } from "elysia-intlayer";
+
+const app = new Elysia().use(intlayer()).get("/", () =>
+  t({
+    de: "Hallo",
+    en: "Hello",
+    fr: "Bonjour",
+    es: "Hola",
+  })
+);
+```
+
+## Beschreibung
+
+Das Plugin führt die folgenden Aufgaben aus:
+
+1. **Locale-Erkennung**: Es liest die vom Client explizit gesetzte Locale aus dem Storage (Cookie, Header) und greift anschließend auf die aus dem `Accept-Language`-Header ausgehandelte Locale zurück.
+2. **Kontext-Injektion**: Es fügt dem Elysia-Route-Context eine `intlayer`-Eigenschaft hinzu (siehe die Tabelle Route-Context weiter unten).
+3. **Kontextverwaltung**: Es verwendet `AsyncLocalStorage`, um einen asynchronen Kontext zu verwalten, wodurch die globalen Intlayer-Funktionen (`t`, `getIntlayer`, `getDictionary`) auf die anfragebezogene Locale zugreifen können, ohne das Kontextobjekt weiterreichen zu müssen.
+4. **Vorbereitung der Dictionaries**: Es ruft `prepareIntlayer` beim Erstellen des Plugins auf, sodass die Dictionaries beim Start der Anwendung gebaut werden.
+
+### Route-Context
+
+| Eigenschaft       | Typ                    | Beschreibung                                                                                           |
+| ----------------- | ---------------------- | ------------------------------------------------------------------------------------------------------ |
+| `locale`          | `Locale`               | Die für diese Anfrage zu verwendende Locale, wobei `locale_storage` Vorrang vor `locale_detected` hat. |
+| `locale_storage`  | `Locale` (optional)    | Die vom Client über ein Cookie oder einen Header explizit angeforderte Locale.                         |
+| `locale_detected` | `Locale`               | Die aus den Request-Headern ausgehandelte Locale.                                                      |
+| `defaultLocale`   | `Locale`               | Die in `intlayer.config.ts` als Fallback konfigurierte Locale.                                         |
+| `t`               | `TranslateFunction`    | Eine Übersetzungsfunktion.                                                                             |
+| `getIntlayer`     | `typeof getIntlayer`   | Eine Funktion zum Abrufen von Wörterbüchern anhand ihres Schlüssels.                                   |
+| `getDictionary`   | `typeof getDictionary` | Eine Funktion zum Verarbeiten von Wörterbuchobjekten.                                                  |
+
+> Anders als die Node-basierten Intlayer-Plugins setzt `elysia-intlayer` auf `AsyncLocalStorage` statt auf `cls-hooked`, da `cls-hooked` von `async_hooks.createHook` abhängt, das Bun nicht implementiert.
+
+Der Request-Kontext wird freigegeben, sobald die Response gemappt wurde, sodass die eigenständigen Helper niemals gegen eine bereits beendete Anfrage auflösen. Werden sie außerhalb einer vom Plugin behandelten Anfrage aufgerufen, greifen sie auf die konfigurierte Standard-Locale zurück.
+
+## Reihenfolge der Locale-Auflösung
+
+Standardmäßig löst das Plugin die Locale in dieser Reihenfolge auf:
+
+1. Das Cookie `INTLAYER_LOCALE`.
+2. Der Header `x-intlayer-locale`.
+3. Die Aushandlung über den `Accept-Language`-Header.
+4. Die konfigurierte `defaultLocale`.
+
+```bash
+# Aus `Accept-Language` ausgehandelt
+curl -H "Accept-Language: fr" http://localhost:3000/
+# Bonjour
+
+# Das Cookie hat Vorrang vor `Accept-Language`
+curl -H "Accept-Language: fr" -H "Cookie: INTLAYER_LOCALE=es" http://localhost:3000/
+# Hola
+
+# Der Header hat Vorrang vor `Accept-Language`
+curl -H "Accept-Language: fr" -H "x-intlayer-locale: es" http://localhost:3000/
+# Hola
+```
+
+## Konfiguration
+
+Das Plugin liest Ihre `intlayer.config.ts`-Datei. Sie können das Cookie und den Header anpassen, die für die Locale-Erkennung verwendet werden:
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  routing: {
+    storage: [
+      { type: "header", name: "my-locale-header" },
+      { type: "cookie", name: "my-locale-cookie" },
+    ],
+  },
+};
+
+export default config;
+```
+
+> Weitere Informationen zur Konfiguration finden Sie in der [Konfigurationsdokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/configuration.md).
+
+## Zugehörige Dokumentation
+
+- [elysia-intlayer Paketdokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/elysia-intlayer/exports.md)
+- [Elysia i18n - Vollständiger Leitfaden zum Übersetzen deiner App](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_with_elysia.md)