@intlayer/docs 9.5.6 → 9.5.8

package/docs/en/cli/infra.md

@@ -0,0 +1,175 @@
+---
+createdAt: 2026-09-21
+updatedAt: 2026-09-21
+title: CLI - Init Infra
+description: Learn how to use the Intlayer CLI init infra command to install the desktop app or self-host the Intlayer CMS with Docker (all-in-one container or Docker Compose stack).
+keywords:
+  - CLI
+  - Infrastructure
+  - Self-hosting
+  - Desktop app
+  - Docker
+  - Docker Compose
+  - CMS
+  - Intlayer
+slugs:
+  - doc
+  - concept
+  - cli
+  - infra
+history:
+  - version: 9.5.6
+    date: 2026-09-21
+    changes: "Add init infra command"
+author: aymericzip
+---
+
+# Intlayer CLI Init Infra Command
+
+## Description
+
+The `init infra` command sets up the Intlayer infrastructure on your machine. It downloads the hosted installer for your platform (`https://intlayer.org/install.sh` on macOS / Linux, `https://intlayer.org/install.ps1` on Windows) and runs it with your terminal attached, so the installer's own menu and progress output reach you unchanged.
+
+The installer asks how you want to run Intlayer:
+
+- **Desktop app**: downloads the native dashboard for your OS and CPU and opens or installs it. The desktop build talks to the Intlayer Cloud backend.
+- **All-in-one Docker**: dashboard + API + MongoDB + Redis + MinIO in a single container backed by one volume. Writes `./intlayer.env` with the secrets generated and pulls the `intlayer/cms-all` image.
+- **Docker Compose**: one container per service, for scalable self-hosting. Writes `docker-compose.yml` and `.env` into `./intlayer/` and pulls the images.
+
+The hosted installer is the single source of truth for the setup flow: the CLI runs it rather than re-implementing the same steps, so `npx intlayer init infra` and `curl -fsSL https://intlayer.org/install.sh | sh` do exactly the same thing.
+
+## Usage
+
+```bash packageManager="npm"
+npx intlayer init infra [options]
+```
+
+```bash packageManager="yarn"
+yarn intlayer init infra [options]
+```
+
+```bash packageManager="pnpm"
+pnpm intlayer init infra [options]
+```
+
+```bash packageManager="bun"
+bun x intlayer init infra [options]
+```
+
+The same step is offered from the checklist of `npx intlayer init --interactive`, under **Infrastructure (desktop app / self-hosting)**.
+
+## Options
+
+- `-m, --mode <mode>` - Optional. Skip the installer's menu and run one mode directly. Accepted values: `desktop`, `docker` (all-in-one) or `compose`. Any other value exits with an error listing the accepted modes.
+
+## Examples
+
+### Pick the mode interactively
+
+```bash
+npx intlayer init infra
+```
+
+### Install the desktop app
+
+```bash
+npx intlayer init infra --mode desktop
+```
+
+### Self-host with the all-in-one container
+
+```bash
+npx intlayer init infra --mode docker
+```
+
+### Self-host with Docker Compose
+
+```bash
+npx intlayer init infra --mode compose
+```
+
+## Example output
+
+```bash
+npx intlayer init infra --mode compose
+◇  Installer downloaded
+▸ Fetching docker-compose.yml into ./intlayer
+▸ Writing ./intlayer/.env
+
+  Let's fill in .env. Press Enter to accept a suggestion;
+  every value can be changed later in the file.
+
+? Domain Intlayer will be served on (empty = localhost only):
+
+  How should Intlayer send emails? The first account cannot be verified
+  without a working mailer.
+
+    1) Resend            API key from resend.com
+    2) SMTP relay        Your own SMTP server
+    3) Later             Fill in the file by hand before starting
+
+? Choice [1-3]: 1
+? Resend API key:
+? Sender address [Intlayer <no-reply@example.com>]:
+? OpenAI API key, enables AI translation (empty = skip):
+▸ Pulling images
+
+  Everything is installed.
+
+  1. Start the stack:
+
+       cd ./intlayer && docker compose up -d
+
+  Then open http://localhost:3000
+  First boot initialises the datastores, so give it a minute. The first
+  account you create becomes the super admin.
+
+    Logs      docker compose logs -f
+    Stop      docker compose down
+    Upgrade   docker compose pull && docker compose up -d
+```
+
+Given a domain (for instance `example.org`), the installer suggests `https://cms.example.org`, `https://back.example.org` and `https://s3.example.org/intlayer` for the dashboard, the API and the object storage, writes them to the environment file, and switches the start command to a build from the repository, since the published dashboard image only works on `localhost`. See [Custom domain](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/self_hosting.md#custom-domain).
+
+## Installer settings
+
+The installer reads a few environment variables, which the CLI passes through untouched. Set them in your shell before running the command:
+
+```bash
+INTLAYER_COMPOSE_DIR=./cms npx intlayer init infra --mode compose
+```
+
+| Variable                  | Default                   | Applies to | Description                                                |
+| ------------------------- | ------------------------- | ---------- | ---------------------------------------------------------- |
+| `INTLAYER_MODE`           | _(asked)_                 | all        | `desktop`, `docker` or `compose`, same as `--mode`         |
+| `INTLAYER_DOWNLOAD_DIR`   | `~/Downloads`             | desktop    | Where the app installer is saved                           |
+| `INTLAYER_IMAGE`          | `intlayer/cms-all:latest` | docker     | All-in-one image to pull                                   |
+| `INTLAYER_ENV_FILE`       | `./intlayer.env`          | docker     | Where to write the environment file                        |
+| `INTLAYER_CONTAINER_NAME` | `intlayer`                | docker     | Container name                                             |
+| `INTLAYER_DATA_VOLUME`    | `intlayer-data`           | docker     | Named volume mounted at `/data`                            |
+| `INTLAYER_APP_PORT`       | `3000`                    | docker     | Host port for the dashboard                                |
+| `INTLAYER_API_PORT`       | `3100`                    | docker     | Host port for the API                                      |
+| `INTLAYER_S3_PORT`        | `9000`                    | docker     | Host port for the MinIO S3 API                             |
+| `INTLAYER_CONSOLE_PORT`   | `9001`                    | docker     | Host port for the MinIO console                            |
+| `INTLAYER_COMPOSE_DIR`    | `./intlayer`              | compose    | Where `docker-compose.yml` and `.env` are written          |
+| `INTLAYER_SELFHOST_REF`   | `main`                    | both       | Git ref the compose file and env template are fetched from |
+
+> The port variables only change the **host** side of the mapping. The published images have `http://localhost:3000`, `http://localhost:3100` and `http://localhost:9000` compiled into the dashboard bundle, so keep the defaults unless you build your own images: see the [self-hosting guide](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/self_hosting.md#limitations).
+
+## Requirements
+
+- **Desktop app** needs [Node.js](https://nodejs.org): the app embeds the dashboard's server and starts it with the machine's own `node` binary.
+- **Docker modes** need [Docker](https://docs.docker.com/get-docker/) (Docker Desktop with the WSL 2 backend on Windows). The Compose mode also needs the `docker compose` plugin.
+
+## Notes
+
+- Re-running the command is safe: an existing environment file is never overwritten, so it doubles as the upgrade path (the installer pulls the latest images and keeps your secrets).
+- The installer is downloaded to a temporary directory and deleted once it exits, whatever the outcome.
+- The command's exit code is the installer's. If the download itself fails, the CLI prints the equivalent `curl … | sh` (or `irm … | iex`) command so you can run the installer directly.
+- The Docker modes need a mailer to send sign-in emails. The installer asks for one; if you skip the question (or run without a terminal, where the questions are skipped altogether), configure Resend or SMTP in the generated environment file: see [Global mailer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/self_hosting.md#global-mailer).
+
+## Related
+
+- [Self-hosting guide](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/self_hosting.md) - Architecture, first-run steps and limitations of each mode
+- [Initialize Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/cli/init.md) - The parent `init` command and its interactive checklist
+- [Intlayer CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/intlayer_CMS.md) - What the dashboard you just installed does

package/docs/en/cli/init.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-12-30
-updatedAt: 2025-12-30
+updatedAt: 2026-09-21
 title: Initialize Intlayer
 description: Learn how to initialize Intlayer in your project.
 keywords:
@@ -14,6 +14,9 @@ slugs:
   - cli
   - init
 history:
+  - version: 9.5.6
+    date: 2026-09-21
+    changes: "Add init infra sub-command"
   - version: 8.6.4
     date: 2026-03-31
     changes: "Add --no-gitignore option"
@@ -51,6 +54,7 @@ The `init` command automatically sets up Intlayer in your project by configuring
 
 - `--project-root [projectRoot]` - Optional. Specify the project root directory. If not provided, the command will search for the project root starting from the current working directory.
 - `--no-gitignore` - Optional. Skip the automatic update of the `.gitignore` file. If this flag is set, `.intlayer` will not be added to `.gitignore`.
+- `-i, --interactive` - Optional. Pick the setup steps from a checklist (packages, CI, skills, MCP, compiler, infrastructure, …) instead of running the default set.
 
 ## What it does:
 
@@ -125,6 +129,26 @@ bun x intlayer init --no-gitignore
 
 This will set up all configuration files but will not modify your `.gitignore`.
 
+### Set up the infrastructure (desktop app or self-hosting):
+
+```bash
+npx intlayer init infra
+```
+
+Downloads and runs the hosted installer (`https://intlayer.org/install.sh`, or `install.ps1` on Windows), which asks how you want to run Intlayer:
+
+- **Desktop app** — installs the native dashboard on your machine, connected to the Intlayer Cloud.
+- **All-in-one Docker** — dashboard + API + MongoDB + Redis + MinIO in a single container.
+- **Docker Compose** — one container per service, for scalable self-hosting.
+
+Skip the menu with `--mode`:
+
+```bash
+npx intlayer init infra --mode compose
+```
+
+The same step is offered by `npx intlayer init --interactive`. See the [`init infra` reference](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/cli/infra.md) for the installer settings, and the [self-hosting guide](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/self_hosting.md) for what each mode sets up.
+
 ## Example output:
 
 ```bash

package/docs/en/cli/upgrade.md

@@ -0,0 +1,125 @@
+---
+createdAt: 2026-09-23
+updatedAt: 2026-09-23
+title: CLI - Upgrade Intlayer packages
+description: Learn how to use the Intlayer CLI upgrade command to list every Intlayer package of your project or monorepo and upgrade them to the latest version.
+keywords:
+  - CLI
+  - Upgrade
+  - Update
+  - Packages
+  - Monorepo
+  - Intlayer
+slugs:
+  - doc
+  - concept
+  - cli
+  - upgrade
+history:
+  - version: 9.5.8
+    date: 2026-09-23
+    changes: "Add upgrade command"
+author: aymericzip
+---
+
+# Upgrade Intlayer Packages
+
+```bash packageManager="npm"
+npx intlayer upgrade
+```
+
+```bash packageManager="yarn"
+yarn intlayer upgrade
+```
+
+```bash packageManager="pnpm"
+pnpm intlayer upgrade
+```
+
+```bash packageManager="bun"
+bun x intlayer upgrade
+```
+
+The `upgrade` command lists the Intlayer packages declared in every `package.json` of your project, including monorepo workspaces, and upgrades them to the latest published version. It runs the same package upgrade step as `intlayer init`, on its own.
+
+## Arguments:
+
+- `--project-root [projectRoot]` - Optional. The project root directory. By default, the command starts from the nearest `package.json` above the current working directory.
+- `--dry-run` - Optional. Lists the packages and their target version without modifying any file.
+- `--tag <tag>` - Optional. The npm dist-tag to upgrade to (for example `canary`). Defaults to `latest`.
+
+## What it does:
+
+1. **Lists the Intlayer packages** - Scans every `package.json` of the project (skipping `node_modules` and build outputs) for `intlayer`, `@intlayer/*`, `*-intlayer` and `intlayer-*` dependencies and dev dependencies.
+2. **Fetches the target version** - Reads the version of the selected dist-tag (`latest` by default) of each package from the npm registry.
+3. **Rewrites the ranges** - Updates each outdated range in place, keeping its operator (`^`, `~` or none) and the file indentation.
+4. **Installs once** - Runs a single install from the workspace root (the nearest directory with a lock file), using the package manager that owns the lock file:
+
+| Lock file                      | Command        |
+| ------------------------------ | -------------- |
+| `bun.lock` / `bun.lockb`       | `bun install`  |
+| `pnpm-lock.yaml`               | `pnpm install` |
+| `yarn.lock`                    | `yarn install` |
+| `package-lock.json` or no lock | `npm install`  |
+
+If there is no lock file, the `packageManager` field of `package.json` (for example `"bun@1.2.0"`) is used before falling back to npm.
+
+Ranges that do not point to the registry, such as `workspace:*`, `file:`, `link:`, `catalog:` or git URLs, are never modified.
+
+## Examples:
+
+### List the available upgrades without applying them:
+
+```bash packageManager="npm"
+npx intlayer upgrade --dry-run
+```
+
+```bash packageManager="yarn"
+yarn intlayer upgrade --dry-run
+```
+
+```bash packageManager="pnpm"
+pnpm intlayer upgrade --dry-run
+```
+
+```bash packageManager="bun"
+bun x intlayer upgrade --dry-run
+```
+
+### Upgrade to the canary release:
+
+```bash packageManager="npm"
+npx intlayer upgrade --tag canary
+```
+
+```bash packageManager="yarn"
+yarn intlayer upgrade --tag canary
+```
+
+```bash packageManager="pnpm"
+pnpm intlayer upgrade --tag canary
+```
+
+```bash packageManager="bun"
+bun x intlayer upgrade --tag canary
+```
+
+## Example output:
+
+```bash
+npx intlayer upgrade
+Intlayer packages:
+  package.json
+    intlayer ^9.0.0 → ^9.5.7
+  apps/web/package.json
+    next-intlayer ^9.5.7 (latest)
+    vite-intlayer ~9.2.0 → ~9.5.7
+Running bun install...
+✓ Upgraded 2 Intlayer dependencies to latest
+```
+
+## Notes:
+
+- Run the command from the root of your repository to upgrade every workspace. Run it from a workspace to upgrade that workspace only.
+- Packages whose version cannot be fetched (offline, private or unpublished package) are listed and left unchanged.
+- If the install fails, the upgraded ranges are kept in `package.json`. Run your package manager's install command manually.

package/docs/en/dictionary/html.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-01-20
-updatedAt: 2026-03-24
+updatedAt: 2026-09-21
 title: HTML Content
 description: Learn how to declare and use HTML content with custom components in Intlayer. Follow this documentation to embed rich HTML-like content with dynamic component replacement in your internationalized project.
 keywords:
@@ -13,6 +13,8 @@ keywords:
   - React
   - Vue
   - Svelte
+  - Remix
+  - Astro
 slugs:
   - doc
   - concept
@@ -235,6 +237,83 @@ When you access content via `useIntlayer`, HTML nodes are already prepared for r
     ```
 
   </Tab>
+  <Tab label="Remix" value="remix">
+    In Remix 3, HTML nodes resolve to an HTML string. Inject it with the `innerHTML` prop of Remix JSX, or with `html.raw` in an `html-template` view.
+
+    ```tsx fileName="src/views/home.tsx"
+    import { useIntlayer } from "remix-intlayer";
+
+    export const HomePage = () => () => {
+      const { myHtmlContent } = useIntlayer("app");
+
+      return <div innerHTML={myHtmlContent.value} />;
+    };
+    ```
+
+    ```ts fileName="src/views/home.ts"
+    import { html } from "remix/html-template";
+    import { useIntlayer } from "remix-intlayer";
+
+    export const renderHomePage = () => {
+      const { myHtmlContent } = useIntlayer("app");
+
+      return html.raw`<div>${myHtmlContent.value}</div>`;
+    };
+    ```
+
+    > Remix escapes interpolated values by default. `innerHTML` and `html.raw` are the two opt-outs, which is what an HTML string needs.
+
+    Use the `.use()` method to override tags or map custom components. Overrides are functions returning an HTML string:
+
+    ```tsx
+    <div
+      innerHTML={myHtmlContent.use({
+        p: ({ children }) => `<p class="prose">${children}</p>`,
+        CustomLink: ({ children }) => `<a href="/details">${children}</a>`,
+      })}
+    />
+    ```
+
+  </Tab>
+  <Tab label="Astro" value="astro">
+    In Astro, HTML nodes resolve to an HTML string. Inject it with the `set:html` directive in the template, or with `innerHTML` in a client `<script>`.
+
+    ```astro fileName="src/pages/index.astro"
+    ---
+    import { useIntlayer } from "astro-intlayer";
+
+    const { myHtmlContent } = useIntlayer("app");
+    ---
+
+    <div set:html={myHtmlContent.value} />
+    ```
+
+    ```astro fileName="src/components/Content.astro"
+    <div id="content"></div>
+
+    <script>
+      import { useIntlayer } from "astro-intlayer";
+
+      const { myHtmlContent } = useIntlayer("app");
+
+      document.querySelector("#content")!.innerHTML = myHtmlContent.value;
+    </script>
+    ```
+
+    > Astro escapes `{expressions}` by default. `set:html` is the opt-out, which is what an HTML string needs.
+
+    Use the `.use()` method to override tags or map custom components. Overrides are functions returning an HTML string:
+
+    ```astro
+    <div
+      set:html={myHtmlContent.use({
+        p: ({ children }) => `<p class="prose">${children}</p>`,
+        CustomLink: ({ children }) => `<a href="/details">${children}</a>`,
+      })}
+    />
+    ```
+
+  </Tab>
 </Tabs>
 
 ## Global Configuration with `HTMLProvider`
@@ -470,6 +549,41 @@ You can configure HTML rendering globally for your entire application. This is i
     > Importing your HTML renderer dynamically is a good way to reduce the bundle size of your application.
 
   </Tab>
+  <Tab label="Remix" value="remix">
+
+    Remix has no component tree to hold a provider, so the configuration is installed once, as a singleton, at server start. It configures the renderer returned by `useHTMLRenderer()`. The `html` nodes returned by `useIntlayer` are rendered as-is; override their tags per node with `.use()`.
+
+    ```typescript fileName="src/router.ts"
+    import { installIntlayerHTML } from "remix-intlayer/html";
+
+    installIntlayerHTML({
+      renderHTML: (html) => html.replaceAll("<p>", '<p class="prose">'),
+    });
+    ```
+
+    > Use `installIntlayerHTMLDynamic(async () => …)` to load the renderer itself lazily; the loader runs on the first call only.
+
+  </Tab>
+  <Tab label="Astro" value="astro">
+
+    Astro has no component tree to hold a provider, so the configuration is installed once, as a singleton, in the middleware (server) and in a client `<script>` (browser). It configures the renderer returned by `useHTMLRenderer()`. The `html` nodes returned by `useIntlayer` are rendered as-is; override their tags per node with `.use()`.
+
+    ```typescript fileName="src/middleware.ts"
+    import { installIntlayerHTML } from "astro-intlayer/html";
+    import { defineMiddleware } from "astro:middleware";
+
+    // Runs once when the server starts; the Intlayer middleware itself is
+    // registered by the integration, ahead of this file.
+    installIntlayerHTML({
+      renderHTML: (html) => html.replaceAll("<p>", '<p class="prose">'),
+    });
+
+    export const onRequest = defineMiddleware((_context, next) => next());
+    ```
+
+    > Use `installIntlayerHTMLDynamic(async () => …)` to load the renderer itself lazily; the loader runs on the first call only.
+
+  </Tab>
 </Tabs>
 
 ### Manual Rendering & Advanced Tools
@@ -642,15 +756,69 @@ If you need to render raw HTML strings or have more control over the component m
     ```
 
   </Tab>
+  <Tab label="Remix" value="remix">
+    #### `useHTMLRenderer()` Hook
+
+    Get a renderer function pre-configured by `installIntlayerHTML()`. It returns an HTML string.
+
+    ```tsx
+    import { useHTMLRenderer } from "remix-intlayer/html";
+
+    const renderHTML = useHTMLRenderer();
+
+    return <div innerHTML={renderHTML("<p>Hello <strong>World</strong></p>")} />;
+    ```
+
+    #### `renderHTML()` Utility
+
+    Standalone utility that ignores the global configuration.
+
+    ```tsx
+    import { renderHTML } from "remix-intlayer/html";
+
+    const html = renderHTML("<p>Hello</p>");
+    ```
+
+  </Tab>
+  <Tab label="Astro" value="astro">
+    #### `useHTMLRenderer()` Hook
+
+    Get a renderer function pre-configured by `installIntlayerHTML()`. It returns an HTML string.
+
+    ```astro
+    ---
+    import { useHTMLRenderer } from "astro-intlayer/html";
+
+    const renderHTML = useHTMLRenderer();
+    ---
+
+    <div set:html={renderHTML("<p>Hello <strong>World</strong></p>")} />
+    ```
+
+    #### `renderHTML()` Utility
+
+    Standalone utility that ignores the global configuration.
+
+    ```astro
+    ---
+    import { renderHTML } from "astro-intlayer/html";
+
+    const html = renderHTML("<p>Hello</p>");
+    ---
+
+    <div set:html={html} />
+    ```
+
+  </Tab>
 </Tabs>
 
 ## Options Reference
 
 These options can be passed to `HTMLProvider`, `HTMLRenderer`, `useHTMLRenderer`, and `renderHTML`.
 
-| Option       | Type                  | Default | Description                                                                                                |
-| :----------- | :-------------------- | :------ | :--------------------------------------------------------------------------------------------------------- |
-| `components` | `Record<string, any>` | `{}`    | A map of HTML tags or custom component names to components.                                                |
-| `renderHTML` | `Function`            | `null`  | A custom rendering function to completely replace the default HTML parser (Only for Vue/Svelte providers). |
+| Option       | Type                  | Default | Description                                                                                                         |
+| :----------- | :-------------------- | :------ | :------------------------------------------------------------------------------------------------------------------ |
+| `components` | `Record<string, any>` | `{}`    | A map of HTML tags or custom component names to components.                                                         |
+| `renderHTML` | `Function`            | `null`  | A custom rendering function to completely replace the default HTML parser (Vue, Svelte, Remix and Astro providers). |
 
 > Note: For React and Preact, standard HTML tags are automatically provided. You only need to pass the `components` prop if you want to override them or add custom components.