@intlayer/docs 9.3.0 → 9.3.2

package/docs/it/interest_of_intlayer.md

@@ -207,7 +207,7 @@ export const ComponentExample = () => {
 Questo approccio ti consente di:
 
 1. **Aumentare la velocità di sviluppo**
-   - I file `.content.{{ts|mjs|cjs|json}}` possono essere creati utilizzando un'estensione VSCode
+   - I file `.content.{ts|js|mjs|cjs|json|tsx|jsx|md|mdx|yaml|yml}` possono essere creati utilizzando un'estensione VSCode
    - Gli strumenti di autocompletamento IA nel tuo IDE (come GitHub Copilot) possono aiutarti a dichiarare il tuo contenuto, riducendo il copia/incolla
 
 2. **Pulire la tua base di codice**
@@ -231,27 +231,27 @@ Questo approccio ti consente di:
 
 ## Funzionalità aggiuntive di Intlayer
 
-| Funzionalità                                                                                                              | Descrizione                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/frameworks.png?raw=true)                          | **Supporto Cross-Framework**<br><br>Intlayer è compatibile con tutti i principali framework e librerie, inclusi Next.js, React, Vite, Vue.js, Nuxt, Preact, Express e altri.                                                                                                                                                                                                                                                               |
-| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/javascript_content_management.jpg?raw=true)       | **Gestione del contenuto basata su JavaScript**<br><br>Sfrutta la flessibilità di JavaScript per definire e gestire il tuo contenuto in modo efficiente.<br><br> - [Dichiarazione del contenuto](https://intlayer.org/doc/concept/content)                                                                                                                                                                                                 |
-| <img src="https://github.com/aymericzip/intlayer/blob/main/docs/assets/compiler.jpg?raw=true" alt="Feature" width="700">  | **Compilatore**<br><br>Il compilatore Intlayer estrae automaticamente il contenuto dai componenti e genera i file del dizionario.<br><br> - [Compilatore](https://intlayer.org/doc/compiler)                                                                                                                                                                                                                                               |
-| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/per_locale_content_declaration_file.png?raw=true) | **File di dichiarazione del contenuto per singola lingua**<br><br>Velocizza il tuo sviluppo dichiarando il tuo contenuto una sola volta, prima della generazione automatica.<br><br> - [File di dichiarazione del contenuto per singola lingua](https://intlayer.org/doc/concept/per-locale-file)                                                                                                                                          |
-| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/autocompletion.png?raw=true)                      | **Ambiente Type-Safe**<br><br>Sfrutta TypeScript per garantire che le definizioni del tuo contenuto e il tuo codice siano privi di errori, beneficiando al contempo dell'autocompletamento dell'IDE.<br><br> - [Configurazione di TypeScript](https://intlayer.org/doc/environment/vite-and-react#configure-typescript)                                                                                                                    |
-| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/config_file.png?raw=true)                         | **Configurazione semplificata**<br><br>Inizia rapidamente con una configurazione minima. Regola facilmente le impostazioni per internazionalizzazione, routing, IA, build e gestione del contenuto.<br><br> - [Esplora l'integrazione con Next.js](https://intlayer.org/doc/environment/nextjs)                                                                                                                                            |
-| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/content_retrieval.png?raw=true)                   | **Recupero del contenuto semplificato**<br><br>Non c'è bisogno di chiamare la tua funzione `t` per ogni elemento del contenuto. Recupera tutto il tuo contenuto direttamente usando un singolo hook.<br><br> - [Integrazione con React](https://intlayer.org/doc/environment/create-react-app)                                                                                                                                             |
-| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/server_component.png?raw=true)                    | **Implementazione coerente dei componenti server**<br><br>Perfettamente adatto per i componenti server di Next.js, usa la stessa implementazione sia per i componenti client che server, senza bisogno di passare la tua funzione `t` attraverso ciascun componente server.<br><br> - [Componenti Server](https://intlayer.org/doc/environment/nextjs#step-7-utilize-content-in-your-code)                                                 |
-| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/file_tree.png?raw=true)                           | **Base di codice organizzata**<br><br>Mantieni la tua base di codice più organizzata: 1 componente = 1 dizionario nella stessa cartella. Le traduzioni vicine ai rispettivi componenti migliorano la manutenibilità e la chiarezza.<br><br> - [Come funziona Intlayer](https://intlayer.org/doc/concept/how-works-intlayer)                                                                                                                |
-| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/url_routing.png?raw=true)                         | **Routing potenziato**<br><br>Supporto completo del routing dell'app, adattandosi perfettamente a strutture applicative complesse, per Next.js, React, Vite, Vue.js, ecc.<br><br> - [Esplora l'integrazione con Next.js](https://intlayer.org/doc/environment/nextjs)                                                                                                                                                                      |
-| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/markdown.png?raw=true)                            | **Supporto Markdown**<br><br>Importa e interpreta file locali e Markdown remoto per contenuti multilingue come informative sulla privacy, documentazione, ecc. Interpreta e rendi accessibili i metadati Markdown nel tuo codice.<br><br> - [File di contenuto](https://intlayer.org/doc/concept/content/file)                                                                                                                             |
-| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/visual_editor.png?raw=true)                       | **Editor visuale e CMS gratuiti**<br><br>Un editor visuale e un CMS gratuiti sono disponibili per i creatori di contenuti, eliminando la necessità di una piattaforma di localizzazione. Mantieni il tuo contenuto sincronizzato usando Git, o esternalizzalo totalmente o parzialmente con il CMS.<br><br> - [Editor di Intlayer](https://intlayer.org/doc/concept/editor) <br> - [CMS di Intlayer](https://intlayer.org/doc/concept/cms) |
-| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/bundle.png?raw=true)                              | **Contenuto Tree-shakable**<br><br>Contenuto tree-shakable, che riduce le dimensioni del bundle finale. Carica il contenuto per componente, escludendo qualsiasi contenuto non utilizzato dal bundle. Supporta il caricamento lazy per migliorare l'efficienza di caricamento dell'app.<br><br> - [Ottimizzazione della build dell'applicazione](https://intlayer.org/doc/concept/how-works-intlayer#app-build-optimization)               |
-| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/static_rendering.png?raw=true)                    | **Rendering statico**<br><br>Non blocca il rendering statico.<br><br> - [Integrazione con Next.js](https://intlayer.org/doc/environment/nextjs)                                                                                                                                                                                                                                                                                            |
-| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/AI_translation.png?raw=true)                      | **Traduzione basata sull'IA**<br><br>Trasforma il tuo sito web in 231 lingue con un solo clic grazie agli strumenti avanzati di traduzione basati sull'IA di Intlayer utilizzando il tuo provider di IA/chiave API.<br><br> - [Integrazione CI/CD](https://intlayer.org/doc/concept/ci-cd) <br> - [CLI di Intlayer](https://intlayer.org/doc/concept/cli) <br> - [Riempimento automatico](https://intlayer.org/doc/concept/auto-fill)      |
-| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/mcp.png?raw=true)                                 | **Integrazione Server MCP**<br><br>Fornisce un server MCP (Model Context Protocol) per l'automazione dell'IDE, abilitando una gestione trasparente del contenuto e dei flussi di lavoro i18n direttamente all'interno del tuo ambiente di sviluppo.<br><br> - [Server MCP](https://github.com/aymericzip/intlayer/blob/main/docs/it/mcp_server.md)                                                                                         |
-| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/vscode_extension.png?raw=true)                    | **Estensione VSCode**<br><br>Intlayer fornisce un'estensione VSCode per aiutarti a gestire il tuo contenuto e le traduzioni, compilare i tuoi dizionari, tradurre il tuo contenuto e altro ancora.<br><br> - [Estensione VSCode](https://intlayer.org/doc/vs-code-extension)                                                                                                                                                               |
-| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/interoperability.png?raw=true)                    | **Interoperabilità**<br><br>Consente l'interoperabilità con react-i18next, next-i18next, next-intl e react-intl.<br><br> - [Intlayer e react-intl](https://intlayer.org/blog/intlayer-with-react-intl) <br> - [Intlayer e next-intl](https://intlayer.org/blog/intlayer-with-next-intl) <br> - [Intlayer e next-i18next](https://intlayer.org/blog/intlayer-with-next-i18next)                                                             |
-| Test delle traduzioni mancanti (CLI/CI)                                                                                   | ✅ CLI: npx intlayer content test (audit compatibile con CI)                                                                                                                                                                                                                                                                                                                                                                               |
+| Funzionalità                                                                                                              | Descrizione                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| ------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/frameworks.png?raw=true)                          | **Supporto Cross-Framework**<br><br>Intlayer è compatibile con tutti i principali framework e librerie, inclusi Next.js, React, Vite, Vue.js, Nuxt, Preact, Express e altri.                                                                                                                                                                                                                                                                                            |
+| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/javascript_content_management.jpg?raw=true)       | **Gestione del contenuto basata su JavaScript**<br><br>Sfrutta la flessibilità di JavaScript per definire e gestire il tuo contenuto in modo efficiente.<br><br> - [Dichiarazione del contenuto](https://intlayer.org/doc/concept/content)                                                                                                                                                                                                                              |
+| <img src="https://github.com/aymericzip/intlayer/blob/main/docs/assets/compiler.jpg?raw=true" alt="Feature" width="700">  | **Compilatore**<br><br>Il compilatore Intlayer estrae automaticamente il contenuto dai componenti e genera i file del dizionario.<br><br> - [Compilatore](https://intlayer.org/doc/compiler)                                                                                                                                                                                                                                                                            |
+| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/per_locale_content_declaration_file.png?raw=true) | **File di dichiarazione del contenuto per singola lingua**<br><br>Velocizza il tuo sviluppo dichiarando il tuo contenuto una sola volta, prima della generazione automatica.<br><br> - [File di dichiarazione del contenuto per singola lingua](https://intlayer.org/doc/concept/per-locale-file)                                                                                                                                                                       |
+| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/autocompletion.png?raw=true)                      | **Ambiente Type-Safe**<br><br>Sfrutta TypeScript per garantire che le definizioni del tuo contenuto e il tuo codice siano privi di errori, beneficiando al contempo dell'autocompletamento dell'IDE.<br><br> - [Configurazione di TypeScript](https://intlayer.org/doc/environment/vite-and-react#configure-typescript)                                                                                                                                                 |
+| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/config_file.png?raw=true)                         | **Configurazione semplificata**<br><br>Inizia rapidamente con una configurazione minima. Regola facilmente le impostazioni per internazionalizzazione, routing, IA, build e gestione del contenuto.<br><br> - [Esplora l'integrazione con Next.js](https://intlayer.org/doc/environment/nextjs)                                                                                                                                                                         |
+| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/content_retrieval.png?raw=true)                   | **Recupero del contenuto semplificato**<br><br>Non c'è bisogno di chiamare la tua funzione `t` per ogni elemento del contenuto. Recupera tutto il tuo contenuto direttamente usando un singolo hook.<br><br> - [Integrazione con React](https://intlayer.org/doc/environment/create-react-app)                                                                                                                                                                          |
+| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/server_component.png?raw=true)                    | **Implementazione coerente dei componenti server**<br><br>Perfettamente adatto per i componenti server di Next.js, usa la stessa implementazione sia per i componenti client che server, senza bisogno di passare la tua funzione `t` attraverso ciascun componente server.<br><br> - [Componenti Server](https://intlayer.org/doc/environment/nextjs#step-7-utilize-content-in-your-code)                                                                              |
+| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/file_tree.png?raw=true)                           | **Base di codice organizzata**<br><br>Mantieni la tua base di codice più organizzata: 1 componente = 1 dizionario nella stessa cartella. Le traduzioni vicine ai rispettivi componenti migliorano la manutenibilità e la chiarezza.<br><br> - [Come funziona Intlayer](https://intlayer.org/doc/concept/how-works-intlayer)                                                                                                                                             |
+| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/url_routing.png?raw=true)                         | **Routing potenziato**<br><br>Supporto completo del routing dell'app, adattandosi perfettamente a strutture applicative complesse, per Next.js, React, Vite, Vue.js, ecc.<br><br> - [Esplora l'integrazione con Next.js](https://intlayer.org/doc/environment/nextjs)                                                                                                                                                                                                   |
+| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/markdown.png?raw=true)                            | **Supporto Markdown**<br><br>Importa e interpreta file locali e Markdown remoto per contenuti multilingue come informative sulla privacy, documentazione, ecc. Interpreta e rendi accessibili i metadati Markdown nel tuo codice.<br><br> - [File di contenuto](https://intlayer.org/doc/concept/content/file)                                                                                                                                                          |
+| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/visual_editor.png?raw=true)                       | **Editor visuale e CMS gratuiti**<br><br>Un editor visuale e un CMS gratuiti sono disponibili per i creatori di contenuti, eliminando la necessità di una piattaforma di localizzazione. Mantieni il tuo contenuto sincronizzato usando Git, o esternalizzalo totalmente o parzialmente con il CMS.<br><br> - [Editor di Intlayer](https://intlayer.org/doc/concept/editor) <br> - [CMS di Intlayer](https://intlayer.org/doc/concept/cms)                              |
+| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/bundle.png?raw=true)                              | **Contenuto Tree-shakable**<br><br>Contenuto tree-shakable, che riduce le dimensioni del bundle finale. Carica il contenuto per componente, escludendo qualsiasi contenuto non utilizzato dal bundle. Supporta il caricamento lazy per migliorare l'efficienza di caricamento dell'app.<br><br> - [Ottimizzazione della build dell'applicazione](https://intlayer.org/doc/concept/how-works-intlayer#app-build-optimization)                                            |
+| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/static_rendering.png?raw=true)                    | **Rendering statico**<br><br>Non blocca il rendering statico.<br><br> - [Integrazione con Next.js](https://intlayer.org/doc/environment/nextjs)                                                                                                                                                                                                                                                                                                                         |
+| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/AI_translation.png?raw=true)                      | **Traduzione basata sull'IA**<br><br>Trasforma il tuo sito web in 231 lingue con un solo clic grazie agli strumenti avanzati di traduzione basati sull'IA di Intlayer utilizzando il tuo provider di IA/chiave API.<br><br> - [Integrazione CI/CD](https://intlayer.org/doc/concept/ci-cd) <br> - [CLI di Intlayer](https://intlayer.org/doc/concept/cli) <br> - [Riempimento automatico](https://intlayer.org/doc/concept/auto-fill)                                   |
+| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/mcp.png?raw=true)                                 | **Integrazione Server MCP**<br><br>Fornisce un server MCP (Model Context Protocol) per l'automazione dell'IDE, abilitando una gestione trasparente del contenuto e dei flussi di lavoro i18n direttamente all'interno del tuo ambiente di sviluppo.<br><br> - [Server MCP](https://github.com/aymericzip/intlayer/blob/main/docs/it/mcp_server.md)                                                                                                                      |
+| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/vscode_extension.png?raw=true)                    | **Estensione VSCode**<br><br>Intlayer fornisce un'estensione VSCode per aiutarti a gestire il tuo contenuto e le traduzioni, compilare i tuoi dizionari, tradurre il tuo contenuto e altro ancora.<br><br> - [Estensione VSCode](https://intlayer.org/doc/vs-code-extension)                                                                                                                                                                                            |
+| ![Feature](https://github.com/aymericzip/intlayer/blob/main/docs/assets/interoperability.png?raw=true)                    | **Interoperabilità**<br><br>Consente l'interoperabilità con react-i18next, next-i18next, next-intl e react-intl.<br><br> - [Intlayer e react-intl](https://intlayer.org/blog/intlayer-with-react-intl) <br> - [Intlayer e next-intl](https://intlayer.org/blog/intlayer-with-next-intl) <br> - [Intlayer e next-i18next](https://intlayer.org/blog/intlayer-with-next-i18next) <br> - [Adattatori di compatibilità di Intlayer](https://intlayer.org/doc/compatibility) |
+| Test delle traduzioni mancanti (CLI/CI)                                                                                   | ✅ CLI: npx intlayer content test (audit compatibile con CI)                                                                                                                                                                                                                                                                                                                                                                                                            |
 
 ## Confronto di Intlayer con altre soluzioni
 
@@ -290,3 +290,5 @@ Le stelle su GitHub sono un forte indicatore della popolarità di un progetto, d
 `intlayer` può anche aiutare a gestire i namespace `react-intl`, `react-i18next`, `next-intl`, `next-i18next` e `vue-i18n`.
 
 Utilizzando `intlayer`, puoi dichiarare il tuo contenuto nel formato della tua libreria i18n preferita, e intlayer genererà i tuoi namespace nella posizione che preferisci (esempio: `/messages/{{locale}}/{{namespace}}.json`).
+
+Se desideri continuare a usare l'API della tua attuale libreria i18n, `intlayer` fornisce anche gli **adattatori di compatibilità (compat adapters)**: pacchetti che espongono esattamente la stessa API di `react-i18next`, `next-intl`, `react-intl`, `vue-i18n` e altre, ma serviti dai dizionari di Intlayer. Questo ti permette di migrare progressivamente senza riscrivere il tuo codice. Consulta la [documentazione degli adattatori di compatibilità](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/compat/index.md).

package/docs/it/intlayer_with_svelte_kit.md

@@ -404,7 +404,7 @@ export const getLocale = (event: RequestEvent): Locale => {
 };
 ```
 
-> `getLocaleFromStorage` controllerà la locale dall'header o dal cookie a seconda della tua configurazione. Vedi [Configurazione](https://intlayer.org/doc/configuration) per maggiori dettagli.
+> `getLocaleFromStorage` controllerà la locale dall'header o dal cookie a seconda della tua configurazione. Vedi [Configurazione](https://intlayer.org/doc/concept/configuration) per maggiori dettagli.
 
 > La funzione `localeDetector` gestirà l'header `Accept-Language` e restituirà la corrispondenza migliore.
 

package/docs/it/intlayer_with_tanstack+solid.md

@@ -254,19 +254,21 @@ import {
   HeadContent,
   Scripts,
   createRootRouteWithContext,
+  getRouteApi,
 } from "@tanstack/solid-router";
 import { HydrationScript } from "solid-js/web";
 import { Suspense, type ParentComponent } from "solid-js";
 import { IntlayerProvider } from "solid-intlayer";
 import { defaultLocale, getHTMLTextDir } from "intlayer";
-import { Route as LocaleRoute } from "./{-$locale}/route";
+
+const localeRoute = getRouteApi("/{-$locale}");
 
 export const Route = createRootRouteWithContext()({
   shellComponent: RootComponent,
 });
 
 const RootComponent: ParentComponent = (props) => {
-  const params = LocaleRoute.useParams();
+  const params = localeRoute.useParams();
   const locale = params()?.locale ?? defaultLocale;
 
   return (
@@ -551,7 +553,7 @@ Come visto nel Passaggio 5, puoi gestire gli attributi `lang` e `dir` del tag `h
 
 ```tsx fileName="src/routes/__root.tsx"
 const RootComponent: ParentComponent = (props) => {
-  const params = LocaleRoute.useParams();
+  const params = localeRoute.useParams();
   const locale = params()?.locale ?? defaultLocale;
 
   return (

package/docs/it/intlayer_with_tanstack.md

@@ -271,13 +271,15 @@ Configura il tuo layout root per supportare l'internazionalizzazione utilizzando
 ```tsx fileName="src/routes/__root.tsx"
 import {
   createRootRouteWithContext,
+  getRouteApi,
   HeadContent,
   Scripts,
 } from "@tanstack/react-router";
 import { defaultLocale, getHTMLTextDir } from "intlayer";
 import { type ReactNode } from "react";
 import { IntlayerProvider } from "react-intlayer";
-import { Route as LocaleRoute } from "./{-$locale}/route";
+
+const localeRoute = getRouteApi("/{-$locale}");
 
 export const Route = createRootRouteWithContext<{}>()({
   head: () => ({
@@ -299,7 +301,7 @@ export const Route = createRootRouteWithContext<{}>()({
 });
 
 function RootDocument({ children }: { children: ReactNode }) {
-  const params = LocaleRoute.useParams();
+  const params = localeRoute.useParams();
   const locale = params?.locale ?? defaultLocale;
 
   return (
@@ -632,7 +634,7 @@ Come visto nel Passaggio 5, puoi gestire gli attributi `lang` e `dir` del tag `h
 
 ```tsx fileName="src/routes/__root.tsx"
 function RootDocument({ children }: { children: ReactNode }) {
-  const params = LocaleRoute.useParams();
+  const params = localeRoute.useParams();
   const locale = params?.locale ?? defaultLocale;
 
   return (

package/docs/it/lsp.md

@@ -1,12 +1,14 @@
 ---
 createdAt: 2025-06-07
-updatedAt: 2026-05-31
-title: Server LSP Intlayer
-description: Scopri come il server di linguaggio Intlayer fornisce la funzionalità "Vai alla definizione" e altre funzionalità IDE per useIntlayer, getIntlayer e chiamate correlate in tutti gli editor supportati.
+updatedAt: 2026-08-10
+title: Server LSP di Intlayer
+description: Scopri come il language server di Intlayer porta Go-to-Definition, ricerca dei riferimenti, anteprime al passaggio del mouse, autocompletamento delle chiavi e diagnostica nel tuo IDE e nel tuo agente IA.
 keywords:
   - LSP
-  - Server di linguaggio
-  - Vai alla definizione
+  - Language Server
+  - Go to Definition
+  - Autocompletamento
+  - Diagnostica
   - IDE
   - Intlayer
   - VS Code
@@ -16,56 +18,58 @@ slugs:
   - doc
   - lsp
 history:
+  - version: 9.1.3
+    date: 2026-08-10
+    changes: "Aggiunti ricerca dei riferimenti, hover, autocompletamento e diagnostica"
   - version: 8.12.0
     date: 2026-06-01
     changes: "Release LSP"
 author: aymericzip
 ---
 
-# Server LSP Intlayer
+# Server LSP di Intlayer
 
-Il **Server di linguaggio Intlayer (LSP)** è un'implementazione del [Language Server Protocol (LSP)](https://microsoft.github.io/language-server-protocol/) che arricchisce il tuo IDE con un'intelligenza consapevole di Intlayer. Attualmente fornisce la funzionalità **Vai alla definizione (Go to Definition)** per le chiamate alle chiavi del dizionario, consentendoti di saltare direttamente da `useIntlayer("my-key")` nel tuo componente al file `.content.ts` che lo dichiara.
+Il **language server di Intlayer** è un'implementazione del [Language Server Protocol (LSP)](https://microsoft.github.io/language-server-protocol/) che rende il tuo IDE — e il tuo agente IA — consapevole di Intlayer. Collega una chiamata come `useIntlayer("home")` al file `.content.ts` che la dichiara, in entrambe le direzioni.
 
 ---
 
-## Perché usare l'LSP?
+## Funzionalità
 
-Quando usi Intlayer, la connessione tra una chiamata come `useIntlayer("homepage")` e la sua dichiarazione in `src/homepage.content.ts` è implicita. Senza strumenti dedicati, dovresti cercare il file manualmente. L'LSP rende questo collegamento esplicito:
+| Funzionalità                  | Scorciatoia         | Descrizione                                                                                                                  |
+| ----------------------------- | ------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
+| **Vai alla definizione**      | `F12` / `Cmd+Clic`  | Passare da una chiave di dizionario o dall'uso di un campo alla sua dichiarazione nel file di contenuto                      |
+| **Trova tutti i riferimenti** | `Maiusc+F12`        | Da un file di contenuto, elencare ogni punto di chiamata che usa quella chiave o quel campo                                  |
+| **Hover**                     | passare il cursore  | Visualizzare i campi di un dizionario, o il valore tradotto di un campo, senza lasciare il file                              |
+| **Autocompletamento**         | `"` `'` `` ` `` `.` | Suggerire le chiavi di dizionario dichiarate dentro un getter, e i campi di contenuto dopo `.` o durante la destrutturazione |
+| **Diagnostica**               | automatico          | Avvisare quando una chiave non è dichiarata in nessun file di contenuto                                                      |
 
-**Consapevolezza dell'agente AI**
+Vale la pena conoscere due comportamenti aggiuntivi:
 
-Gli agenti di programmazione AI (Cursor, Windsurf, GitHub Copilot, Claude Code, Codex) si affidano al server di linguaggio per risolvere i simboli e comprendere le relazioni tra i file. Con l'LSP di Intlayer in esecuzione, gli agenti possono seguire `useIntlayer("key")` fino alla sua dichiarazione, ottenendo un contesto accurato sulle chiavi di contenuto disponibili, la struttura di ciascun dizionario e quali file leggere o modificare.
+- **Dizionari uniti** — una chiave suddivisa su più file di contenuto restituisce un risultato per file, così puoi navigare a ogni dichiarazione.
+- **Compatibile con i monorepo** — il server risolve l'`intlayer.config.*` _più vicino_ a ciascun file, così più progetti in uno stesso workspace hanno ciascuno i propri dizionari.
 
-**Vai alla definizione**
+### Chiamate supportate
 
-Posiziona il cursore su qualsiasi stringa chiave del dizionario all'interno di una chiamata getter supportata e premi `F12` (o `Cmd/Ctrl+Click`). L'editor apre il file di dichiarazione del contenuto e posiziona il cursore sulla riga `key:`.
+La chiave viene letta da un argomento posizionale di tipo stringa oppure da un oggetto di opzioni (`{ namespace }`, `{ id }`).
 
-**Supporto per dizionari uniti**
+| Libreria                    | Chiamate                                                 |
+| --------------------------- | -------------------------------------------------------- |
+| **Intlayer**                | `useIntlayer`, `getIntlayer`                             |
+| **i18next / react-i18next** | `useTranslation`, `getFixedT`, `t`, `Trans`              |
+| **next-intl / use-intl**    | `useTranslations`, `getTranslations`, `createTranslator` |
+| **react-intl**              | `formatMessage`, `FormattedMessage`                      |
+| **Lingui**                  | `useLingui`, `t`, `Trans`, `_`                           |
+| **vue-i18n**                | `useI18n`                                                |
 
-Una chiave può essere suddivisa in più file di contenuto (Intlayer li unisce). Il server restituisce una posizione (`Location`) per file sorgente, consentendoti di navigare in ogni dichiarazione.
+Funziona per ogni pacchetto `*-intlayer` (`next-intlayer`, `react-intlayer`, `vue-intlayer`, `svelte-intlayer`, `solid-intlayer`, `preact-intlayer`, `angular-intlayer`, `lit-intlayer`, `express-intlayer`, `hono-intlayer`, `fastify-intlayer`, `intlayer`) e per i pacchetti adattatori compat che ti permettono di mantenere la sintassi i18n esistente.
 
-**Funziona ovunque**
-
-Supporta tutti i pacchetti `*-intlayer` (`next-intlayer`, `react-intlayer`, `vue-intlayer`, `svelte-intlayer`, `solid-intlayer`, `preact-intlayer`, `angular-intlayer`, `lit-intlayer`, `express-intlayer`, `hono-intlayer`, `fastify-intlayer`, `adonis-intlayer`, `intlayer`).
-
-### Chiamate getter supportate
-
-Il server rileva le seguenti chiamate di funzione ed estrae il primo argomento stringa letterale come chiave del dizionario:
-
-| Funzione      | Esempio                       |
-| ------------- | ----------------------------- |
-| `useIntlayer` | `useIntlayer("hero")`         |
-| `getIntlayer` | `getIntlayer("hero", locale)` |
-
-I generici TypeScript e gli argomenti extra vengono ignorati: conta solo la stringa della chiave.
-
-> `useDictionary` e `getDictionary` accettano un oggetto `Dictionary` già importato come primo argomento anziché una chiave stringa, pertanto non beneficiano della funzionalità Vai alla definizione e non sono tracciati dal server.
+> I dizionari vengono letti dall'output di build: esegui `npx intlayer build` — o tieni attivo il server di sviluppo — per dare al server qualcosa da risolvere.
 
 ---
 
 ## Installazione
 
-Il server LSP è distribuito come parte di `@intlayer/lsp`:
+Il server è distribuito come binario `intlayer-lsp` in `@intlayer/lsp`:
 
 ```bash packageManager="npm"
 npm install --save-dev @intlayer/lsp
@@ -83,43 +87,43 @@ pnpm add --save-dev @intlayer/lsp
 bun add --dev @intlayer/lsp
 ```
 
-Il pacchetto espone il binario `intlayer-lsp`, che gli editor utilizzano come eseguibile del server.
+Installalo invece globalmente (`npm install -g @intlayer/lsp`) se il tuo editor richiede `intlayer-lsp` nel `PATH` — è il caso del plugin per Claude Code e di qualsiasi configurazione qui sotto che invochi direttamente il binario.
 
 ---
 
-## Configurazione come plugin di Claude Code
+## Configurazione
 
-L'LSP Intlayer è disponibile come **plugin di Claude Code** ospitato direttamente nel repository GitHub di Intlayer. Installarlo fornisce a Claude Code una consapevolezza nativa di Vai alla definizione per tutte le tue chiamate `useIntlayer` / `getIntlayer`.
+<Tabs defaultTab="vscode">
+  <Tab label="VS Code" value="vscode">
 
-### 1. Installa il binario del server di linguaggio
+Installa l'[estensione VS Code di Intlayer](https://marketplace.visualstudio.com/items?itemName=Intlayer.intlayer-vs-code-extension). Il language server è incluso dalla v8.12.0 e si avvia automaticamente — **nessuna configurazione richiesta**.
 
-```bash packageManager="npm"
-npm install -g @intlayer/lsp
-```
+Consulta la [documentazione dell'estensione VS Code](https://intlayer.org/doc/vs-code-extension) per le altre funzionalità.
 
-```bash packageManager="yarn"
-yarn global add @intlayer/lsp
-```
+  </Tab>
+  <Tab label="Cursor / Windsurf" value="cursor">
 
-```bash packageManager="pnpm"
-pnpm add -g @intlayer/lsp
-```
+[Cursor](https://www.cursor.com/) e [Windsurf](https://windsurf.com/) sono fork di VS Code e usano lo stesso ecosistema di estensioni. Installa una volta l'[estensione VS Code di Intlayer](https://marketplace.visualstudio.com/items?itemName=Intlayer.intlayer-vs-code-extension) e il server si attiva automaticamente — **nessuna configurazione richiesta**.
+
+  </Tab>
+  <Tab label="Claude Code" value="claude-code">
 
-Questo inserisce il binario `intlayer-lsp` nel tuo PATH, che è ciò che richiama la voce `lspServers` del plugin.
+Intlayer fornisce un **plugin per Claude Code** ospitato nel repository di Intlayer. Dà a Claude Code una vera risoluzione dei simboli per le tue chiavi di dizionario, invece di ripiegare su `grep`.
 
-### 2. Registra il marketplace di Intlayer e installa il plugin
+Metti il binario nel tuo `PATH`, poi registra il marketplace e installa il plugin:
 
 ```bash
+npm install -g @intlayer/lsp
+
 claude plugin marketplace add intlayer@github:aymericzip/intlayer
 claude plugin install intlayer-lsp@intlayer
-claude plugin enable intlayer-lsp@intlayer
 ```
 
-Claude Code aggiungerà `"intlayer-lsp@intlayer": true` ai tuoi `enabledPlugins` e avvierà automaticamente il server di linguaggio sui tipi di file supportati (`.ts`, `.tsx`, `.js`, `.jsx`, `.vue`, `.svelte`).
+`install` abilita anche il plugin. **Riavvia Claude Code** — i language server vengono caricati all'avvio, quindi il plugin non ha effetto prima di allora.
 
-### 3. Abilita lo strumento LSP (se non è già attivo)
+Claude Code avvia poi il server sui file `.ts`, `.tsx`, `.js`, `.jsx`, `.vue`, `.astro` e `.svelte`, e usa `goToDefinition`, `findReferences` e `hover` durante la navigazione del codice.
 
-Alcune versioni di Claude Code richiedono l'impostazione del flag di funzionalità LSP. Aggiungi quanto segue al tuo file `~/.claude/settings.json` se Vai alla definizione non funziona dopo l'installazione:
+Se Go-to-Definition continua a non fare nulla, la tua versione di Claude Code potrebbe vincolare lo strumento LSP a un flag:
 
 ```json fileName="~/.claude/settings.json"
 {
@@ -129,61 +133,10 @@ Alcune versioni di Claude Code richiedono l'impostazione del flag di funzionalit
 }
 ```
 
-Riavvia Claude Code: ora utilizzerà `goToDefinition`, `findReferences` e altre operazioni LSP durante la navigazione nella base di codice Intlayer anziché ripiegare su `grep`.
-
----
-
-## Configurazione in VS Code (tramite estensione — consigliato)
-
-Se hai installato l'**estensione Intlayer per VS Code**, il server di linguaggio si avvia automaticamente. Non è richiesta alcuna configurazione aggiuntiva. L'LSP è integrato direttamente nell'estensione VSCode dalla versione 8.12.0.
-
-> Consulta la [documentazione dell'estensione VS Code](https://intlayer.org/doc/vs-code-extension) per l'installazione e altre funzionalità.
-
----
-
-## Configurazione manuale in VS Code
-
-Se non utilizzi l'estensione Intlayer, puoi configurare il server di linguaggio manualmente utilizzando un'estensione client LSP generica come [**vscode-glspc**](https://marketplace.visualstudio.com/items?itemName=sibiraj-s.vscode-scss-formatter) o scrivendo una tua piccola estensione. L'approccio consigliato consiste nell'utilizzare l'estensione Intlayer.
-
-Per riferimento, il server viene avviato tramite il binario `intlayer-lsp` su stdio:
-
-```json fileName=".vscode/settings.json"
-{
-  "intlayer.languageServer.command": "npx",
-  "intlayer.languageServer.args": ["@intlayer/lsp"]
-}
-```
-
-L'estensione Intlayer legge queste impostazioni per avviare il server. Se ti affidi esclusivamente all'estensione, non sono necessarie impostazioni manuali.
-
----
-
-## Configurazione in Cursor
-
-[Cursor](https://www.cursor.com/) è un fork di VS Code con funzionalità AI integrate. Utilizza lo stesso ecosistema di estensioni, quindi l'**estensione Intlayer per VS Code** funziona senza alcuna configurazione aggiuntiva: installala una volta e Cursor la rileverà automaticamente.
-
-Se preferisci una configurazione manuale, Cursor legge anche `.vscode/settings.json` dalla radice dell'area di lavoro, quindi lo snippet di VS Code sopra si applica direttamente.
-
----
-
-## Configurazione in Windsurf
-
-[Windsurf](https://windsurf.com/) (di Codeium) è un altro editor basato su VS Code. Installa l'estensione Intlayer dal VS Code Marketplace e il server di linguaggio si attiverà automaticamente, esattamente come accade in VS Code e Cursor.
-
-Per la configurazione manuale, crea `.vscode/settings.json` nella radice del progetto:
-
-```json fileName=".vscode/settings.json"
-{
-  "intlayer.languageServer.command": "npx",
-  "intlayer.languageServer.args": ["@intlayer/lsp"]
-}
-```
-
----
-
-## Configurazione in Zed
+  </Tab>
+  <Tab label="Zed" value="zed">
 
-[Zed](https://zed.dev/) offre un supporto LSP nativo tramite le sue impostazioni di lingua. Aggiungi una voce nelle tue impostazioni utente di Zed (`~/.config/zed/settings.json`):
+Zed ha supporto LSP nativo. Aggiungi il server alle tue impostazioni utente:
 
 ```json fileName="~/.config/zed/settings.json"
 {
@@ -196,47 +149,21 @@ Per la configurazione manuale, crea `.vscode/settings.json` nella radice del pro
     }
   },
   "languages": {
-    "TypeScript": {
-      "language_servers": ["intlayer-lsp", "..."]
-    },
-    "TSX": {
-      "language_servers": ["intlayer-lsp", "..."]
-    },
-    "JavaScript": {
-      "language_servers": ["intlayer-lsp", "..."]
-    },
-    "Vue.js": {
-      "language_servers": ["intlayer-lsp", "..."]
-    },
-    "Svelte": {
-      "language_servers": ["intlayer-lsp", "..."]
-    }
+    "TypeScript": { "language_servers": ["intlayer-lsp", "..."] },
+    "TSX": { "language_servers": ["intlayer-lsp", "..."] },
+    "JavaScript": { "language_servers": ["intlayer-lsp", "..."] },
+    "Vue.js": { "language_servers": ["intlayer-lsp", "..."] },
+    "Svelte": { "language_servers": ["intlayer-lsp", "..."] }
   }
 }
 ```
 
-Il segnaposto `"..."` indica a Zed di mantenere i suoi server di linguaggio predefiniti insieme a quello di Intlayer.
-
----
-
-## Configurazione per CLI di agenti AI (Claude Code, Codex, ecc.)
-
-**Claude Code** offre un supporto di prim'ordine per i plugin LSP: segui la [configurazione del plugin Claude Code](#configurazione-come-plugin-di-claude-code) sopra per ottenere l'esperienza completa di Vai alla definizione direttamente nelle tue sessioni di terminale.
+Il segnaposto `"..."` mantiene i language server predefiniti di Zed insieme a quello di Intlayer.
 
-**OpenAI Codex** e altri strumenti basati su terminale non fungono ancora da client LSP: leggono e scrivono i file direttamente anziché mantenere una sessione di server di linguaggio persistente. Per tali strumenti, il valore di avere l'LSP in esecuzione deriva indirettamente: quando il server è attivo in un editor complementare (VS Code, Cursor, Windsurf, ...), l'indice in tempo reale dell'editor è disponibile per qualsiasi agente AI in grado di interrogarlo tramite il contesto fornito dall'editor (ad esempio, Cursor Composer, Windsurf Cascade, GitHub Copilot Chat).
+  </Tab>
+  <Tab label="Neovim" value="neovim">
 
-Se lavori esclusivamente in un terminale senza un editor aperto, puoi avviare il server di linguaggio in background in modo che sia pronto per qualsiasi editor che si collegherà successivamente alla stessa area di lavoro:
-
-```bash
-# Mantieni il server attivo in background
-npx @intlayer/lsp &
-```
-
----
-
-## Configurazione manuale in Neovim
-
-Utilizzando [nvim-lspconfig](https://github.com/neovim/nvim-lspconfig), registra una configurazione del server personalizzata:
+Con [nvim-lspconfig](https://github.com/neovim/nvim-lspconfig), registra una configurazione di server personalizzata:
 
 ```lua fileName="~/.config/nvim/init.lua"
 local lspconfig = require('lspconfig')
@@ -245,7 +172,7 @@ local configs = require('lspconfig.configs')
 if not configs.intlayer_lsp then
   configs.intlayer_lsp = {
     default_config = {
-      -- Avvia il server con npx per evitare un'installazione globale
+      -- Avvia il server con npx per non richiedere un'installazione globale
       cmd = { 'npx', '--yes', '@intlayer/lsp' },
       filetypes = {
         'typescript',
@@ -267,21 +194,10 @@ end
 lspconfig.intlayer_lsp.setup({})
 ```
 
-Dopo aver riavviato Neovim, premendo `gd` su una chiave Intlayer verrà avviata la funzionalità Vai alla definizione.
-
----
-
-## Configurazione manuale in altri editor
-
-Qualsiasi editor che supporti il Language Server Protocol può utilizzare `@intlayer/lsp`. Il server fornisce:
+Dopo aver riavviato Neovim, `gd` su una chiave di dizionario esegue Vai alla definizione e `gr` esegue Trova riferimenti.
 
-- **Trasporto** – Node.js IPC / stdio (standard)
-- **Eseguibile** – `npx @intlayer/lsp` (o il binario `intlayer-lsp` installato localmente)
-- **Funzionalità** – `definitionProvider: true`, `textDocumentSync: Incremental`
-
-Consulta la documentazione LSP del tuo editor per il formato di configurazione esatto (ad esempio, `languageserver.json` per [coc.nvim](https://github.com/neoclide/coc.nvim) o le impostazioni del client LSP in [Helix](https://helix-editor.com)).
-
-### Esempio: coc.nvim
+  </Tab>
+  <Tab label="coc.nvim" value="coc">
 
 ```json fileName="~/.config/nvim/coc-settings.json"
 {
@@ -307,9 +223,14 @@ Consulta la documentazione LSP del tuo editor per il formato di configurazione e
 }
 ```
 
-### Esempio: Helix
+  </Tab>
+  <Tab label="Helix" value="helix">
 
 ```toml fileName="~/.config/helix/languages.toml"
+[language-server.intlayer-lsp]
+command = "npx"
+args = ["@intlayer/lsp"]
+
 [[language]]
 name = "typescript"
 language-servers = ["intlayer-lsp", "typescript-language-server"]
@@ -317,36 +238,54 @@ language-servers = ["intlayer-lsp", "typescript-language-server"]
 [[language]]
 name = "tsx"
 language-servers = ["intlayer-lsp", "typescript-language-server"]
-
-[language-server.intlayer-lsp]
-command = "npx"
-args = ["@intlayer/lsp"]
 ```
 
+  </Tab>
+  <Tab label="Altri editor" value="other">
+
+Qualsiasi editor compatibile con LSP può eseguire `@intlayer/lsp`. Configuralo con:
+
+- **Eseguibile** — `npx @intlayer/lsp`, o il binario `intlayer-lsp`
+- **Trasporto** — stdio (standard)
+- **Capacità** — `definitionProvider`, `referencesProvider`, `hoverProvider`, `completionProvider` (caratteri di attivazione `"` `'` `` ` `` `.`), diagnostica push, `textDocumentSync: Incremental`
+- **Pattern di root** — `intlayer.config.ts`, `intlayer.config.js`, `package.json`
+
+Consulta la documentazione LSP del tuo editor per il formato di configurazione esatto.
+
+  </Tab>
+</Tabs>
+
 ---
 
-## Come funziona
+## Nota sugli agenti IA da terminale
 
-Quando il server si avvia, risolve la configurazione di Intlayer dalla radice dell'area di lavoro utilizzando `getConfiguration()`. Questo gli fornisce i percorsi `build` e `system` necessari per trovare i dizionari compilati.
+**Claude Code** agisce come un vero client LSP — vedi la scheda sopra.
 
-Su ogni richiesta di **Vai alla definizione**:
+**OpenAI Codex** e la maggior parte degli altri strumenti da terminale non sono client LSP: leggono e scrivono i file direttamente. Eseguire il server da solo non li aiuta; il valore deriva dall'averlo attivo in un editor complementare il cui indice l'agente può interrogare (Cursor Composer, Windsurf Cascade, Copilot Chat).
 
-1. Il server legge il testo completo del documento aperto.
-2. Esegue una scansione per trovare le chiamate getter (`useIntlayer`, `getIntlayer`, ecc.) utilizzando una espressione regolare.
-3. Verifica se la posizione del cursore rientra all'interno di una di quelle chiamate.
-4. In caso affermativo, estrae la chiave del dizionario (gruppo di cattura 3 dell'espressione regolare) e chiama `getUnmergedDictionaries()` per individuare ogni file di contenuto che dichiara quella chiave.
-5. Legge ciascun file corrispondente e trova la riga esatta contenente `key: "<key>"` per posizionare il cursore in modo preciso.
-6. Restituisce un array di oggetti `Location` — uno per file sorgente.
+---
 
-La configurazione viene risolta in modo lazy e memorizzata nella cache per sessione; si reimposta su ciascuna richiesta `initialize` (ad esempio, quando si apre una nuova cartella dell'area di lavoro).
+## Come funziona
+
+Per ogni file, il server individua l'`intlayer.config.*` più vicino e carica la configurazione di quel progetto per trovare i dizionari compilati. Configurazione, dizionari ed elenco dei file sorgente sono memorizzati in cache con TTL brevi e invalidati ogni volta che cambia un file di contenuto monitorato.
+
+A ogni richiesta, il server analizza il documento (tramite [oxc](https://oxc.rs/)) ed esamina la posizione del cursore:
+
+1. **Su una stringa chiave** (`useIntlayer("home")`) → restituisce ogni file di contenuto che dichiara quella chiave, posizionato sulla sua riga `key:`.
+2. **Sull'uso di un campo** (`content.title`, una proprietà destrutturata, `t('path.to.field')`, `<Trans>`, …) → risale dalla variabile al suo dizionario e restituisce il campo corrispondente all'interno dei file di contenuto.
+3. **Da un file di contenuto** → esegue la ricerca inversa, scandendo i sorgenti del progetto alla ricerca dei punti di chiamata di quella chiave o di quel campo.
 
 ---
 
 ## Risoluzione dei problemi
 
-| Sintomo                                    | Causa probabile                    | Soluzione                                                                                            |
-| ------------------------------------------ | ---------------------------------- | ---------------------------------------------------------------------------------------------------- |
-| Vai alla definizione non fa nulla          | Il server non è in esecuzione      | Verifica che `@intlayer/lsp` sia installato e che l'editor lo stia avviando                          |
-| Rilevata radice dell'area di lavoro errata | Più cartelle dell'area di lavoro   | Assicurati che la cartella contenente `intlayer.config.ts` sia la prima cartella dell'area di lavoro |
-| Definizioni non trovate per una chiave     | Configurazione non risolta         | Verifica che `intlayer.config.ts` (o `.js`) esista nella radice dell'area di lavoro                  |
-| Il server si blocca all'avvio              | Versione di Node.js troppo vecchia | Richiede Node.js ≥ 14.18                                                                             |
+| Sintomo                                    | Causa probabile                       | Soluzione                                                                      |
+| ------------------------------------------ | ------------------------------------- | ------------------------------------------------------------------------------ |
+| Non succede assolutamente nulla            | Server non in esecuzione              | Verifica che `@intlayer/lsp` sia installato e che il tuo editor lo avvii       |
+| Funziona nell'editor, non in Claude Code   | Plugin installato a sessione avviata  | Riavvia Claude Code — i language server si caricano all'avvio                  |
+| Nessuna definizione trovata per una chiave | Dizionari non compilati               | Esegui `npx intlayer build`, oppure avvia il server di sviluppo                |
+| Ogni chiave segnalata come non dichiarata  | Configurazione non risolta            | Verifica che esista un `intlayer.config.ts` (o `.js`) alla radice del progetto |
+| Progetto sbagliato usato in un monorepo    | Manca la configurazione per pacchetto | Aggiungi un `intlayer.config.*` a ogni pacchetto che dichiara contenuti propri |
+| Il server va in crash all'avvio            | Versione di Node.js troppo vecchia    | Richiede Node.js ≥ 14.18                                                       |
+
+In VS Code il server scrive i log in **Visualizza → Output → «Intlayer LSP»** — utile per confermare quale configurazione è stata risolta e quanti dizionari sono stati trovati.