@intlayer/docs 9.0.0-canary.6 → 9.0.0-canary.8

package/docs/en/packages/@intlayer_babel/export.md

@@ -0,0 +1,131 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: "@intlayer/babel Package Documentation"
+description: Babel plugins for Intlayer to handle content extraction, import optimization, pruning of unused fields, and mangling of field names during build.
+keywords:
+  - "@intlayer/babel"
+  - babel
+  - plugin
+  - internationalization
+  - i18n
+  - compiler
+  - optimize
+  - purge
+  - minify
+slugs:
+  - doc
+  - packages
+  - "@intlayer/babel"
+  - export
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Unified documentation of all exports"
+author: aymericzip
+---
+
+# @intlayer/babel Package
+
+The `@intlayer/babel` package provides a set of specialized Babel plugins for Intlayer. These plugins cover the entire build cycle: extracting content declarations, rewriting `useIntlayer` / `getIntlayer` calls to optimized dictionary imports, pruning unused fields, and minifying field names.
+
+## Installation
+
+```bash
+npm install @intlayer/babel
+```
+
+## Exports
+
+Import:
+
+```ts
+import { ... } from "@intlayer/babel";
+```
+
+---
+
+### Plugins
+
+| Function / Class               | Description                                                                                                                                                                                 |
+| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `intlayerExtractBabelPlugin`   | Babel plugin that extracts translatable content from source files and injects `useIntlayer` / `getIntlayer` hooks automatically. Designed for use with Next.js and Babel-based build tools. |
+| `intlayerOptimizeBabelPlugin`  | Babel plugin that transforms `useIntlayer` and `getIntlayer` calls and rewrites their imports to optimized JSON dictionary imports (static, dynamic, or via fetch).                         |
+| `intlayerPurgeBabelPlugin`     | Babel plugin that analyses source files and rewrites compiled dictionary JSON files to remove unused fields (`build.purge`) or rename them to short aliases (`build.minify`).               |
+| `intlayerMinifyBabelPlugin`    | Babel plugin that rewrites source files to use the short field aliases assigned during the minification phase (e.g. `content.title` ← `content.a`). Relies on `intlayerPurgeBabelPlugin`.   |
+| `makeFieldRenameBabelPlugin`   | Factory function that produces a Babel plugin to rename dictionary content field accesses in source files according to the `dictionaryKeyToFieldRenameMap` populated in the `PruneContext`. |
+| `makeUsageAnalyzerBabelPlugin` | Factory function that produces a Babel plugin to analyze the usage of `useIntlayer` / `getIntlayer` in the source code and aggregate field usage data in the shared `PruneContext`.         |
+| `getSharedPruneContext`        | Helper function that returns the shared `PruneContext` object for the specified base directory, or `null` if it has not been initialized yet.                                               |
+
+---
+
+### Plugin Configuration Utilities
+
+| Function                   | Description                                                                                                                                       |
+| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `getExtractPluginOptions`  | Loads the Intlayer configuration and returns `ExtractPluginOptions` ready for use with `intlayerExtractBabelPlugin`.                              |
+| `getOptimizePluginOptions` | Loads the Intlayer configuration and compiled dictionaries, and returns `OptimizePluginOptions` ready for use with `intlayerOptimizeBabelPlugin`. |
+| `getPurgePluginOptions`    | Loads the Intlayer configuration and returns `PurgePluginOptions` ready for use with `intlayerPurgeBabelPlugin`.                                  |
+| `getMinifyPluginOptions`   | Loads the Intlayer configuration and returns `MinifyPluginOptions` ready for use with `intlayerMinifyBabelPlugin`.                                |
+
+---
+
+### Types
+
+| Type                    | Description                                                                                                     |
+| ----------------------- | --------------------------------------------------------------------------------------------------------------- |
+| `CompilerMode`          | Compiler mode: `'dev'` for development with HMR support, or `'build'` for production builds.                    |
+| `ExtractPluginOptions`  | Options for `intlayerExtractBabelPlugin`: files list, configuration, `onExtract` callback, etc.                 |
+| `ExtractResult`         | Extraction result: dictionary key, file path, content, and locale.                                              |
+| `OptimizePluginOptions` | Options for `intlayerOptimizeBabelPlugin`: dictionary paths, import mode, mode map per dictionary, etc.         |
+| `PurgePluginOptions`    | Options for `intlayerPurgeBabelPlugin`: base directory, purge/minify/optimize flags, component files list.      |
+| `MinifyPluginOptions`   | Options for `intlayerMinifyBabelPlugin`: base directory, minify/optimize/editorEnabled flags.                   |
+| `PruneContext`          | Shared state between analysis and pruning plugins: field usage maps, rename maps, etc.                          |
+| `DictionaryFieldUsage`  | Field usage result for a single dictionary: `Set<string>` or `'all'` when static analysis is inconclusive.      |
+| `NestedRenameEntry`     | Node in the rename tree: the shortName and the children map.                                                    |
+| `NestedRenameMap`       | One level in the rename tree: `Map<string, NestedRenameEntry>`.                                                 |
+| `CompatCallerConfig`    | Configuration for a compatible usage analyzer for compat-adapter packages (caller name and processing options). |
+| `ScriptBlock`           | Script block extracted from a SFC file (Vue or Svelte): content, start offset, and end offset.                  |
+
+---
+
+### Utility Functions
+
+| Function                          | Description                                                                                                                                                   |
+| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `generateShortFieldName`          | Converts an integer (starting from zero) into a short alphabetic identifier: `0` → `'a'`, `25` → `'z'`, `26` → `'aa'`, etc.                                   |
+| `buildNestedRenameMapFromContent` | Recursively builds a `NestedRenameMap` from the content value of a compiled dictionary, respecting Intlayer node structures (translation, enumeration, etc.). |
+| `createPruneContext`              | Creates a new empty `PruneContext` object initialized with default values.                                                                                    |
+| `extractScriptBlocks`             | Extracts `<script>` blocks from SFC files (Vue / Svelte) for subsequent Babel analysis.                                                                       |
+| `BABEL_PARSER_OPTIONS`            | Constant representing Babel parser options covering the supported frameworks (React/Vue/Svelte/Angular/...).                                                  |
+| `INTLAYER_CALLER_NAMES`           | Constant list of original Intlayer caller names: `['useIntlayer', 'getIntlayer']`.                                                                            |
+
+---
+
+## Example Usage
+
+```js
+// babel.config.js
+const {
+  intlayerExtractBabelPlugin,
+  intlayerPurgeBabelPlugin,
+  intlayerMinifyBabelPlugin,
+  intlayerOptimizeBabelPlugin,
+  getExtractPluginOptions,
+  getPurgePluginOptions,
+  getMinifyPluginOptions,
+  getOptimizePluginOptions,
+} = require("@intlayer/babel");
+
+module.exports = {
+  presets: ["next/babel"],
+  plugins: [
+    [intlayerExtractBabelPlugin, getExtractPluginOptions()],
+    [intlayerPurgeBabelPlugin, getPurgePluginOptions()],
+    [intlayerMinifyBabelPlugin, getMinifyPluginOptions()],
+    [intlayerOptimizeBabelPlugin, getOptimizePluginOptions()],
+  ],
+};
+```
+
+> **Note:** The `intlayerPurgeBabelPlugin` must be declared **before** `intlayerMinifyBabelPlugin`, because the latter reads the rename map built by the former. In addition, they both must be preceded by `intlayerOptimizeBabelPlugin` so that it can see the dictionary keys before the `useIntlayer` calls are rewritten.

package/docs/en/packages/vite-intlayer/exports.md

@@ -1,20 +1,26 @@
 ---
 createdAt: 2026-01-21
-updatedAt: 2026-01-21
+updatedAt: 2026-06-25
 title: vite-intlayer Package Documentation
-description: Vite plugin for Intlayer, providing dictionary aliases and watchers.
+description: Vite plugin for Intlayer, providing dictionary aliases, watchers, locale routing, and build optimisations.
 keywords:
   - vite-intlayer
   - vite
   - plugin
   - internationalization
   - i18n
+  - proxy
+  - routing
+  - tree-shaking
 slugs:
   - doc
   - packages
   - vite-intlayer
   - exports
 history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Updated exports index – proxy and compiler now bundled into intlayer(); added intlayerProxy, intlayerCompiler, intlayerMinify docs"
   - version: 8.0.0
     date: 2026-01-21
     changes: "Unified documentation for all exports"
@@ -23,7 +29,7 @@ author: aymericzip
 
 # vite-intlayer Package
 
-The `vite-intlayer` package provides a Vite plugin to integrate Intlayer into your Vite-based application.
+The `vite-intlayer` package provides a Vite plugin to integrate Intlayer into your Vite-based application. It handles dictionary compilation, dev-server watching, module aliases, locale-routing middleware, and build-time optimisations (tree-shaking, minification).
 
 ## Installation
 
@@ -33,18 +39,37 @@ npm install vite-intlayer
 
 ## Exports
 
-### Plugin
+### Plugins
 
 Import:
 
-```tsx
-import "vite-intlayer";
+```ts
+import { ... } from "vite-intlayer";
 ```
 
-| Function             | Description                                                           | Related Doc                                                                                                            |
-| -------------------- | --------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
-| `intlayer`           | Main Vite plugin that integrates Intlayer into the build process.     | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayer.md)           |
-| `intlayerPlugin`     | (**Deprecated**) Alias for `intlayer`.                                | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayer.md)           |
-| `intlayerProxy`      | Development middleware plugin to handle locale detection and routing. | -                                                                                                                      |
-| `intlayerMiddleware` | (**Deprecated**) Alias for `intlayerProxy`.                           | -                                                                                                                      |
-| `intlayerPrune`      | Plugin to tree-shake and prune unused dictionaries during build.      | [intlayerPrune](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayerPrune.md) |
+| Export                     | Description                                                                                                                                       | Related Doc                                                                                                                  |
+| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
+| `intlayer`                 | Main Vite plugin. Prepares dictionaries, configures aliases, starts dev-server watchers, and (since v9) bundles the proxy and compiler.           | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayer.md)                 |
+| `intlayerPlugin`           | (**Deprecated**) Alias for `intlayer`.                                                                                                            | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayer.md)                 |
+| `intLayerPlugin`           | (**Deprecated**) Alias for `intlayer`.                                                                                                            | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayer.md)                 |
+| `intlayerProxy`            | Locale-routing middleware plugin (detection, redirect, rewrite). Since v9 it is bundled inside `intlayer()` – register separately only if needed. | [intlayerProxy](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayerProxy.md)       |
+| `intlayerMiddleware`       | (**Deprecated**) Alias for `intlayerProxy`.                                                                                                       | [intlayerProxy](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayerProxy.md)       |
+| `intLayerMiddlewarePlugin` | (**Deprecated**) Alias for `intlayerProxy`.                                                                                                       | [intlayerProxy](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayerProxy.md)       |
+| `intlayerCompiler`         | Extracts inline content declarations from components and writes them to dictionaries. Since v9 it is bundled inside `intlayer()`.                 | [intlayerCompiler](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayerCompiler.md) |
+| `intlayerPrune`            | Tree-shakes unused dictionary fields from the production bundle.                                                                                  | [intlayerPrune](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayerPrune.md)       |
+| `intlayerMinify`           | Minifies compiled dictionary JSON files and optionally mangles field names.                                                                       | [intlayerMinify](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayerMinify.md)     |
+
+### Utilities
+
+| Export                       | Description                                                                                   | Related Doc                                                                                                            |
+| ---------------------------- | --------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| `createIntlayerProxyHandler` | Returns a framework-agnostic Node.js `(req, res, next)` middleware with locale-routing logic. | [intlayerProxy](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayerProxy.md) |
+
+### Types
+
+| Export                       | Description                                                                                                      |
+| ---------------------------- | ---------------------------------------------------------------------------------------------------------------- |
+| `IntlayerPluginOptions`      | Options accepted by `intlayer()`. Extends `GetConfigurationOptions` with `compatCallers` and `proxy`.            |
+| `IntlayerProxyPluginOptions` | Options accepted by `intlayerProxy()` and `createIntlayerProxyHandler()`. Includes `ignore` and `configOptions`. |
+| `IntlayerCompilerOptions`    | Options accepted by `intlayerCompiler()`. Includes `configOptions` and `compilerConfig`.                         |
+| `CompatCallerConfig`         | Re-export from `@intlayer/babel`. Describes a compat-adapter caller pattern for field-usage analysis.            |

package/docs/en/packages/vite-intlayer/intlayer.md

@@ -1,31 +1,35 @@
 ---
 createdAt: 2026-01-21
-updatedAt: 2026-01-21
+updatedAt: 2026-06-25
 title: intlayer Vite Plugin Documentation | vite-intlayer
-description: See how to use the intlayer plugin for vite-intlayer package
+description: Complete guide to the intlayer() Vite plugin – dictionary preparation, aliases, dev watcher, locale-routing proxy, and compiler.
 keywords:
   - intlayer
   - vite
   - plugin
-  - Intlayer
-  - intlayer
-  - Internationalization
-  - Documentation
+  - proxy
+  - compiler
+  - internationalization
+  - i18n
+  - routing
 slugs:
   - doc
   - packages
   - vite-intlayer
   - intlayer
 history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Proxy and compiler bundled into intlayer(); added proxy option, compatCallers, routing.enableProxy"
   - version: 8.0.0
     date: 2026-01-21
     changes: "Init doc"
 author: aymericzip
 ---
 
-# intlayer Vite Plugin Documentation
+# intlayer Vite Plugin
 
-The `intlayer` Vite plugin integrates Intlayer configuration into the build process. It handles dictionary aliases, starts the dictionary watcher in development mode, and prepares dictionaries for the build.
+The `intlayer` plugin is the single entry-point for integrating Intlayer into a Vite application. Register it once and everything works out of the box: dictionary compilation, module aliases, dev-server watching, locale-routing middleware, and production build optimisations.
 
 ## Usage
 
@@ -39,11 +43,126 @@ export default defineConfig({
 });
 ```
 
-## Description
+## Options
+
+```ts
+import type { IntlayerPluginOptions } from "vite-intlayer";
+```
+
+`IntlayerPluginOptions` extends `GetConfigurationOptions` (see `@intlayer/config`) with the following additional fields:
+
+| Option          | Type                            | Default     | Description                                                                                                                           |
+| --------------- | ------------------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------- |
+| `compatCallers` | `CompatCallerConfig[]`          | `[]`        | Extra caller patterns for compat-adapter packages (e.g. `@intlayer/react-i18next`). Passed to the field-usage analyser at build time. |
+| `proxy`         | `{ ignore?: (req) => boolean }` | `undefined` | Options forwarded to the bundled locale-routing proxy. Use `ignore` to exclude specific paths (e.g. API routes) from locale routing.  |
+
+All other options (`override`, `configFile`, …) are forwarded directly to `getConfiguration()`.
+
+### Examples
+
+#### Ignore API routes from locale routing
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
+});
+```
+
+#### With a custom config file path
+
+```ts
+export default defineConfig({
+  plugins: [
+    intlayer({
+      configFile: "./config/intlayer.config.ts",
+    }),
+  ],
+});
+```
+
+#### With compat-adapter callers
+
+```ts
+import { intlayer } from "vite-intlayer";
+import { reactI18nextCallerConfig } from "@intlayer/react-i18next/plugin";
+
+export default defineConfig({
+  plugins: [
+    intlayer({
+      compatCallers: [reactI18nextCallerConfig],
+    }),
+  ],
+});
+```
+
+## What the plugin does
+
+### 1. Dictionary preparation
+
+Before the build starts (and once per hour in dev), `intlayer` calls `prepareIntlayer` to compile all `.content.ts` files into optimised JSON dictionaries stored in `.intlayer/`.
+
+### 2. Module aliases
+
+The plugin adds Vite resolve aliases so that `import { myDict } from 'intlayer/dictionaries/my-dict'` resolves to the compiled JSON file on disk. SSR builds use `ssr.noExternal` to ensure all `@intlayer/*` packages are bundled with aliases applied.
+
+### 3. Dev-server watcher
+
+In development mode a `chokidar` watcher is started. When a `.content.ts` file changes the dictionaries are recompiled and Vite's HMR propagates the update to the browser.
+
+### 4. Bundled locale-routing proxy (v9+)
+
+Since Intlayer v9 the `intlayerProxy` middleware is registered automatically inside `intlayer()`. It handles:
+
+- Locale detection from URL prefix, cookies, and `Accept-Language` header.
+- 301 redirects when the detected locale does not match the current URL.
+- Internal URL rewrites so the framework sees the correct `[locale]` route parameter.
+
+The proxy is controlled by `routing.enableProxy` (default `true`) in your Intlayer config. To disable it completely:
+
+```ts
+// intlayer.config.ts
+import { defineConfig } from "intlayer";
+
+export default defineConfig({
+  routing: { enableProxy: false },
+});
+```
+
+To customise proxy behaviour without a separate `intlayerProxy()` call, pass `proxy` options to the main plugin:
+
+```ts
+intlayer({ proxy: { ignore: (req) => req.url?.startsWith("/api") } });
+```
+
+See the [intlayerProxy documentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayerProxy.md) for the full routing behaviour reference.
+
+### 5. Bundled compiler (v9+)
+
+When `compiler.enabled` is `true` **and** `compiler.output` is set in your Intlayer config, `intlayer()` registers `intlayerCompiler` automatically. The compiler extracts inline content declarations written directly inside component files and writes them to dictionaries at transform time. See [intlayerCompiler documentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayerCompiler.md).
+
+### 6. Build optimisations
+
+During a production build the plugin adds:
+
+- **intlayerOptimize** – Babel transform that rewrites `useIntlayer('key')` → `useDictionary(hash)` and injects direct JSON imports.
+- **intlayerPrune** – removes unused content fields from dictionary JSON.
+- **intlayerMinify** – compacts dictionary JSON and optionally mangles field names.
+
+These are inactive in development mode.
 
-The plugin performs the following tasks:
+## Deprecated aliases
 
-1. **Prepare Dictionaries**: It compiles the dictionaries into optimized files at the start of the build or dev process.
-2. **Watch Mode**: In development mode, it watches for changes in dictionary files and recompiles them automatically.
-3. **Aliases**: it provides aliases for accessing the dictionaries in your application.
-4. **Tree-shaking**: it supports tree-shaking unused translations through the `intlayerPrune` plugin.
+| Deprecated export | Replacement |
+| ----------------- | ----------- |
+| `intlayerPlugin`  | `intlayer`  |
+| `intLayerPlugin`  | `intlayer`  |

package/docs/en/packages/vite-intlayer/intlayerCompiler.md

@@ -0,0 +1,120 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: intlayerCompiler Vite Plugin Documentation | vite-intlayer
+description: Vite plugin that extracts inline Intlayer content declarations from component files and writes them to dictionary JSON files at build/transform time.
+keywords:
+  - intlayerCompiler
+  - vite
+  - plugin
+  - compiler
+  - content
+  - dictionary
+  - internationalization
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerCompiler
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Bundled into intlayer(); init doc"
+author: aymericzip
+---
+
+# intlayerCompiler
+
+`intlayerCompiler` is a Vite plugin that scans component source files for **inline Intlayer content declarations** — content defined directly inside a component rather than in a separate `.content.ts` file — and writes them to dictionary JSON files during the transform phase.
+
+> **Since Intlayer v9** `intlayerCompiler` is automatically included inside the main [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayer.md) plugin when both `compiler.enabled` is `true` and `compiler.output` is set in your Intlayer config. You only need to register it separately when you want full control over compiler-specific configuration.
+
+## Usage
+
+### As part of `intlayer()` (recommended, v9+)
+
+Enable the compiler through your Intlayer config:
+
+```ts
+// intlayer.config.ts
+import { defineConfig } from "intlayer";
+
+export default defineConfig({
+  compiler: {
+    enabled: true,
+    output: "./src/dictionaries", // where extracted dictionaries are written
+  },
+});
+```
+
+Then use the standard plugin with no extra registration:
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+### Standalone (when needed)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerCompiler } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayerCompiler()],
+});
+```
+
+## Options
+
+```ts
+import type { IntlayerCompilerOptions } from "vite-intlayer";
+```
+
+| Option           | Type                      | Description                                                                                 |
+| ---------------- | ------------------------- | ------------------------------------------------------------------------------------------- |
+| `configOptions`  | `GetConfigurationOptions` | Intlayer configuration overrides forwarded to `getConfiguration()`.                         |
+| `compilerConfig` | `Partial<CompilerConfig>` | Overrides for the compiler-specific config section (e.g. `enabled`, `output`, `filesList`). |
+
+### Example
+
+```ts
+intlayerCompiler({
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+  compilerConfig: { enabled: true, output: "./src/dictionaries" },
+});
+```
+
+## How it works
+
+### Transform phase
+
+For every source file that matches `compiler.filesList`, the compiler plugin:
+
+1. Passes the file content through `extractContent` from `@intlayer/babel`.
+2. Calls `onExtract` for each declaration found, which writes the resulting dictionary JSON to `compiler.output`.
+3. Returns the transformed source code with inline declarations replaced by standard `useIntlayer('key')` / `getIntlayer('key')` calls.
+
+Supported file types: `.ts`, `.tsx`, `.js`, `.jsx`, `.vue`, `.svelte`, `.astro`.
+
+### HMR (Hot Module Replacement)
+
+When a component file is saved in development mode, the compiler:
+
+1. Detects the file change via Vite's `handleHotUpdate` hook.
+2. Re-extracts content from the updated file.
+3. Writes the updated dictionary JSON.
+4. Triggers a full page reload (`server.ws.send({ type: 'full-reload' })`).
+
+A 500 ms debounce prevents the dictionary write itself (which also triggers a file-change event) from causing an infinite re-extraction loop.
+
+### Deduplication
+
+`intlayerCompiler` uses the same `createPrimaryInstanceGuard` deduplication mechanism as the other bundled plugins. When both `intlayer()` (which bundles the compiler) and a manual `intlayerCompiler()` call are present, only the first registered instance runs — no dictionaries are written twice.

package/docs/en/packages/vite-intlayer/intlayerMinify.md

@@ -0,0 +1,92 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: intlayerMinify Vite Plugin Documentation | vite-intlayer
+description: Vite plugin that minifies compiled Intlayer dictionary JSON files and optionally mangles content field names to reduce bundle size.
+keywords:
+  - intlayerMinify
+  - vite
+  - plugin
+  - minify
+  - bundle size
+  - dictionary
+  - internationalization
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerMinify
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Init doc"
+author: aymericzip
+---
+
+# intlayerMinify
+
+`intlayerMinify` is a Vite plugin that minifies compiled dictionary JSON files during a production build. It strips all unnecessary whitespace and, when combined with `intlayerPrune`, optionally renames content field names to short alphabetic aliases (`a`, `b`, `c`, …) to further reduce bundle size.
+
+> The plugin is already included and configured automatically when you use [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/vite-intlayer/intlayer.md). You only need to register it manually if you are composing the plugin stack yourself.
+
+## Usage
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerMinify, intlayerPrune } from "vite-intlayer";
+import { createPruneContext } from "@intlayer/babel";
+
+const pruneContext = createPruneContext();
+
+export default defineConfig({
+  plugins: [
+    intlayerPrune(intlayerConfig, pruneContext),
+    intlayerMinify(intlayerConfig, pruneContext),
+  ],
+});
+```
+
+## Activation conditions
+
+`intlayerMinify` is active **only** when all three of the following are true:
+
+1. The Vite command is `build` (not `serve` / dev).
+2. `build.optimize` is `true` (or `undefined`, which defaults to `true` for builds).
+3. `build.minify` is `true` in your Intlayer config.
+
+It is automatically **disabled** when `editor.enabled` is `true` because the editor needs the full, human-readable dictionary content.
+
+## What gets minified
+
+The plugin targets two dictionary locations (as resolved from `intlayer.system`):
+
+- `dictionariesDir` — static all-locale dictionaries (e.g. `.intlayer/dictionaries/*.json`)
+- `dynamicDictionariesDir` — per-locale dynamic dictionaries
+
+> Fetch-mode dictionaries (`fetchDictionariesDir`) are **never** minified because they are served from a remote API at runtime using their original field names. Renaming fields would create a mismatch between the server response and client-side property accesses.
+
+## Field-name mangling (property minification)
+
+When `intlayerPrune` has analysed the codebase and populated `pruneContext.dictionaryKeyToFieldRenameMap`, `intlayerMinify` also renames content field names to short aliases. For example:
+
+```json
+// before
+{ "key": "myDict", "content": { "title": "Hello", "description": "World" } }
+
+// after (with mangling)
+{ "key": "myDict", "content": { "a": "Hello", "b": "World" } }
+```
+
+The corresponding source-file property accesses are renamed by the Babel pass inside `intlayerOptimize`, so runtime behaviour is unchanged.
+
+Internal Intlayer fields (`nodeType`, `translation`, etc.) are never renamed.
+
+## Edge-case dictionaries
+
+Dictionaries flagged in `pruneContext.dictionariesWithEdgeCases` (structural anomalies detected during the prune phase) are skipped entirely — neither minified nor mangled — to avoid shipping broken data.
+
+## Qualified groups (collections / variants / meta records)
+
+For dictionaries with a `qualifierTypes` array (collections, variants, and meta records), the plugin preserves the `qualifierTypes` array and the `meta` side-map verbatim. Only the `content` entries have their field names mangled. The composite keys (used for selector matching at runtime) are never touched.