@intlayer/docs 8.12.4 → 9.0.0-canary.10

package/docs/en/packages/svelte-intlayer/usePathname.md

@@ -0,0 +1,103 @@
+---
+createdAt: 2026-06-22
+updatedAt: 2026-06-22
+title: usePathname Function Documentation | svelte-intlayer
+description: See how to use the usePathname function for svelte-intlayer package
+keywords:
+  - usePathname
+  - pathname
+  - locale
+  - Intlayer
+  - Internationalization
+  - Documentation
+  - Svelte
+  - JavaScript
+slugs:
+  - doc
+  - packages
+  - svelte-intlayer
+  - usePathname
+history:
+  - version: 10.0.0
+    date: 2026-06-23
+    changes: "Add usePathname utility"
+  - version: 8.2.0
+    date: 2026-06-22
+    changes: "Init history"
+author: aymericzip
+---
+
+# Svelte Integration: `usePathname` Documentation
+
+The `usePathname` function returns the current browser pathname with the locale segment stripped, as a Svelte `Readable<string>` store. It is useful for building locale-aware navigation — for example, determining which nav item is active — without having to manually remove the locale prefix.
+
+## Importing `usePathname` in Svelte
+
+```typescript
+import { usePathname } from "svelte-intlayer";
+```
+
+## Overview
+
+`usePathname` creates a Svelte readable store that reads `window.location.pathname`, strips the locale prefix via `getPathWithoutLocale`, and emits a new value whenever the browser fires a `popstate` event (back/forward navigation). Subscribe with the `$` store syntax in components.
+
+## Usage
+
+```svelte fileName="src/components/NavItem.svelte"
+<script lang="ts">
+  import { usePathname } from "svelte-intlayer";
+
+  export let href: string;
+  export let label: string;
+
+  const pathname = usePathname();
+</script>
+
+<a {href} aria-current={$pathname === href ? "page" : undefined}>
+  {label}
+</a>
+```
+
+## Return Value
+
+| Type               | Description                                                                      |
+| ------------------ | -------------------------------------------------------------------------------- |
+| `Readable<string>` | Svelte readable store containing the current pathname without the locale prefix. |
+
+## Behavior
+
+- **Locale stripping**: Removes the leading locale segment (e.g. `/fr/dashboard` → `/dashboard`).
+- **Reactive**: Emits a new value on every `popstate` event (browser back / forward navigation).
+- **SSR-safe**: Returns `""` when `window` is not available.
+- **Cleanup**: The `popstate` listener is removed automatically when the last subscriber unsubscribes.
+
+## Example
+
+```svelte fileName="src/components/Sidebar.svelte"
+<script lang="ts">
+  import { usePathname } from "svelte-intlayer";
+
+  const links = [
+    { href: "/dashboard", label: "Dashboard" },
+    { href: "/settings", label: "Settings" },
+  ];
+
+  const pathname = usePathname();
+</script>
+
+<nav>
+  {#each links as link}
+    <a
+      href={link.href}
+      style:font-weight={$pathname === link.href ? "bold" : "normal"}
+    >
+      {link.label}
+    </a>
+  {/each}
+</nav>
+```
+
+## Related
+
+- [`useLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/svelte-intlayer/exports.md) — current locale + locale switcher
+- [`getPathWithoutLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/packages/intlayer/getPathWithoutLocale.md) — the underlying utility used by this function

package/docs/en/packages/svelte-intlayer/useRewriteURL.md

@@ -15,6 +15,7 @@ slugs:
   - packages
   - svelte-intlayer
   - useRewriteURL
+author: aymericzip
 ---
 
 # useRewriteURL Hook

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

@@ -1,28 +1,35 @@
 ---
 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"
+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
 
@@ -32,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,30 +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
 
@@ -38,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.