From 040b1357ae7454a7db9d81528a836a1ecca2e86c Mon Sep 17 00:00:00 2001
From: Alessandro De Blasis <alex@deblasis.net>
Date: Mon, 14 Sep 2026 20:53:18 +0000
Subject: [PATCH 1/2] translate(reference): renderToReadableStream (#674)
 (#706)

Signed-off-by: Alessandro De Blasis <alex@deblasis.net>
---
 .../server/renderToReadableStream.md          | 193 +++++++++---------
 1 file changed, 100 insertions(+), 93 deletions(-)

diff --git a/src/content/reference/react-dom/server/renderToReadableStream.md b/src/content/reference/react-dom/server/renderToReadableStream.md
index 76819184c..e6c977b2a 100644
--- a/src/content/reference/react-dom/server/renderToReadableStream.md
+++ b/src/content/reference/react-dom/server/renderToReadableStream.md
@@ -1,10 +1,17 @@
 ---
 title: renderToReadableStream
+translationStatus: ai-draft
 ---
 
+<Note>
+
+Questa pagina è stata tradotta automaticamente e supervisionata da un maintainer. Un'ulteriore revisione da parte della community sarebbe comunque utile. [Migliora questa traduzione](https://github.com/reactjs/it.react.dev/edit/main/src/content/reference/react-dom/server/renderToReadableStream.md).
+
+</Note>
+
 <Intro>
 
-`renderToReadableStream` renders a React tree to a [Readable Web Stream.](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream)
+`renderToReadableStream` renderizza un albero React in uno [Stream Web Readable.](https://developer.mozilla.org/it/docs/Web/API/ReadableStream)
 
 ```js
 const stream = await renderToReadableStream(reactNode, options?)
@@ -16,7 +23,7 @@ const stream = await renderToReadableStream(reactNode, options?)
 
 <Note>
 
-This API depends on [Web Streams.](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API) For Node.js, use [`renderToPipeableStream`](/reference/react-dom/server/renderToPipeableStream) instead.
+Questa API dipende dai [Web Streams.](https://developer.mozilla.org/it/docs/Web/API/Streams_API) Per Node.js, usa invece [`renderToPipeableStream`](/reference/react-dom/server/renderToPipeableStream).
 
 </Note>
 
@@ -26,7 +33,7 @@ This API depends on [Web Streams.](https://developer.mozilla.org/en-US/docs/Web/
 
 ### `renderToReadableStream(reactNode, options?)` {/*rendertoreadablestream*/}
 
-Call `renderToReadableStream` to render your React tree as HTML into a [Readable Web Stream.](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream)
+Chiama `renderToReadableStream` per renderizzare il tuo albero React come HTML in uno [Stream Web Readable.](https://developer.mozilla.org/it/docs/Web/API/ReadableStream)
 
 ```js
 import { renderToReadableStream } from 'react-dom/server';
@@ -41,49 +48,49 @@ async function handler(request) {
 }
 ```
 
-On the client, call [`hydrateRoot`](/reference/react-dom/client/hydrateRoot) to make the server-generated HTML interactive.
+Sul client, chiama [`hydrateRoot`](/reference/react-dom/client/hydrateRoot) per idratare l'HTML generato sul server e attivarne l'interattività.
 
-[See more examples below.](#usage)
+[Vedi altri esempi sotto.](#usage)
 
 #### Parameters {/*parameters*/}
 
-* `reactNode`: A React node you want to render to HTML. For example, a JSX element like `<App />`. It is expected to represent the entire document, so the `App` component should render the `<html>` tag.
-
-* **optional** `options`: An object with streaming options.
-  * **optional** `bootstrapScriptContent`: If specified, this string will be placed in an inline `<script>` tag.
-  * **optional** `bootstrapScripts`: An array of string URLs for the `<script>` tags to emit on the page. Use this to include the `<script>` that calls [`hydrateRoot`.](/reference/react-dom/client/hydrateRoot) Omit it if you don't want to run React on the client at all.
-  * **optional** `bootstrapModules`: Like `bootstrapScripts`, but emits [`<script type="module">`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules) instead.
-  * **optional** `formState`: The form state from a form submission handled by a [Server Function](/reference/rsc/server-functions). If the page is rendered in response to a submission of a form that uses [`useActionState`](/reference/react/useActionState) with a `permalink`, pass the resulting form state so that React embeds it into the HTML for hydration. The same value must be passed to [`hydrateRoot`](/reference/react-dom/client/hydrateRoot#parameters) on the client. This is typically passed through by your framework.
-  * **optional** `identifierPrefix`: A string prefix React uses for IDs generated by [`useId`.](/reference/react/useId) Useful to avoid conflicts when using multiple roots on the same page. Must be the same prefix as passed to [`hydrateRoot`.](/reference/react-dom/client/hydrateRoot#parameters)
-  * **optional** `importMap`: An [import map](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script/type/importmap) object with `imports` and `scopes` properties. React emits it as an inline `<script type="importmap">` tag before any module scripts, so that `<script type="module">` tags (for example, from `bootstrapModules`) can use bare module specifiers. <CanaryBadge /> When `nonce` is set, it is also applied to the import map script.
-  * **optional** `maxHeadersLength`: The maximum total length of the header content passed to `onHeaders`, measured in UTF-16 code units. Defaults to 2000. Once the limit is reached, React stops adding resource hints to the headers.
-  * **optional** `namespaceURI`: A string with the root [namespace URI](https://developer.mozilla.org/en-US/docs/Web/API/Document/createElementNS#important_namespace_uris) for the stream. Defaults to regular HTML. Pass `'http://www.w3.org/2000/svg'` for SVG or `'http://www.w3.org/1998/Math/MathML'` for MathML.
-  * **optional** `nonce`: A [`nonce`](http://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#nonce) string to allow scripts for [`script-src` Content-Security-Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src). To use different nonces for scripts and styles, pass an object with `script` and `style` properties instead.
-  * **optional** `onBrowserBailout`: A callback React calls when it recovers from [`browser()`](/reference/react-dom/browser) by leaving a Suspense fallback for the browser to replace. It receives an `Error` describing the browser-only render and an `errorInfo` object containing the `componentStack`. If a reason was passed to `browser`, it is available as `error.cause`. By default, React does nothing. [See how to report browser-only rendering.](/reference/react-dom/browser#reporting-browser-only-rendering-on-the-server)
-  * **optional** `onError`: A callback that fires whenever there is a server error, whether [recoverable](#recovering-from-errors-outside-the-shell) or [not.](#recovering-from-errors-inside-the-shell) By default, this only calls `console.error`. If you override it to [log crash reports,](#logging-crashes-on-the-server) make sure that you still call `console.error`. You can also use it to [adjust the status code](#setting-the-status-code) before the shell is emitted.
-  * **optional** `onHeaders`: A callback that fires when React has determined the resource hints for the document, such as preconnects and stylesheet, font, or high-priority image preloads. It receives a [`Headers`](https://developer.mozilla.org/en-US/docs/Web/API/Headers) instance containing the corresponding [`Link` header](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/link) value, so you can send it as an HTTP response header or as a [103 Early Hints](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/103) response. React calls it even when there are no resource hints to send. The header content is capped by `maxHeadersLength`.
-  * **optional** `progressiveChunkSize`: The number of bytes in a chunk. [Read more about the default heuristic.](https://github.com/react/react/blob/14c2be8dac2d5482fda8a0906a31d239df8551fc/packages/react-server/src/ReactFizzServer.js#L210-L225)
-  * **optional** `signal`: An [abort signal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) that lets you [abort server rendering](#aborting-server-rendering) and render the rest on the client.
+* `reactNode`: Un nodo React che vuoi renderizzare in HTML. Ad esempio, un elemento JSX come `<App />`. Si presume che rappresenti l'intero documento, quindi il componente `App` dovrebbe renderizzare il tag `<html>`.
+
+* **optional** `options`: Un oggetto con opzioni di streaming.
+  * **optional** `bootstrapScriptContent`: Se specificato, questa stringa verrà inserita in un tag `<script>` inline.
+  * **optional** `bootstrapScripts`: Un array di URL stringa per i tag `<script>` da emettere nella pagina. Usalo per includere lo `<script>` che chiama [`hydrateRoot`.](/reference/react-dom/client/hydrateRoot) Omettilo se non vuoi eseguire React sul client.
+  * **optional** `bootstrapModules`: Come `bootstrapScripts`, ma emette [`<script type="module">`](https://developer.mozilla.org/it/docs/Web/JavaScript/Guide/Modules) al posto degli script normali.
+  * **optional** `formState`: Lo state del form da un invio di form gestito da una [Server Function](/reference/rsc/server-functions). Se la pagina viene renderizzata in risposta all'invio di un form che usa [`useActionState`](/reference/react/useActionState) con un `permalink`, passa lo state del form risultante così che React lo incorpori nell'HTML per l'hydration. Lo stesso valore deve essere passato a [`hydrateRoot`](/reference/react-dom/client/hydrateRoot#parameters) sul client. Di solito viene passato dal tuo framework.
+  * **optional** `identifierPrefix`: Un prefisso stringa che React usa per gli ID generati da [`useId`.](/reference/react/useId) Utile per evitare conflitti quando usi più root sulla stessa pagina. Deve essere lo stesso prefisso passato a [`hydrateRoot`.](/reference/react-dom/client/hydrateRoot#parameters)
+  * **optional** `importMap`: Un oggetto [import map](https://developer.mozilla.org/it/docs/Web/HTML/Element/script/type/importmap) con le proprietà `imports` e `scopes`. React lo emette come tag `<script type="importmap">` inline prima di qualsiasi script di modulo, così i tag `<script type="module">` (ad esempio, da `bootstrapModules`) possono usare specificatori di modulo bare. <CanaryBadge /> Quando `nonce` è impostato, viene applicato anche allo script import map.
+  * **optional** `maxHeadersLength`: La lunghezza totale massima del contenuto dell'header passato a `onHeaders`, misurata in unità di codice UTF-16. Il valore predefinito è 2000. Una volta raggiunto il limite, React smette di aggiungere resource hint agli header.
+  * **optional** `namespaceURI`: Una stringa con l'[namespace URI](https://developer.mozilla.org/it/docs/Web/API/Document/createElementNS#important_namespace_uris) root per lo stream. Il valore predefinito è HTML normale. Passa `'http://www.w3.org/2000/svg'` per SVG o `'http://www.w3.org/1998/Math/MathML'` per MathML.
+  * **optional** `nonce`: Una stringa [`nonce`](http://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#nonce) per consentire gli script per [`script-src` Content-Security-Policy](https://developer.mozilla.org/it/docs/Web/HTTP/Headers/Content-Security-Policy/script-src). Per usare nonce diversi per script e stili, passa un oggetto con le proprietà `script` e `style`.
+  * **optional** `onBrowserBailout`: Una callback che React chiama quando recupera da [`browser()`](/reference/react-dom/browser) lasciando un fallback Suspense che il browser sostituirà. Riceve un `Error` che descrive la renderizzazione solo browser e un oggetto `errorInfo` contenente il `componentStack`. Se a `browser` è stata passata una reason, è disponibile come `error.cause`. Per impostazione predefinita, React non fa nulla. [Vedi come segnalare la renderizzazione solo browser.](/reference/react-dom/browser#reporting-browser-only-rendering-on-the-server)
+  * **optional** `onError`: Una callback che viene chiamata ogni volta che c'è un errore sul server, sia [recuperabile](#recovering-from-errors-outside-the-shell) sia [no.](#recovering-from-errors-inside-the-shell) Per impostazione predefinita, chiama solo `console.error`. Se la sovrascrivi per [registrare i crash report,](#logging-crashes-on-the-server) assicurati di chiamare comunque `console.error`. Puoi anche usarla per [regolare il codice di stato](#setting-the-status-code) prima che venga emessa la shell.
+  * **optional** `onHeaders`: Una callback che viene chiamata quando React ha determinato i resource hint per il documento, come preconnect, stylesheet, font o preload di immagini ad alta priorità. Riceve un'istanza [`Headers`](https://developer.mozilla.org/it/docs/Web/API/Headers) contenente il valore corrispondente dell'[header `Link`](https://developer.mozilla.org/it/docs/Web/HTTP/Headers/link), così puoi inviarlo come header di risposta HTTP o come risposta [103 Early Hints](https://developer.mozilla.org/it/docs/Web/HTTP/Status/103). React la chiama anche quando non ci sono resource hint da inviare. Il contenuto dell'header è limitato da `maxHeadersLength`.
+  * **optional** `progressiveChunkSize`: Il numero di byte in un chunk. [Leggi di più sull'euristica predefinita.](https://github.com/react/react/blob/14c2be8dac2d5482fda8a0906a31d239df8551fc/packages/react-server/src/ReactFizzServer.js#L210-L225)
+  * **optional** `signal`: Un [segnale di abort](https://developer.mozilla.org/it/docs/Web/API/AbortSignal) che ti permette di [interrompere la renderizzazione server](#aborting-server-rendering) e renderizzare il resto sul client.
 
 
 #### Returns {/*returns*/}
 
-`renderToReadableStream` returns a Promise:
+`renderToReadableStream` restituisce una Promise:
 
-- If rendering the [shell](#specifying-what-goes-into-the-shell) is successful, that Promise will resolve to a [Readable Web Stream.](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream)
-- If rendering the shell fails, the Promise will be rejected. [Use this to output a fallback shell.](#recovering-from-errors-inside-the-shell)
+- Se la renderizzazione della [shell](#specifying-what-goes-into-the-shell) ha successo, quella Promise verrà risolta con uno [Stream Web Readable.](https://developer.mozilla.org/it/docs/Web/API/ReadableStream)
+- Se la renderizzazione della shell fallisce, la Promise verrà rifiutata. [Usa questo per emettere una shell di fallback.](#recovering-from-errors-inside-the-shell)
 
-The returned stream has an additional property:
+Lo stream restituito ha una proprietà aggiuntiva:
 
-* `allReady`: A Promise that resolves when all rendering is complete, including both the [shell](#specifying-what-goes-into-the-shell) and all additional [content.](#streaming-more-content-as-it-loads) You can `await stream.allReady` before returning a response [for crawlers and static generation.](#waiting-for-all-content-to-load-for-crawlers-and-static-generation) If you do that, you won't get any progressive loading. The stream will contain the final HTML.
+* `allReady`: Una Promise che si risolve quando tutta la renderizzazione è completa, inclusi sia la [shell](#specifying-what-goes-into-the-shell) sia tutto il [contenuto aggiuntivo.](#streaming-more-content-as-it-loads) Puoi fare `await stream.allReady` prima di restituire una risposta [per crawler e generazione statica.](#waiting-for-all-content-to-load-for-crawlers-and-static-generation) Se lo fai, non otterrai alcun caricamento progressivo. Lo stream conterrà l'HTML finale.
 
 ---
 
 ## Usage {/*usage*/}
 
-### Rendering a React tree as HTML to a Readable Web Stream {/*rendering-a-react-tree-as-html-to-a-readable-web-stream*/}
+### Renderizzare un albero React come HTML in uno Stream Web Readable {/*rendering-a-react-tree-as-html-to-a-readable-web-stream*/}
 
-Call `renderToReadableStream` to render your React tree as HTML into a [Readable Web Stream:](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream)
+Chiama `renderToReadableStream` per renderizzare il tuo albero React come HTML in uno [Stream Web Readable:](https://developer.mozilla.org/it/docs/Web/API/ReadableStream)
 
 ```js [[1, 4, "<App />"], [2, 5, "['/main.js']"]]
 import { renderToReadableStream } from 'react-dom/server';
@@ -98,9 +105,9 @@ async function handler(request) {
 }
 ```
 
-Along with the <CodeStep step={1}>root component</CodeStep>, you need to provide a list of <CodeStep step={2}>bootstrap `<script>` paths</CodeStep>. Your root component should return **the entire document including the root `<html>` tag.**
+Insieme al <CodeStep step={1}>componente root</CodeStep>, devi fornire un elenco di <CodeStep step={2}>percorsi `<script>` bootstrap</CodeStep>. Il tuo componente root dovrebbe restituire **l'intero documento incluso il tag root `<html>`.**
 
-For example, it might look like this:
+Ad esempio, potrebbe essere così:
 
 ```js [[1, 1, "App"]]
 export default function App() {
@@ -120,17 +127,17 @@ export default function App() {
 }
 ```
 
-React will inject the [doctype](https://developer.mozilla.org/en-US/docs/Glossary/Doctype) and your <CodeStep step={2}>bootstrap `<script>` tags</CodeStep> into the resulting HTML stream:
+React inietterà il [doctype](https://developer.mozilla.org/it/docs/Glossary/Doctype) e i tuoi <CodeStep step={2}>tag `<script>` bootstrap</CodeStep> nello stream HTML risultante:
 
 ```html [[2, 5, "/main.js"]]
 <!DOCTYPE html>
 <html>
-  <!-- ... HTML from your components ... -->
+  <!-- ... HTML dai tuoi componenti ... -->
 </html>
 <script src="/main.js" async=""></script>
 ```
 
-On the client, your bootstrap script should [hydrate the entire `document` with a call to `hydrateRoot`:](/reference/react-dom/client/hydrateRoot#hydrating-an-entire-document)
+Sul client, il tuo script bootstrap dovrebbe [idratare l'intero `document` con una chiamata a `hydrateRoot`:](/reference/react-dom/client/hydrateRoot#hydrating-an-entire-document)
 
 ```js [[1, 4, "<App />"]]
 import { hydrateRoot } from 'react-dom/client';
@@ -139,15 +146,15 @@ import App from './App.js';
 hydrateRoot(document, <App />);
 ```
 
-This will attach event listeners to the server-generated HTML and make it interactive.
+Questo attaccherà i listener di eventi all'HTML generato sul server e lo renderà interattivo.
 
 <DeepDive>
 
-#### Reading CSS and JS asset paths from the build output {/*reading-css-and-js-asset-paths-from-the-build-output*/}
+#### Leggere i percorsi delle risorse CSS e JS dall'output della build {/*reading-css-and-js-asset-paths-from-the-build-output*/}
 
-The final asset URLs (like JavaScript and CSS files) are often hashed after the build. For example, instead of `styles.css` you might end up with `styles.123456.css`. Hashing static asset filenames guarantees that every distinct build of the same asset will have a different filename. This is useful because it lets you safely enable long-term caching for static assets: a file with a certain name would never change content.
+Gli URL finali delle risorse (come file JavaScript e CSS) spesso vengono hashati dopo la build. Ad esempio, invece di `styles.css` potresti finire con `styles.123456.css`. L'hashing dei nomi file delle risorse statiche garantisce che ogni build distinta della stessa risorsa avrà un nome file diverso. Questo è utile perché ti permette di abilitare in sicurezza la cache a lungo termine per le risorse statiche: un file con un certo nome non cambierà mai contenuto.
 
-However, if you don't know the asset URLs until after the build, there's no way for you to put them in the source code. For example, hardcoding `"/styles.css"` into JSX like earlier wouldn't work. To keep them out of your source code, your root component can read the real filenames from a map passed as a prop:
+Tuttavia, se non conosci gli URL delle risorse fino a dopo la build, non c'è modo di inserirli nel codice sorgente. Ad esempio, hardcodare `"/styles.css"` nel JSX come prima non funzionerebbe. Per tenerli fuori dal codice sorgente, il tuo componente root può leggere i nomi file reali da una mappa passata come prop:
 
 ```js {1,6}
 export default function App({ assetMap }) {
@@ -163,10 +170,10 @@ export default function App({ assetMap }) {
 }
 ```
 
-On the server, render `<App assetMap={assetMap} />` and pass your `assetMap` with the asset URLs:
+Sul server, renderizza `<App assetMap={assetMap} />` e passa la tua `assetMap` con gli URL delle risorse:
 
 ```js {1-5,8,9}
-// You'd need to get this JSON from your build tooling, e.g. read it from the build output.
+// Dovresti ottenere questo JSON dal tuo build tooling, ad es. leggerlo dall'output della build.
 const assetMap = {
   'styles.css': '/styles.123456.css',
   'main.js': '/main.123456.js'
@@ -182,10 +189,10 @@ async function handler(request) {
 }
 ```
 
-Since your server is now rendering `<App assetMap={assetMap} />`, you need to render it with `assetMap` on the client too to avoid hydration errors. You can serialize and pass `assetMap` to the client like this:
+Poiché il tuo server ora renderizza `<App assetMap={assetMap} />`, devi renderizzarlo con `assetMap` anche sul client per evitare errori di hydration. Puoi serializzare e passare `assetMap` al client così:
 
 ```js {9-10}
-// You'd need to get this JSON from your build tooling.
+// Dovresti ottenere questo JSON dal tuo build tooling.
 const assetMap = {
   'styles.css': '/styles.123456.css',
   'main.js': '/main.123456.js'
@@ -193,7 +200,7 @@ const assetMap = {
 
 async function handler(request) {
   const stream = await renderToReadableStream(<App assetMap={assetMap} />, {
-    // Careful: It's safe to stringify() this because this data isn't user-generated.
+    // Attenzione: è sicuro fare stringify() di questo perché questi dati non sono generati dall'utente.
     bootstrapScriptContent: `window.assetMap = ${JSON.stringify(assetMap)};`,
     bootstrapScripts: [assetMap['/main.js']],
   });
@@ -203,7 +210,7 @@ async function handler(request) {
 }
 ```
 
-In the example above, the `bootstrapScriptContent` option adds an extra inline `<script>` tag that sets the global `window.assetMap` variable on the client. This lets the client code read the same `assetMap`:
+Nell'esempio sopra, l'opzione `bootstrapScriptContent` aggiunge un tag `<script>` inline extra che imposta la variabile globale `window.assetMap` sul client. Questo permette al codice client di leggere la stessa `assetMap`:
 
 ```js {4}
 import { hydrateRoot } from 'react-dom/client';
@@ -212,15 +219,15 @@ import App from './App.js';
 hydrateRoot(document, <App assetMap={window.assetMap} />);
 ```
 
-Both client and server render `App` with the same `assetMap` prop, so there are no hydration errors.
+Sia client che server renderizzano `App` con la stessa prop `assetMap`, quindi non ci sono errori di hydration.
 
 </DeepDive>
 
 ---
 
-### Streaming more content as it loads {/*streaming-more-content-as-it-loads*/}
+### Fare streaming di più contenuto man mano che si carica {/*streaming-more-content-as-it-loads*/}
 
-Streaming allows the user to start seeing the content even before all the data has loaded on the server. For example, consider a profile page that shows a cover, a sidebar with friends and photos, and a list of posts:
+Lo streaming permette all'utente di iniziare a vedere il contenuto anche prima che tutti i dati siano stati caricati sul server. Ad esempio, considera una pagina profilo che mostra una cover, una sidebar con amici e foto, e un elenco di post:
 
 ```js
 function ProfilePage() {
@@ -237,7 +244,7 @@ function ProfilePage() {
 }
 ```
 
-Imagine that loading data for `<Posts />` takes some time. Ideally, you'd want to show the rest of the profile page content to the user without waiting for the posts. To do this, [wrap `Posts` in a `<Suspense>` boundary:](/reference/react/Suspense#displaying-a-fallback-while-content-is-loading)
+Immagina che caricare i dati per `<Posts />` richieda del tempo. Idealmente, vorresti mostrare il resto del contenuto della pagina profilo all'utente senza aspettare i post. Per farlo, [avvolgi `Posts` in un boundary `<Suspense>`:](/reference/react/Suspense#displaying-a-fallback-while-content-is-loading)
 
 ```js {9,11}
 function ProfilePage() {
@@ -256,9 +263,9 @@ function ProfilePage() {
 }
 ```
 
-This tells React to start streaming the HTML before `Posts` loads its data. React will send the HTML for the loading fallback (`PostsGlimmer`) first, and then, when `Posts` finishes loading its data, React will send the remaining HTML along with an inline `<script>` tag that replaces the loading fallback with that HTML. From the user's perspective, the page will first appear with the `PostsGlimmer`, later replaced by the `Posts`.
+Questo dice a React di iniziare a fare streaming dell'HTML prima che `Posts` carichi i suoi dati. React invierà prima l'HTML per il fallback di caricamento (`PostsGlimmer`), e poi, quando `Posts` finisce di caricare i suoi dati, React invierà l'HTML rimanente insieme a un tag `<script>` inline che sostituisce il fallback di caricamento con quell'HTML. Dal punto di vista dell'utente, la pagina apparirà prima con `PostsGlimmer`, poi sostituito da `Posts`.
 
-You can further [nest `<Suspense>` boundaries](/reference/react/Suspense#revealing-nested-content-as-it-loads) to create a more granular loading sequence:
+Puoi [annidare ulteriormente i boundary `<Suspense>`](/reference/react/Suspense#revealing-nested-content-as-it-loads) per creare una sequenza di caricamento più granulare:
 
 ```js {5,13}
 function ProfilePage() {
@@ -280,23 +287,23 @@ function ProfilePage() {
 ```
 
 
-In this example, React can start streaming the page even earlier. Only `ProfileLayout` and `ProfileCover` must finish rendering first because they are not wrapped in any `<Suspense>` boundary. However, if `Sidebar`, `Friends`, or `Photos` need to load some data, React will send the HTML for the `BigSpinner` fallback instead. Then, as more data becomes available, more content will continue to be revealed until all of it becomes visible.
+In questo esempio, React può iniziare a fare streaming della pagina ancora prima. Solo `ProfileLayout` e `ProfileCover` devono finire di renderizzare per primi perché non sono avvolti in alcun boundary `<Suspense>`. Tuttavia, se `Sidebar`, `Friends` o `Photos` devono caricare dei dati, React invierà l'HTML per il fallback `BigSpinner`. Poi, man mano che più dati diventano disponibili, più contenuto continuerà a essere rivelato finché tutto non diventa visibile.
 
-Streaming does not need to wait for React itself to load in the browser, or for your app to become interactive. The HTML content from the server will get progressively revealed before any of the `<script>` tags load.
+Lo streaming non deve aspettare che React stesso si carichi nel browser, o che la tua app diventi interattiva. Il contenuto HTML dal server verrà rivelato progressivamente prima che uno qualsiasi dei tag `<script>` si carichi.
 
-[Read more about how streaming HTML works.](https://github.com/reactwg/react-18/discussions/37)
+[Leggi di più su come funziona lo streaming HTML.](https://github.com/reactwg/react-18/discussions/37)
 
 <Note>
 
-Only data read from a source that [activates a Suspense boundary](/reference/react/Suspense#what-activates-a-suspense-boundary), such as a Promise read with [`use`](/reference/react/use), will suspend during rendering. Suspense does not detect data fetched inside an Effect or event handler.
+Solo i dati letti da una fonte che [attiva un boundary Suspense](/reference/react/Suspense#what-activates-a-suspense-boundary), come una Promise letta con [`use`](/reference/react/use), andranno in sospensione durante la renderizzazione. Suspense non rileva i dati recuperati all'interno di un Effetto o di un gestore di eventi.
 
 </Note>
 
 ---
 
-### Specifying what goes into the shell {/*specifying-what-goes-into-the-shell*/}
+### Specificare cosa va nella shell {/*specifying-what-goes-into-the-shell*/}
 
-The part of your app outside of any `<Suspense>` boundaries is called *the shell:*
+La parte della tua app al di fuori di qualsiasi boundary `<Suspense>` è chiamata *shell:*
 
 ```js {3-5,13,14}
 function ProfilePage() {
@@ -317,7 +324,7 @@ function ProfilePage() {
 }
 ```
 
-It determines the earliest loading state that the user may see:
+Determina la fase di caricamento più precoce che l'utente può vedere:
 
 ```js {3-5,13
 <ProfileLayout>
@@ -326,9 +333,9 @@ It determines the earliest loading state that the user may see:
 </ProfileLayout>
 ```
 
-If you wrap the whole app into a `<Suspense>` boundary at the root, the shell will only contain that spinner. However, that's not a pleasant user experience because seeing a big spinner on the screen can feel slower and more annoying than waiting a bit more and seeing the real layout. This is why usually you'll want to place the `<Suspense>` boundaries so that the shell feels *minimal but complete*--like a skeleton of the entire page layout.
+Se avvolgi l'intera app in un boundary `<Suspense>` alla root, la shell conterrà solo quello spinner. Tuttavia, non è un'esperienza utente piacevole perché vedere un grande spinner sullo schermo può sembrare più lento e fastidioso che aspettare un po' di più e vedere il layout reale. Ecco perché di solito vorrai posizionare i boundary `<Suspense>` in modo che la shell risulti *minima ma completa* — come uno skeleton dell'intero layout della pagina.
 
-The async call to `renderToReadableStream` will resolve to a `stream` as soon as the entire shell has been rendered. Usually, you'll start streaming then by creating and returning a response with that `stream`:
+La chiamata asincrona a `renderToReadableStream` verrà risolta con uno `stream` non appena l'intera shell è stata renderizzata. Di solito, inizierai lo streaming allora creando e restituendo una risposta con quello `stream`:
 
 ```js {5}
 async function handler(request) {
@@ -341,13 +348,13 @@ async function handler(request) {
 }
 ```
 
-By the time the `stream` is returned, components in nested `<Suspense>` boundaries might still be loading data.
+Quando lo `stream` viene restituito, i componenti nei boundary `<Suspense>` annidati potrebbero ancora essere in fase di caricamento dati.
 
 ---
 
-### Logging crashes on the server {/*logging-crashes-on-the-server*/}
+### Registrare i crash sul server {/*logging-crashes-on-the-server*/}
 
-By default, all errors on the server are logged to console. You can override this behavior to log crash reports:
+Per impostazione predefinita, tutti gli errori sul server vengono registrati nella console. Puoi sovrascrivere questo comportamento per registrare i crash report:
 
 ```js {4-7}
 async function handler(request) {
@@ -364,13 +371,13 @@ async function handler(request) {
 }
 ```
 
-If you provide a custom `onError` implementation, don't forget to also log errors to the console like above.
+Se fornisci un'implementazione personalizzata di `onError`, non dimenticare di registrare anche gli errori nella console come sopra.
 
 ---
 
-### Recovering from errors inside the shell {/*recovering-from-errors-inside-the-shell*/}
+### Recuperare dagli errori all'interno della shell {/*recovering-from-errors-inside-the-shell*/}
 
-In this example, the shell contains `ProfileLayout`, `ProfileCover`, and `PostsGlimmer`:
+In questo esempio, la shell contiene `ProfileLayout`, `ProfileCover` e `PostsGlimmer`:
 
 ```js {3-5,7-8}
 function ProfilePage() {
@@ -385,7 +392,7 @@ function ProfilePage() {
 }
 ```
 
-If an error occurs while rendering those components, React won't have any meaningful HTML to send to the client. Wrap your `renderToReadableStream` call in a `try...catch` to send a fallback HTML that doesn't rely on server rendering as the last resort:
+Se si verifica un errore durante la renderizzazione di quei componenti, React non avrà HTML significativo da inviare al client. Avvolgi la tua chiamata a `renderToReadableStream` in un `try...catch` per inviare un HTML di fallback che non dipenda dalla renderizzazione server come ultima risorsa:
 
 ```js {2,13-18}
 async function handler(request) {
@@ -409,13 +416,13 @@ async function handler(request) {
 }
 ```
 
-If there is an error while generating the shell, both `onError` and your `catch` block will fire. Use `onError` for error reporting and use the `catch` block to send the fallback HTML document. Your fallback HTML does not have to be an error page. Instead, you may include an alternative shell that renders your app on the client only.
+Se c'è un errore durante la generazione della shell, verranno chiamati sia `onError` sia il tuo blocco `catch`. Usa `onError` per la segnalazione degli errori e il blocco `catch` per inviare il documento HTML di fallback. Il tuo HTML di fallback non deve essere una pagina di errore. Puoi invece includere una shell alternativa che renderizza la tua app solo sul client.
 
 ---
 
-### Recovering from errors outside the shell {/*recovering-from-errors-outside-the-shell*/}
+### Recuperare dagli errori al di fuori della shell {/*recovering-from-errors-outside-the-shell*/}
 
-In this example, the `<Posts />` component is wrapped in `<Suspense>` so it is *not* a part of the shell:
+In questo esempio, il componente `<Posts />` è avvolto in `<Suspense>` quindi *non* fa parte della shell:
 
 ```js {6}
 function ProfilePage() {
@@ -430,23 +437,23 @@ function ProfilePage() {
 }
 ```
 
-If an error happens in the `Posts` component or somewhere inside it, React will [try to recover from it:](/reference/react/Suspense#providing-a-fallback-for-server-errors-and-client-only-content)
+Se si verifica un errore nel componente `Posts` o da qualche parte al suo interno, React [proverà a recuperare:](/reference/react/Suspense#providing-a-fallback-for-server-errors-and-client-only-content)
 
-1. It will emit the loading fallback for the closest `<Suspense>` boundary (`PostsGlimmer`) into the HTML.
-2. It will "give up" on trying to render the `Posts` content on the server anymore.
-3. When the JavaScript code loads on the client, React will *retry* rendering `Posts` on the client.
+1. Emetterà il fallback di caricamento per il boundary `<Suspense>` più vicino (`PostsGlimmer`) nell'HTML.
+2. "Rinuncerà" a provare a renderizzare il contenuto di `Posts` sul server.
+3. Quando il codice JavaScript si carica sul client, React *riproverà* a renderizzare `Posts` sul client.
 
-If retrying rendering `Posts` on the client *also* fails, React will throw the error on the client. As with all the errors thrown during rendering, the [closest parent error boundary](/reference/react/Component#static-getderivedstatefromerror) determines how to present the error to the user. In practice, this means that the user will see a loading indicator until it is certain that the error is not recoverable.
+Se anche riprovare a renderizzare `Posts` sul client *fallisce*, React lancerà l'errore sul client. Come con tutti gli errori lanciati durante la renderizzazione, il [contenitore di errori padre più vicino](/reference/react/Component#static-getderivedstatefromerror) determina come presentare l'errore all'utente. In pratica, questo significa che l'utente vedrà un indicatore di caricamento finché non è certo che l'errore non sia recuperabile.
 
-If retrying rendering `Posts` on the client succeeds, the loading fallback from the server will be replaced with the client rendering output. The user will not know that there was a server error. However, the server `onError` callback and the client [`onRecoverableError`](/reference/react-dom/client/hydrateRoot#hydrateroot) callbacks will fire so that you can get notified about the error.
+Se riprovare a renderizzare `Posts` sul client ha successo, il fallback di caricamento dal server verrà sostituito con l'output della renderizzazione client. L'utente non saprà che c'è stato un errore sul server. Tuttavia, la callback server `onError` e le callback client [`onRecoverableError`](/reference/react-dom/client/hydrateRoot#hydrateroot) verranno chiamate così che tu possa essere notificato dell'errore.
 
 ---
 
-### Setting the status code {/*setting-the-status-code*/}
+### Impostare il codice di stato {/*setting-the-status-code*/}
 
-Streaming introduces a tradeoff. You want to start streaming the page as early as possible so that the user can see the content sooner. However, once you start streaming, you can no longer set the response status code.
+Lo streaming introduce un compromesso. Vuoi iniziare a fare streaming della pagina il prima possibile così che l'utente possa vedere il contenuto prima. Tuttavia, una volta iniziato lo streaming, non puoi più impostare il codice di stato della risposta.
 
-By [dividing your app](#specifying-what-goes-into-the-shell) into the shell (above all `<Suspense>` boundaries) and the rest of the content, you've already solved a part of this problem. If the shell errors, your `catch` block will run which lets you set the error status code. Otherwise, you know that the app may recover on the client, so you can send "OK".
+[Dividendo la tua app](#specifying-what-goes-into-the-shell) nella shell (sopra tutti i boundary `<Suspense>`) e nel resto del contenuto, hai già risolto parte di questo problema. Se la shell va in errore, verrà eseguito il tuo blocco `catch` che ti permette di impostare il codice di stato di errore. Altrimenti, sai che l'app può recuperare sul client, quindi puoi inviare "OK".
 
 ```js {11}
 async function handler(request) {
@@ -471,9 +478,9 @@ async function handler(request) {
 }
 ```
 
-If a component *outside* the shell (i.e. inside a `<Suspense>` boundary) throws an error, React will not stop rendering. This means that the `onError` callback will fire, but your code will continue running without getting into the `catch` block. This is because React will try to recover from that error on the client, [as described above.](#recovering-from-errors-outside-the-shell)
+Se un componente *al di fuori* della shell (cioè all'interno di un boundary `<Suspense>`) lancia un errore, React non smetterà di renderizzare. Questo significa che la callback `onError` verrà chiamata, ma il tuo codice continuerà a essere eseguito senza entrare nel blocco `catch`. Questo perché React proverà a recuperare da quell'errore sul client, [come descritto sopra.](#recovering-from-errors-outside-the-shell)
 
-However, if you'd like, you can use the fact that something has errored to set the status code:
+Tuttavia, se vuoi, puoi usare il fatto che qualcosa è andato in errore per impostare il codice di stato:
 
 ```js {3,7,13}
 async function handler(request) {
@@ -500,13 +507,13 @@ async function handler(request) {
 }
 ```
 
-This will only catch errors outside the shell that happened while generating the initial shell content, so it's not exhaustive. If knowing whether an error occurred for some content is critical, you can move it up into the shell.
+Questo catturerà solo gli errori al di fuori della shell che si sono verificati durante la generazione del contenuto iniziale della shell, quindi non è esaustivo. Se sapere se si è verificato un errore per un certo contenuto è critico, puoi spostarlo nella shell.
 
 ---
 
-### Handling different errors in different ways {/*handling-different-errors-in-different-ways*/}
+### Gestire errori diversi in modi diversi {/*handling-different-errors-in-different-ways*/}
 
-You can [create your own `Error` subclasses](https://javascript.info/custom-errors) and use the [`instanceof`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof) operator to check which error is thrown. For example, you can define a custom `NotFoundError` and throw it from your component. Then you can save the error in `onError` and do something different before returning the response depending on the error type:
+Puoi [creare le tue sottoclassi di `Error`](https://javascript.info/custom-errors) e usare l'operatore [`instanceof`](https://developer.mozilla.org/it/docs/Web/JavaScript/Reference/Operators/instanceof) per verificare quale errore viene lanciato. Ad esempio, puoi definire un `NotFoundError` personalizzato e lanciarlo dal tuo componente. Poi puoi salvare l'errore in `onError` e fare qualcosa di diverso prima di restituire la risposta a seconda del tipo di errore:
 
 ```js {2-3,5-15,22,28,33}
 async function handler(request) {
@@ -548,17 +555,17 @@ async function handler(request) {
 }
 ```
 
-Keep in mind that once you emit the shell and start streaming, you can't change the status code.
+Tieni presente che una volta emessa la shell e iniziato lo streaming, non puoi cambiare il codice di stato.
 
 ---
 
-### Waiting for all content to load for crawlers and static generation {/*waiting-for-all-content-to-load-for-crawlers-and-static-generation*/}
+### Aspettare che tutto il contenuto si carichi per crawler e generazione statica {/*waiting-for-all-content-to-load-for-crawlers-and-static-generation*/}
 
-Streaming offers a better user experience because the user can see the content as it becomes available.
+Lo streaming offre una migliore esperienza utente perché l'utente può vedere il contenuto man mano che diventa disponibile.
 
-However, when a crawler visits your page, or if you're generating the pages at the build time, you might want to let all of the content load first and then produce the final HTML output instead of revealing it progressively.
+Tuttavia, quando un crawler visita la tua pagina, o se stai generando le pagine al momento della build, potresti voler lasciare che tutto il contenuto si carichi prima e poi produrre l'output HTML finale invece di rivelarlo progressivamente.
 
-You can wait for all the content to load by awaiting the `stream.allReady` Promise:
+Puoi aspettare che tutto il contenuto si carichi facendo `await` sulla Promise `stream.allReady`:
 
 ```js {12-15}
 async function handler(request) {
@@ -572,7 +579,7 @@ async function handler(request) {
         logServerCrashReport(error);
       }
     });
-    let isCrawler = // ... depends on your bot detection strategy ...
+    let isCrawler = // ... dipende dalla tua strategia di rilevamento bot ...
     if (isCrawler) {
       await stream.allReady;
     }
@@ -589,13 +596,13 @@ async function handler(request) {
 }
 ```
 
-A regular visitor will get a stream of progressively loaded content. A crawler will receive the final HTML output after all the data loads. However, this also means that the crawler will have to wait for *all* data, some of which might be slow to load or error. Depending on your app, you could choose to send the shell to the crawlers too.
+Un visitatore normale riceverà uno stream di contenuto caricato progressivamente. Un crawler riceverà l'output HTML finale dopo che tutti i dati si sono caricati. Tuttavia, questo significa anche che il crawler dovrà aspettare *tutti* i dati, alcuni dei quali potrebbero essere lenti da caricare o andare in errore. A seconda della tua app, potresti scegliere di inviare la shell anche ai crawler.
 
 ---
 
-### Aborting server rendering {/*aborting-server-rendering*/}
+### Interrompere la renderizzazione server {/*aborting-server-rendering*/}
 
-You can force the server rendering to "give up" after a timeout:
+Puoi forzare la renderizzazione server a "rinunciare" dopo un timeout:
 
 ```js {3,4-6,9}
 async function handler(request) {
@@ -617,4 +624,4 @@ async function handler(request) {
     // ...
 ```
 
-React will flush the remaining loading fallbacks as HTML, and will attempt to render the rest on the client.
+React svuoterà i fallback di caricamento rimanenti come HTML e proverà a renderizzare il resto sul client.

From fc6ca6e668004d06ce3650aa14af6fbb4bca4c95 Mon Sep 17 00:00:00 2001
From: Alessandro De Blasis <alex@deblasis.net>
Date: Mon, 14 Sep 2026 23:53:24 +0300
Subject: [PATCH 2/2] translate(reference): renderToStaticMarkup (#675)

Signed-off-by: Alessandro De Blasis <alex@deblasis.net>
---
 .../react-dom/server/renderToStaticMarkup.md  | 41 +++++++++++--------
 1 file changed, 24 insertions(+), 17 deletions(-)

diff --git a/src/content/reference/react-dom/server/renderToStaticMarkup.md b/src/content/reference/react-dom/server/renderToStaticMarkup.md
index 2b9178d55..962500403 100644
--- a/src/content/reference/react-dom/server/renderToStaticMarkup.md
+++ b/src/content/reference/react-dom/server/renderToStaticMarkup.md
@@ -1,10 +1,17 @@
 ---
 title: renderToStaticMarkup
+translationStatus: ai-draft
 ---
 
+<Note>
+
+Questa pagina è stata tradotta automaticamente e supervisionata da un maintainer. Un'ulteriore revisione da parte della community sarebbe comunque utile. [Migliora questa traduzione](https://github.com/reactjs/it.react.dev/edit/main/src/content/reference/react-dom/server/renderToStaticMarkup.md).
+
+</Note>
+
 <Intro>
 
-`renderToStaticMarkup` renders a non-interactive React tree to an HTML string.
+`renderToStaticMarkup` renderizza un albero React non interattivo in una stringa HTML.
 
 ```js
 const html = renderToStaticMarkup(reactNode, options?)
@@ -20,7 +27,7 @@ const html = renderToStaticMarkup(reactNode, options?)
 
 ### `renderToStaticMarkup(reactNode, options?)` {/*rendertostaticmarkup*/}
 
-On the server, call `renderToStaticMarkup` to render your app to HTML.
+Sul server, chiama `renderToStaticMarkup` per renderizzare la tua app in HTML.
 
 ```js
 import { renderToStaticMarkup } from 'react-dom/server';
@@ -28,52 +35,52 @@ import { renderToStaticMarkup } from 'react-dom/server';
 const html = renderToStaticMarkup(<Page />);
 ```
 
-It will produce non-interactive HTML output of your React components.
+Produrrà un output HTML non interattivo dei tuoi componenti React.
 
-[See more examples below.](#usage)
+[Vedi altri esempi sotto.](#usage)
 
 #### Parameters {/*parameters*/}
 
-* `reactNode`: A React node you want to render to HTML. For example, a JSX node like `<Page />`.
-* **optional** `options`: An object for server render.
-  * **optional** `identifierPrefix`: A string prefix React uses for IDs generated by [`useId`.](/reference/react/useId) Useful to avoid conflicts when using multiple roots on the same page.
+* `reactNode`: Un nodo React che vuoi renderizzare in HTML. Ad esempio, un elemento JSX come `<Page />`.
+* **optional** `options`: Un oggetto per la renderizzazione sul server.
+  * **optional** `identifierPrefix`: Un prefisso stringa che React usa per gli ID generati da [`useId`.](/reference/react/useId) Utile per evitare conflitti quando usi più root sulla stessa pagina.
 
 #### Returns {/*returns*/}
 
-An HTML string.
+Una stringa HTML.
 
 #### Caveats {/*caveats*/}
 
-* `renderToStaticMarkup` output cannot be hydrated.
+* L'output di `renderToStaticMarkup` non supporta l'hydration.
 
-* `renderToStaticMarkup` has limited Suspense support. If a component suspends, `renderToStaticMarkup` immediately sends its fallback as HTML.
+* `renderToStaticMarkup` ha un supporto limitato a Suspense. Se un componente sospende, `renderToStaticMarkup` invia immediatamente il suo fallback come HTML.
 
-* `renderToStaticMarkup` works in the browser, but using it in the client code is not recommended. If you need to render a component to HTML in the browser, [get the HTML by rendering it into a DOM node.](/reference/react-dom/server/renderToString#removing-rendertostring-from-the-client-code)
+* `renderToStaticMarkup` funziona nel browser, ma usarlo nel codice client non è consigliato. Se devi renderizzare un componente in HTML nel browser, [ottieni l'HTML renderizzandolo in un nodo DOM.](/reference/react-dom/server/renderToString#removing-rendertostring-from-the-client-code)
 
 ---
 
 ## Usage {/*usage*/}
 
-### Rendering a non-interactive React tree as HTML to a string {/*rendering-a-non-interactive-react-tree-as-html-to-a-string*/}
+### Renderizzare un albero React non interattivo come HTML in una stringa {/*rendering-a-non-interactive-react-tree-as-html-to-a-string*/}
 
-Call `renderToStaticMarkup` to render your app to an HTML string which you can send with your server response:
+Chiama `renderToStaticMarkup` per renderizzare la tua app in una stringa HTML che puoi inviare con la risposta del server:
 
 ```js {5-6}
 import { renderToStaticMarkup } from 'react-dom/server';
 
-// The route handler syntax depends on your backend framework
+// La sintassi del route handler dipende dal tuo framework backend
 app.use('/', (request, response) => {
   const html = renderToStaticMarkup(<Page />);
   response.send(html);
 });
 ```
 
-This will produce the initial non-interactive HTML output of your React components.
+Questo produrrà l'output HTML non interattivo iniziale dei tuoi componenti React.
 
 <Pitfall>
 
-This method renders **non-interactive HTML that cannot be hydrated.**  This is useful if you want to use React as a simple static page generator, or if you're rendering completely static content like emails.
+Questo metodo renderizza **HTML non interattivo che non supporta l'hydration.** È utile se vuoi usare React come semplice generatore di pagine statiche, o se renderizzi contenuto completamente statico come email.
 
-Interactive apps should use [`renderToString`](/reference/react-dom/server/renderToString) on the server and [`hydrateRoot`](/reference/react-dom/client/hydrateRoot) on the client.
+Le app interattive dovrebbero usare [`renderToString`](/reference/react-dom/server/renderToString) sul server e [`hydrateRoot`](/reference/react-dom/client/hydrateRoot) sul client.
 
 </Pitfall>