sync languages

Author: AGulev

docs/en/en.json

@@ -1480,7 +1480,7 @@
                         "name": "Text nodes"
                     },
                     {
-                        "path": "/manuals/labels",
+                        "path": "/manuals/label",
                         "name": "Label components"
                     }
                 ]

docs/es/manuals/addressing.md

@@ -14,7 +14,7 @@ Defold usa direcciones (o URL, cómo se mostrará más adelante) para referencia
 
 ```lua
 local id = factory.create("#enemy_factory")
-label.set_text("my_gameobject#my_label", "Hello World!")
+go.set("my_gameobject#my_label", "text", "Hello World!")
 
 local pos = go.get_position("my_gameobject")
 go.set_position(pos, "/level/stuff/other_gameobject")

docs/es/manuals/android.md

@@ -85,6 +85,41 @@ Para que esta funcionalidad funcione, necesitarás tener *ADB* instalado y *USB
 
 Un archivo *.aab* se puede subir a Google Play mediante la [consola para desarrolladores de Google Play](https://play.google.com/apps/publish/). También es posible generar un archivo *`.apk`* a partir de un archivo *.aab* para instalarlo localmente usando [Android bundletool](https://developer.android.com/studio/command-line/bundletool).
 
+## Reducir el código Java con R8 {#shrinking-java-code-with-r8}
+
+R8 reduce el tamaño del código Java mediante eliminación de código no usado, optimización y ofuscación.
+
+### Activar R8 {#enabling-r8}
+
+Selecciona `/builtins/manifests/android/dmengine.keep` en **Android ▸ R8 Keep Rules** en *game.project*. Esto usa directamente las reglas predeterminadas de Defold:
+
+```ini
+[android]
+r8_keep_rules = /builtins/manifests/android/dmengine.keep
+```
+
+Asegúrate de que cada extensión con código Java proporcione un archivo `.keep` para las clases que necesita en runtime. Las reglas de las extensiones se combinan con las reglas del proyecto seleccionadas al compilar. Prueba una build de release en un dispositivo después de activar R8.
+
+Dejar **R8 Keep Rules** vacío usa D8 sin eliminar código. Al activar R8 se usa el servicio de compilación de extensiones nativas, incluso en un proyecto sin extensiones nativas.
+
+### Agregar reglas a una extensión {#adding-rules-to-an-extension}
+
+Las reglas de conservación de una extensión van en su directorio `manifests/android`, junto a `build.gradle`. Consulta [reglas de conservación de R8 para extensiones de Android](/manuals/extensions/#r8-keep-rules-for-android) para saber cómo agregar un archivo y conservar las clases Java de la extensión.
+
+### Conservar el mapa de ofuscación {#keeping-the-obfuscation-mapping}
+
+Activa **Generate debug symbols** en el diálogo de bundle de Android, o pasa `--with-symbols` a Bob, para conservar el archivo `mapping.txt` de R8 cuando la build lo genere. Por ejemplo, desde el directorio del proyecto:
+
+```sh
+java -jar bob.jar --platform arm64-android --variant release \
+  --archive --with-symbols --bundle-output build/android \
+  resolve build bundle
+```
+
+El mapa se guarda como `<binary-name>.apk.symbols/mapping.txt` junto al APK o AAB generado. Por ejemplo, con el título de proyecto `My Game`, el comando anterior genera `build/android/MyGame/MyGame.apk.symbols/mapping.txt`.
+
+Guarda el archivo de mapa junto a la release exacta de la que procede. Permite relacionar los nombres Java ofuscados con los originales para interpretar trazas de pila; un mapa de otra build puede dar resultados incorrectos.
+
 ## Permisos
 
 El motor Defold requiere varios permisos para que funcionen todas sus funcionalidades. Los permisos se definen en `AndroidManifest.xml`, especificado en el [archivo de configuración del proyecto](/manuals/project-settings/#android) *game.project*. Puedes leer más sobre los permisos de Android en [la documentación oficial](https://developer.android.com/guide/topics/permissions/overview). En el manifiesto predeterminado se solicitan los siguientes permisos:

docs/es/manuals/app-manifest.md

@@ -76,6 +76,21 @@ Incluye soporte para recursos de sonido Ogg Opus. El decodificador Opus se exclu
 Excluye todo el manejo de input del motor.
 
 
+## Excluir GUI (`Exclude GUI`) {#exclude-gui}
+
+Elimina del motor los recursos, componentes y soporte Lua de GUI. Activa esta opción solo si el proyecto no usa escenas ni scripts GUI. Los componentes Label siguen disponibles. Esta opción está desactivada de forma predeterminada.
+
+
+## Excluir efectos de partículas (`Exclude Particle FX`) {#exclude-particle-fx}
+
+Elimina los recursos y componentes de efectos de partículas y el módulo Lua `particlefx`. También elimina el soporte de nodos de partículas en escenas GUI; las escenas GUI sin nodos de partículas siguen siendo compatibles. Elimina las referencias a efectos de partículas y las llamadas a sus APIs antes de activar esta opción. Está desactivada de forma predeterminada.
+
+
+## Excluir tilemaps (`Exclude Tilemaps`) {#exclude-tilemaps}
+
+Elimina los recursos y componentes de tilemap y el módulo Lua `tilemap`. Activa esta opción solo si el proyecto no usa componentes tilemap ni sus APIs. Las tile sources usadas por otros componentes siguen disponibles. Esta opción está desactivada de forma predeterminada.
+
+
 ## Excluir Live Update (`Exclude Live Update`)
 
 Excluye la [funcionalidad Live Update](/manuals/live-update) del motor.
@@ -117,7 +132,12 @@ En Linux ARM64, la opción **OpenGL** usa el backend OpenGL ES. En Android, la o
 
 ## Usar el sistema completo de layout de texto (`Use full text layout system`)
 
-Si está activado (`true`), permite usar la generación en runtime para fuentes de tipo SDF al usar True Type Fonts (`.ttf`) en el proyecto. Lee más detalles en el [manual de fuentes](https://defold.com/manuals/font/#enabling-runtime-fonts).
+Si está activado (`true`), incluye el sistema completo de layout de texto para dar forma al texto, incluidos los idiomas de derecha a izquierda. Activa esta opción junto con `font.runtime_generation` en *game.project* para usar la generación en runtime de fuentes SDF a partir de recursos TrueType (`.ttf`) u OpenType (`.otf`). La generación en runtime a partir de recursos `.otf` está disponible desde Defold 1.13.2. Lee más en el [manual de fuentes](/manuals/font/#enabling-runtime-fonts).
+
+
+## Usar texto enriquecido (`Use Rich Text`) {#use-rich-text}
+
+Incluye el análisis de marcado de texto enriquecido y efectos de estilo para labels y texto GUI. Esta opción está activada de forma predeterminada. Desactívala para reducir el tamaño del motor cuando el proyecto solo necesite texto sin formato. Los labels y el texto GUI siguen siendo compatibles, pero el marcado se muestra como texto sin formato en lugar de aplicar formato o efectos.
 
 
 ## Versiones mínimas del navegador

docs/es/manuals/editor-http-api.md

@@ -34,7 +34,7 @@ El argumento opcional `--port` o `-p` selecciona el puerto del servidor del edit
 C:\path\to\Defold\Defold.exe --port 8181 C:\absolute\path\to\project\game.project
 ```
 
-El editor es una aplicación gráfica de escritorio. Inícialo en una sesión de usuario interactiva con acceso a la pantalla. Utiliza [Bob](/manuals/bob) cuando no haya una sesión gráfica disponible, como en un entorno de CI headless, o para automatizar únicamente la compilación y crear bundles independientes.
+El editor es una aplicación gráfica de escritorio. Inícialo en una sesión de usuario interactiva con acceso a la pantalla. Utiliza [Bob](/manuals/bob) cuando no haya una sesión gráfica disponible, como en un entorno de CI headless, o para crear bundles independientes. Un editor abierto también admite automatizar únicamente la compilación mediante `/command/compile`.
 
 Después de iniciar el editor, espera hasta que el proyecto se haya abierto y exista `.internal/editor.port`. A continuación, consulta periódicamente `/openapi.json` hasta que devuelva un documento válido. No des por sentado que el proyecto está listo solo porque se haya creado el proceso.
 
@@ -80,39 +80,53 @@ curl -sS "$BASE_URL/openapi.json" |
   jq -r '.paths | keys[]'
 ```
 
-Muestra los comandos disponibles del editor:
+Muestra las rutas documentadas de los comandos del editor:
 
 ```sh
 curl -sS "$BASE_URL/openapi.json" |
-  jq -r '
-    .paths["/command/{command}"].post.parameters[]
-    | select(.name == "command")
-    | .schema.enum[]
-  '
+  jq -r '.paths | keys[] | select(startswith("/command/"))'
 ```
 
+En Defold 1.13.2 y posteriores, cada comando tiene su propia ruta en el documento OpenAPI. Las versiones anteriores describen los comandos mediante una ruta `/command/{command}` y una enumeración de nombres de comandos.
+
 Una integración que tenga en cuenta la versión debe verificar cada operación necesaria y configurar las solicitudes según el esquema devuelto. No recomendamos mantener una copia supuestamente exhaustiva de los nombres de endpoints o comandos, ya que puede quedar obsoleta.
 
 Las rutas definidas por el proyecto también aparecen en `/openapi.json` cuando sus scripts del editor proporcionan una descripción de la operación OpenAPI.
 
 ## Ejecutar comandos del editor
 
-Los comandos del editor se invocan mediante:
+Invoca los comandos del editor enviando una solicitud `POST` a la ruta documentada del comando, por ejemplo:
 
 ```text
-POST /command/{command}
+POST /command/compile
+POST /command/run
+```
+
+Para compilar el proyecto sin ejecutarlo:
+
+```sh
+curl -sS \
+  -X POST \
+  "$BASE_URL/command/compile" |
+  jq
 ```
 
-Por ejemplo, el comando `build` actual compila y ejecuta el proyecto:
+Para compilar y ejecutar el proyecto:
 
 ```sh
 curl -sS \
   -X POST \
-  "$BASE_URL/command/build" |
+  "$BASE_URL/command/run" |
   jq
 ```
 
-Una build correcta devuelve un resultado estructurado:
+Estas tuberías muestran el cuerpo de la respuesta. En los scripts de automatización, comprueba también el estado HTTP y `success`, siguiendo el patrón de [crear una build HTML5](#building-html5).
+
+::: sidenote
+Desde Defold 1.13.2, `/command/build` es un alias de compatibilidad obsoleto de `/command/run` y no aparece en OpenAPI. Usa `/command/run` en nuevas integraciones.
+:::
+
+Una compilación correcta devuelve el estado HTTP `200` con un resultado estructurado:
 
 ```json
 {
@@ -150,7 +164,10 @@ Los campos disponibles dependen del error. Utiliza la ruta del recurso y el rang
 
 Entre los comandos que suelen resultar útiles, cuando aparecen en el editor en ejecución, se incluyen:
 
-`build`
+`compile`
+: Compila el proyecto sin ejecutarlo.
+
+`run`
 : Compila y ejecuta el proyecto.
 
 `clean-build`
@@ -177,7 +194,9 @@ Los comandos que operan sobre recursos del proyecto sincronizan los cambios exte
 
 ### Respuestas de comandos y trabajo asíncrono
 
-La operación del comando documenta los códigos de respuesta en el esquema OpenAPI actual.
+Las respuestas dependen del comando. En Defold 1.13.2 y posteriores, `compile`, `run`, `clean-build`, `build-html5`, `debugger-start` y `hot-reload` esperan a que finalice el comando y devuelven un resultado estructurado con `success` e `issues`, como se muestra arriba. Un resultado correcto devuelve HTTP `200`; un fallo de compilación o validación devuelve `422`.
+
+Otros comandos aún pueden devolver `202`, por ejemplo `debugger-break`. Consulta la operación en el esquema OpenAPI actual y gestiona el estado HTTP real de la respuesta:
 
 | Estado | Significado |
 | --- | --- |
@@ -192,21 +211,36 @@ Una respuesta HTTP `202` no demuestra que el resultado solicitado exista. Espera
 
 ### Crear una build HTML5 {#building-html5}
 
-Si el documento OpenAPI actual incluye `build-html5`, invócalo mediante la operación del comando:
+Si el documento OpenAPI actual incluye `/command/build-html5`, invócalo mediante esa ruta. En un script de shell, captura el estado HTTP por separado del cuerpo de la respuesta y detente si falla la solicitud o la build:
 
 ```sh
-curl -sS \
+build_response_file="$(mktemp)" || exit 1
+if ! build_http_status="$(curl -sS \
   -X POST \
-  "$BASE_URL/command/build-html5"
+  -o "$build_response_file" \
+  -w '%{http_code}' \
+  "$BASE_URL/command/build-html5")"; then
+  cat "$build_response_file"
+  rm -f "$build_response_file"
+  exit 1
+fi
+
+cat "$build_response_file"
+if [ "$build_http_status" != "200" ] ||
+   ! jq -e '.success == true' "$build_response_file" > /dev/null; then
+  rm -f "$build_response_file"
+  exit 1
+fi
+rm -f "$build_response_file"
 ```
 
-El comando se ejecuta de forma asíncrona y normalmente devuelve el estado HTTP `202`. Una vez finalizada la build, el editor la sirve en:
+En Defold 1.13.2 y posteriores, esta solicitud espera a que termine la build y devuelve un resultado estructurado. El ejemplo imprime el cuerpo de la respuesta, incluidas las incidencias de compilación, y continúa solo con HTTP `200` y `success: true`. Después de una build correcta, el editor abre el juego en un navegador y lo sirve en:
 
 ```text
 http://127.0.0.1:<editor-port>/html5/
 ```
 
-Espera a que la URL esté disponible antes de iniciar las pruebas de navegador. Consulta [Pruebas de navegador para HTML5](/manuals/automated-testing/#browser-tests-for-html5) para obtener más detalles.
+Que la build haya terminado no significa que el juego haya terminado de cargar en el navegador. Espera a que el canvas y la aplicación estén listos antes de enviar input o comprobar el funcionamiento del juego. Consulta [pruebas de navegador para HTML5](/manuals/automated-testing/#browser-tests-for-html5) para obtener más detalles.
 
 ## Buscar en la documentación de la API
 

docs/es/manuals/editor-preferences.md

@@ -62,6 +62,10 @@ Auto-insert closing parens
 : Inserta automáticamente los caracteres de cierre correspondientes al editar código. Esta opción está activada de forma predeterminada.
 
 
+Format on save
+: Ejecuta el formateador del servidor de lenguaje en los archivos de código abiertos y modificados al guardar. Está desactivado de forma predeterminada. El servidor de lenguaje debe admitir el formateo; consulta [formatear código](/manuals/writing-code/#formatting-code) para formatear un documento o una selección manualmente.
+
+
 ### Abrir archivos script en Visual Studio Code {#open-script-files-in-visual-studio-code}
 
 ![](images/editor/preferences_vscode.png)

docs/es/manuals/editor-scripts-ui.md

@@ -5,7 +5,7 @@ brief: Este manual explica cómo crear elementos de interfaz en el editor usando
 
 # Scripts del editor e interfaz
 
-Este manual explica cómo crear elementos interactivos de interfaz en el editor usando scripts del editor escritos en Lua. Para empezar con los scripts del editor, consulta el [manual de scripts del editor](/manuals/editor-scripts). Puedes encontrar la referencia completa de la API del editor [aquí](/ref/stable/editor-lua/). Actualmente solo es posible crear diálogos interactivos, aunque queremos ampliar el soporte de scripting de interfaz al resto del editor en el futuro.
+Este manual explica cómo crear diálogos interactivos y abrir recursos en el editor usando scripts del editor escritos en Lua. Para empezar con los scripts del editor, consulta el [manual de scripts del editor](/manuals/editor-scripts). Puedes encontrar la referencia completa de la API del editor [aquí](/ref/stable/editor-lua/).
 
 ## Hola mundo
 
@@ -53,6 +53,32 @@ Finalmente, después de presionar <kbd>Enter</kbd> (o hacer click en el botón `
 Perform action:	true
 ```
 
+## Abrir recursos {#opening-resources}
+
+Llama a `editor.ui.open_resource()` desde la función `run` de un comando para abrir un recurso del proyecto. La ruta comienza con `/`. Si omites la vista, se selecciona la vista principal del recurso:
+
+```lua
+editor.ui.open_resource("/main/main.script")
+```
+
+Las vistas `code` y `text` aceptan como tercer argumento una posición del cursor o una selección. Los números de línea y columna empiezan en `1`; si falta la columna, su valor predeterminado es `1`. Especifica la vista al pasar estos argumentos:
+
+```lua
+editor.ui.open_resource("/main/main.script", "code", { line = 10 })
+editor.ui.open_resource("/main/main.script", "code", { line = 10, column = 5 })
+```
+
+Para seleccionar un rango, proporciona en su lugar las posiciones del cursor `from` y `to`:
+
+```lua
+editor.ui.open_resource("/main/main.script", "code", {
+    from = { line = 10, column = 1 },
+    to = { line = 12, column = 1 }
+})
+```
+
+La vista configurada para el recurso puede abrirse en el editor o en una aplicación externa. Las vistas integradas Code y Text admiten los argumentos de cursor y selección. Consulta [`editor.ui.open_resource()`](/ref/beta/editor/#editor.ui.open_resource:resource_path-view-args) para conocer los nombres de vista compatibles.
+
 ## Conceptos básicos
 
 ### Componentes

docs/es/manuals/editor-scripts.md

@@ -574,9 +574,13 @@ Ten en cuenta que los hooks de ciclo de vida actualmente son una funcionalidad s
 
 ## Servidores de lenguaje {#language-servers}
 
-El editor admite un subconjunto del [Language Server Protocol](https://microsoft.github.io/language-server-protocol/): diagnósticos (lints), sugerencias de completado, información al pasar el cursor, símbolos del documento en el panel Structure, ir a la definición, buscar referencias y cambiar el nombre de símbolos. Pasa el cursor sobre un símbolo para ver información del servidor de lenguaje. Con el cursor sobre un símbolo, usa <kbd>F2</kbd> para cambiarle el nombre, <kbd>F12</kbd> para ir a su definición o <kbd>Shift+F12</kbd> para buscar referencias. Estas acciones también están disponibles en el menú <kbd>Edit</kbd>.
+El editor admite un subconjunto del [Language Server Protocol](https://microsoft.github.io/language-server-protocol/): diagnósticos (lints), sugerencias de completado, información al pasar el cursor, símbolos del documento en el panel Structure, ir a la definición, buscar referencias, cambiar el nombre de símbolos y formatear documentos o rangos. Pasa el cursor sobre un símbolo para ver información del servidor de lenguaje. Con el cursor sobre un símbolo, usa <kbd>F2</kbd> para cambiarle el nombre, <kbd>F12</kbd> para ir a su definición o <kbd>Shift+F12</kbd> para buscar referencias. Estas acciones también están disponibles en el menú <kbd>Edit</kbd>.
 
-Para definir el servidor de lenguaje, necesitas editar la función `get_language_servers` de tu script del editor así:
+Consulta [formatear código](/manuals/writing-code/#formatting-code) para conocer el comando de formateo y la preferencia para formatear al guardar.
+
+El servidor de lenguaje Lua incluido contiene anotaciones de tipos de Defold para las APIs de runtime y de scripting del editor. En archivos `.editor_script`, el completado y los diagnósticos reconocen las funciones `editor.*` y sus tipos de argumentos y valores de retorno. Consulta [completado de código](/manuals/writing-code/#code-completion).
+
+Para registrar un servidor de lenguaje adicional, define la función `get_language_servers` de tu script del editor así:
 
 ```lua
 function M.get_language_servers()