> For the complete documentation index, see [llms.txt](https://docs.decentraland.org/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/primeros-pasos/coding-scenes.md).
# Fundamentos de programación
Este conjunto te ayudará a entender cómo funcionan las cosas en el cliente y el SDK de Decentraland.
## Las herramientas de desarrollo
A muy alto nivel, Decentraland **Kit de desarrollo de software** (SDK) te permite hacer lo siguiente:
* Generar un *proyecto* que contiene una escena de Decentraland, incluidos todos los assets necesarios para renderizar y ejecutar tu contenido.
* Construir, probar y previsualizar el contenido de tu escena localmente en tu navegador web, completamente offline y sin tener que realizar transacciones en Ethereum ni poseer LAND.
* Escribir código TypeScript usando la API de Decentraland para añadir comportamiento interactivo y dinámico a la escena.
* Subir el contenido de tu escena al servidor de contenido.
* Vincular tus tokens LAND con la URL del contenido que has subido.
Nuestro SDK incluye lo siguiente:
* **Creator Hub**: Una aplicación independiente que, entre otras cosas, te permite crear escenas con una interfaz fácil de arrastrar y soltar. Puedes ejecutar previsualizaciones, depurar, editar código y publicar. [Leer más](/creator/content-creator-es/scene-editor/primeros-pasos/about-editor.md)
* **El ECS de Decentraland**: Un paquete de TypeScript que contiene el framework de métodos auxiliares que te permite crear experiencias interactivas. Úsalo para crear y manipular objetos en la escena y también para facilitar transacciones dentro del mundo entre jugadores u otras aplicaciones. ( [referencia más reciente de ECS](https://github.com/decentraland/ecs-reference/blob/master/docs-latest/decentraland-ecs.md))
* **Ejemplos de escenas**: Inspírate y toma buenas prácticas de programación de los [ejemplos de escenas](https://studios.decentraland.org/resources?sdk_version=SDK7).
Otras herramientas heredadas:
* **El Web Editor**: Una herramienta basada en la web para crear escenas simples y publicarlas.
## Requisitos
Para desarrollar una escena localmente, no necesitas poseer tokens LAND. Desarrollar y probar una escena puede hacerse completamente offline, sin necesidad de desplegar una escena en la red Ethereum (el sistema que usa Decentraland para establecer la propiedad de LAND, de un NAME de Decentraland) ni en el servidor de contenido.
Debes tener:
* **Creator Hub**: Una aplicación independiente que, entre otras cosas, te permite crear escenas con una interfaz fácil de arrastrar y soltar. Puedes ejecutar previsualizaciones, depurar, editar código y publicar. [Leer más](/creator/content-creator-es/scene-editor/primeros-pasos/about-editor.md).
Si planeas editar el código de la escena, también tendrás que instalar uno de los siguientes:
* 
**Visual Studio Code**: Descárgalo [aquí](https://code.visualstudio.com/). Te ayuda a escribir código mucho más rápido y con menos errores. Un editor de código fuente marca errores de sintaxis, autocompleta mientras escribes e incluso muestra sugerencias inteligentes que dependen del contexto en el que estés. También puedes hacer clic en un objeto del código para ver la definición completa de su clase y qué atributos admite.
* 
**Cursor AI**: Descárgalo [aquí](https://www.cursor.com/). Un potente editor de código integrado con IA. Te permite elegir distintos modelos de IA para ayudarte a escribir código, todos gratuitos. El asistente de IA no solo autocompleta mientras escribes; también puedes pedirle que refactorice una base de código grande, escriba documentación y más.
{% hint style="info" %}
**💡 Consejo**: Puedes usar asistentes de IA como Cursor, OpenDCL o Claude Code para crear escenas completas a partir de descripciones en lenguaje natural — no se necesita experiencia con TypeScript. Consulta [Vibe Coding con IA](/creator/content-creator-es/scenes-sdk7/primeros-pasos/vibe-coding.md) para comenzar.
{% endhint %}
## Idiomas y sintaxis admitidos
Decentraland emplea [TypeScript (.ts)](https://www.typescriptlang.org/docs/handbook/jsx.html) como el lenguaje predeterminado para escribir escenas.
TypeScript es un superconjunto de JavaScript, así que si estás familiarizado con JavaScript verás que es casi lo mismo, pero TypeScript incluye declaraciones de tipos. Gracias a las declaraciones de tipos, es posible tener funciones como autocompletado y mejores pistas de depuración; esto acelera los tiempos de desarrollo y permite crear una base de código más sólida. Estas funciones son componentes clave de una buena experiencia de desarrollo.
Cuando se construye una escena, el código TypeScript que escribiste se compila a JavaScript minificado, para hacerlo más ligero. El código fuente original en TypeScript nunca se sube a los servidores; solo la versión compilada en JavaScript.
### Otros idiomas
Puedes usar otra herramienta o lenguaje en lugar de TypeScript y compilarlo a JavaScript, siempre que tus scripts compilados estén contenidos dentro de un único archivo JavaScript que coincida con la ruta establecida en el `main` campo de `scene.json` archivo de tu escena (por defecto *bin/index.js*). Todas las declaraciones de tipos proporcionadas se hacen en TypeScript, y otros lenguajes y transpiladores no están oficialmente admitidos.
## Scenes
El contenido que despliegas en tu LAND se llama **escena**. Una escena es un programa interactivo que renderiza contenido 3D; esto podría ser un juego, una experiencia interactiva, una galería de arte, ¡lo que quieras!
Las escenas se despliegan en el LAND virtual de Decentraland. LAND es un asset escaso y no fungible mantenido en un smart contract de Ethereum. Despliega en una sola **parcela**, un terreno de LAND de 16 metros por 16 metros, o en múltiples parcelas adyacentes.
Cuando los jugadores visitan Decentraland, descargan y renderizan el contenido de cada escena a medida que recorren el mapa. Descargan las escenas cuando se alejan de ellas.
También puedes ejecutar una escena localmente en tu máquina ejecutando una preview desde la CLI.
## Entities and Components
Las escenas tridimensionales en Decentraland se basan en una [Entity-Component-System](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system) arquitectura, donde todo en una escena es una *entidad*entidad *components*, cada componente le asigna a la entidad a la que pertenece propiedades específicas. Es probable que una entidad puerta tenga al menos un componente Transform (que define posición, rotación y escala) y otro para proporcionarle una forma. Los componentes son solo un lugar para almacenar datos; por sí mismos no realizan ninguna acción.
.png?alt=media)
```ts
export function main() {
// Crear una entity
const door = engine.addEntity()
// Darle una posición a la entity mediante un component Transform
Transform.create(door, {
position: Vector3.create(5, 1, 5),
})
// Darle a la entity una forma visible mediante un component GltfContainer
GltfContainer.create(door, {
src: 'assets/models/door.glb',
})
}
```
Las entidades pueden anidarse dentro de otras entidades para formar una estructura en árbol. Si estás familiarizado con el desarrollo web, puede resultarte útil pensar en las entidades como elementos en un árbol DOM y en los componentes como los atributos de cada uno de estos elementos.
.png?alt=media)
Las entidades son un concepto abstracto. Una entidad es solo un id, que se usa como referencia para agrupar diferentes componentes.
Consulta [Entities y components](/creator/content-creator-es/scenes-sdk7/arquitectura/entities-components.md) para ver en profundidad ambos conceptos y cómo se usan en las escenas de Decentraland.
### Custom components
El conjunto predeterminado de componentes (como `Transform`, `GltfContainer`, `Material`, etc.) es interpretado por el engine y tiene consecuencias directas sobre cómo se verá la entidad, su posición, si emite sonidos, etc.
También puedes definir *custom components* componentes personalizados para almacenar datos que puedan resultar útiles para la mecánica de tu escena. El engine no sabrá cómo interpretar qué significan los valores de estos componentes, ni tendrán consecuencias directas en cómo se renderiza la escena. Sin embargo, puedes escribir lógica en el código de tu escena para vigilar estos valores y responder a ellos. Por ejemplo, puedes definir un componente personalizado "doorState" para seguir el estado abierto/cerrado de la puerta. En este caso, el componente no es más que un lugar para almacenar un valor que haga seguimiento de este estado. Para ver la puerta abrirse y cerrarse en tu escena, luego tendrás que implementar por separado la lógica que use estos valores para afectar la rotación de la puerta, un valor del `Transform` componente que el engine sí sabe cómo interpretar.
Consulta [Componentes personalizados](/creator/content-creator-es/scenes-sdk7/arquitectura/custom-components.md) para más información.
### Obtener entidades por nombre
Las entidades añadidas arrastrando y soltando en el Scene Editor en Creator Hub también pueden accederse por código para seguir editándolas y añadirles comportamiento.
Usa `engine.getEntityOrNullByName()` para obtener una entidad, pasando el nombre asignado a la entidad en la UI del Scene Editor. Cada una debe tener un nombre único.
```ts
function main() {
const door = engine.getEntityOrNullByName('door3')
}
```
Luego puedes hacer lo que quieras con esa entidad, como añadir nuevos componentes, modificar sus componentes existentes, duplicarla o eliminarla.
Consulta [Obtener entidad por nombre](/creator/content-creator-es/scenes-sdk7/arquitectura/entities-components.md#get-an-entity-by-name) para más información.
Si la entidad es una [Smart item](/creator/content-creator-es/scene-editor/interactividad/smart-items.md), también puedes llamar a su **Actions** o suscribirte a su **Triggers** o suscribirte a su [Elementos de referencia](/creator/content-creator-es/scene-editor/extender-con-codigo/reference-items.md).
## Systems
Las entidades y los componentes son lugares para almacenar información sobre los objetos de una escena. *Systems* contienen funciones que cambian la información almacenada en los componentes con el tiempo.
Los Systems son donde implementamos la lógica del juego; ejecutan las acciones que necesitan actualizarse o comprobarse periódicamente en cada tick del game loop.
Un System es una función pura y simple que se llama una vez en cada tick (hasta 30 veces por segundo), siguiendo el [*patrón de actualización*](http://gameprogrammingpatterns.com/update-method.html).
```ts
// System básico
function mySystem() {
console.log('mi system está en ejecución')
}
engine.addSystem(mySystem)
// System con dt
function mySystemDT(dt: number) {
console.log('tiempo transcurrido desde el último frame: ', dt)
}
engine.addSystem(mySystemDT)
```
Una sola escena puede tener 0 o muchos Systems ejecutándose al mismo tiempo. Los Systems pueden activarse o desactivarse en distintos momentos durante la duración de la escena. En general, es una buena práctica mantener los comportamientos independientes en Systems separados.
Consulta [Systems](/creator/content-creator-es/scenes-sdk7/arquitectura/systems.md) para más detalles sobre cómo se usan los Systems en una escena.
### El game loop
El [game loop](http://gameprogrammingpatterns.com/game-loop.html) es la columna vertebral del código de una escena de Decentraland. Cicla a través de parte del código a intervalos regulares y hace lo siguiente:
* Escuchar la entrada del jugador
* Actualizar la escena
* Volver a renderizar la escena
En la mayoría de los programas de software tradicionales, todos los eventos se activan directamente por las acciones del jugador. Nada en el estado del programa cambiará hasta que el jugador haga clic en un botón, abra un menú, etc.
Pero los entornos interactivos y los juegos son distintos. No todos los cambios de la escena son necesariamente causados por las acciones de un jugador. Tu escena podría tener objetos animados que se mueven por sí solos o incluso personajes no jugables que tienen su propia IA. Algunas acciones del jugador también pueden requerir varios ticks para completarse; por ejemplo, si la apertura de una puerta necesita durar un segundo completo, la rotación de la puerta debe actualizarse incrementalmente unas 30 veces mientras se mueve.
Llamamos a cada iteración del loop un *tick*. Las escenas de Decentraland se renderizan a 30 ticks por segundo, siempre que sea posible. Si la máquina tiene dificultades para renderizar cada tick, puede resultar en actualizaciones menos frecuentes.
En cada tick, la escena se actualiza; luego la escena se vuelve a renderizar, basándose en los valores actualizados.
En las escenas de Decentraland, no hay un game loop declarado explícitamente, sino que [Systems](/creator/content-creator-es/scenes-sdk7/arquitectura/systems.md) de la escena conforman el game loop.
La compilación y el renderizado de la escena se llevan a cabo en el backend; no necesitas encargarte de eso mientras desarrollas tu escena.
## Consultar components
Puedes [consultar components](/creator/content-creator-es/scenes-sdk7/arquitectura/querying-components.md) con el método `engine.getEntitiesWith(...components)` para hacer seguimiento de todas las entities en la scene que tienen ciertos components.
A menudo tiene sentido consultar components dentro de un [system](/creator/content-creator-es/scenes-sdk7/arquitectura/systems.md), para luego iterar sobre cada una de las entidades devueltas y realizar el mismo conjunto de acciones sobre cada una.
Si intentas iterar sobre todas las entidades de la escena en cada tick del game loop, eso podría tener un coste significativo en el rendimiento. Al referirte solo a las entidades devueltas por una consulta, te aseguras de tratar solo con aquellas que son relevantes.
```ts
// Define un System
function boxHeightSystem(dt: number) {
// consulta para entidades que incluyan tanto componentes MeshRenderer como Transform
for (const [entity] of engine.getEntitiesWith(MeshRenderer, Transform)) {
const transform = Transform.get(entity)
console.log('una caja está a la altura: ', transform.position.y)
}
}
// Agrega el system al engine
engine.addSystem(boxHeightSystem)
```
## Ciclo de vida de la escena
Si empiezas a escribir líneas sueltas de código directamente en `index.ts`, tu código puede carecer de un contexto importante. Por ejemplo, te faltará información sobre la entidad jugador, o sobre entidades que fueron añadidas mediante arrastrar y soltar en Creator Hub. En el momento en que se leen tus líneas de código, esas cosas todavía no se han cargado.
Para evitar ese escenario, siempre se recomienda escribir el código de carga inicial de tu escena usando la `main()` función (en el `index.ts` archivo) como punto de entrada. Esta función se ejecuta solo después de que todo el contexto inicial de la escena ya está cargado; esto incluye cualquier cosa añadida mediante la UI del Scene Editor.
Puedes escribir tu código fuera de la `main()` función cuando:
* El código es llamado indirectamente por `main()`
* El código define un System, o añade un System al engine
* El código está dentro de un [función async](/creator/content-creator-es/scenes-sdk7/patrones-de-programacion/async-functions.md)
{% hint style="warning" %}
**📔 Nota**: Para cuando el código dentro de una función async o un System se ejecuta por primera vez, todo en la escena ya está debidamente inicializado.
[Componente personalizado](/creator/content-creator-es/scenes-sdk7/arquitectura/custom-components.md) Las definiciones son una excepción; estas siempre deben escribirse fuera de la `main()` función, en un archivo separado. Necesitan interpretarse antes de que `main()` se ejecute.
{% endhint %}
## Mutabilidad
Puedes elegir trabajar con versiones mutables o inmutables (solo lectura) de un component. La `.get()` función de un component devuelve una versión inmutable del component. Solo puedes leer sus valores, pero no puedes cambiar ninguna de sus propiedades.
El `.getMutable()` La función devuelve una representación del component que te permite cambiar sus valores. Usa versiones mutables solo cuando planees hacer cambios en un component. Trabajar con versiones inmutables de components supone una enorme mejora en el rendimiento.
```ts
// obtener una versión inmutable (solo lectura)
const immutableTransform = Transform.get(myEntity)
// lo siguiente NO funciona:
// \timmutableTransform.position.y = 2
const mutableTransform = Transform.getMutable(myEntity)
// lo siguiente SÍ cambia la posición de la entidad
mutableTransform.position.y = 2
```
Consulta [mutable data](/creator/content-creator-es/scenes-sdk7/patrones-de-programacion/mutable-data.md) para más detalles.
## Poniéndolo todo junto
El *engine* es lo que se sitúa entre *entities*, y *components* por un lado y *systems* por el otro.
.png?alt=media)
Todos los valores almacenados en los components de la escena representan el estado de la escena en ese momento. Con cada tick del game loop, el engine ejecuta las funciones de cada uno de los Systems para actualizar los valores almacenados en los components.
Después de que se ejecutan todos los Systems, los components de cada entidad tendrán nuevos valores. Cuando el engine renderiza la escena, usará estos valores nuevos y actualizados, y los jugadores verán cómo las entidades cambian para reflejar sus nuevos estados.
```ts
export function main() {
// Crear una entity
const cube = engine.addEntity()
// Darle una posición a la entity mediante un component Transform
Transform.create(cube, {
position: Vector3.create(5, 1, 5),
})
// Dale a la entidad una forma visible mediante un componente MeshRenderer
MeshRenderer.setBox(cube)
}
// Define un System
function rotationSystem(dt: number) {
// consulta para entidades que incluyan tanto componentes MeshRenderer como Transform
for (const [entity] of engine.getEntitiesWith(MeshRenderer, Transform)) {
const transform = Transform.getMutable(entity)
transform.rotation = Quaternion.multiply(
transform.rotation,
Quaternion.fromAngleAxis(dt * 10, Vector3.Up())
)
}
}
// Agrega el system al engine
engine.addSystem(rotationSystem)
```
En el ejemplo anterior, una `caja` entidad y un `rotationSystem` System se añaden al engine. La `caja` entidad tiene un `Transform` y un `MeshRenderer` componente. En cada tick del game loop, el `rotationSystem` System se llama, y cambia los valores de rotación en el `Transform` componente de la `caja` entidad.
Ten en cuenta que la mayor parte del código anterior se ejecuta solo una vez, al cargar la escena. La excepción es el `rotationSystem` System, que se llama en cada tick del game loop.
## Desacoplamiento de la escena
Tus escenas no se ejecutan en el mismo contexto que el engine (también conocido como el hilo principal). Creamos el SDK de una forma completamente desacoplada del motor de renderizado. Lo diseñamos así por razones tanto de seguridad como de rendimiento.
Debido a este desacoplamiento, el código de tu escena no tiene acceso al DOM ni al `window` object, por lo que no puedes acceder a datos como el navegador o la ubicación geográfica del jugador.
El desacoplamiento funciona usando el protocolo RPC; este protocolo asigna una pequeña parte del client solo para renderizar la escena y controlar eventos.
También hemos abstraído el protocolo de comunicación. Esto nos permite ejecutar las escenas localmente en un WebWorker.
No queremos que los desarrolladores intervengan con el interior del engine ni siquiera que necesiten saber qué hay dentro del engine. Necesitamos garantizar una experiencia coherente para los jugadores en todo el mapa de Decentraland, y es más probable que ocurran errores en ese nivel "bajo".
Este desacoplamiento también es importante para evitar que las escenas vecinas interfieran con la experiencia de los jugadores mientras están en la escena de otra persona. Un jugador puede tener varias escenas cercanas cargadas al mismo tiempo, cada una ejecutando su propio código. Algunas acciones (como abrir enlaces externos o mover al jugador) solo se permiten cuando el jugador está de pie en esa escena concreta, no si la escena está cargada pero el jugador está fuera.
## Tree Shaking
Cuando se convierte el código fuente en TypeScript al código compilado en JavaScript minificado, el proceso realiza [tree shaking](https://en.wikipedia.org/wiki/Tree_shaking) para garantizar que solo se conviertan las partes del código que realmente se están usando. Esto ayuda a mantener el código final de la escena lo más ligero posible. Es especialmente útil al usar bibliotecas externas, ya que a menudo estas incluyen mucha funcionalidad que no se usa y que de otro modo engrosaría la escena.
Como consecuencia del tree shaking, cualquier código que quieras que tu escena ejecute necesita ser referenciado de una forma u otra por los puntos de entrada de tu código: la `main()` función en `index.ts`. Los Systems también pueden añadirse alternativamente al engine en el `index.ts` archivo, sin hacer referencia a `main()`. Cualquier código que no sea referenciado explícita o indirectamente por estos archivos no se incluirá en la escena.
Por ejemplo, supongamos que tienes un archivo llamado `extraContent.ts` con el siguiente contenido; la entidad no se renderizará y el System no empezará a ejecutarse:
```ts
// extraContent.ts
const myEntity = engine.addEntity()
Transform.create(myEntity, {
posición: { x: 8, y: 0, z: 8 },
})
MeshRenderer.setBox(myEntity)
function mySystem(dt: number) {
console.log('system en ejecución')
}
engine.addSystem(mySystem)
```
Para hacer que se ejecute como parte de tu escena, puedes hacer referencia desde `index.ts` de la siguiente manera:
```ts
// en extraContent.ts
export function addEntities() {
const myEntity = engine.addEntity()
Transform.create(myEntity, {
posición: { x: 8, y: 0, z: 8 },
})
MeshRenderer.setBox(myEntity)
}
export function mySystem(dt: number) {
console.log('system en ejecución')
}
/////////////////////////////
// en index.ts
import { addEntities, mySystem } from './extraContent'
export function main() {
addEntities()
}
engine.addSystem(mySystem)
```
La excepción a esta regla son las definiciones de componentes personalizados. No se debe acceder a estas mediante el `main()` punto de entrada de la función, ya que necesitan interpretarse antes que todo lo demás.
## Imports
Todas las funciones, objetos, componentes y otros elementos utilizados por la escena deben importarse en cada archivo para usarlos. Esto es una consecuencia del [tree-shaking](#tree-shaking), ya que evita empaquetar todo el SDK y en su lugar solo incluye las partes que usa la escena.
Los snippets a lo largo de la documentación omiten las líneas de importación al inicio de cada archivo para mantenerlas limpias, pero para que funcionen debes agregarlas a la escena.
Cuando uses Visual Studio Code para escribir tus escenas, las opciones inteligentes de autocompletado deberían encargarse de gestionar las importaciones por ti mientras escribes, sin que tengas que ser consciente de ello.
Cuando pegas un snippet en tu escena, sin embargo, probablemente verás algunos elementos marcados en rojo, que no están importados en ese archivo. Para arreglarlo:
* Haz clic en cada palabra subrayada
* Haz clic en el icono de la bombilla a la izquierda de la línea
* Selecciona **Añadir importación desde**
* Aparece una línea de importación al inicio del archivo.
Si hay muchas cosas diferentes que importar, también puedes seleccionar **Añadir todas las importaciones que faltan** en el mismo menú desplegable.
Ten en cuenta que las importaciones deben hacerse en cada archivo donde se use un elemento.
Visual Studio Code debería ser capaz de resolver por sí solo las rutas correctas de tus importaciones. Si por cualquier motivo tiene problemas para hacerlo, un truco es pegar las siguientes sentencias de importación vacías al inicio de tu archivo. Visual Studio Code debería poder encargarse a partir de ahí.
```ts
import {} from '@dcl/sdk/ecs'
import {} from '@dcl/sdk/math'
```
## Versiones del SDK
Cuando desarrollas una nueva escena, usas la `@latest` versión estable del SDK por defecto.
Puedes instalar la `@next` versión del SDK si quieres aprovechar o previsualizar funciones próximas que aún no han llegado a la última versión estable.
Para hacerlo, abre el `archivo package.json` archivo de tu escena y cambia las siguientes líneas:
```json
"devDependencies": {
"@dcl/js-runtime": "next",
"@dcl/sdk": "next"
},
```
Luego ejecuta el siguiente comando en la carpeta de tu proyecto de escena:
```
npm i
```
Consulta [gestionar dependencias](/creator/content-creator-es/scenes-sdk7/libraries/manage-dependencies.md) para más detalles.
{% hint style="warning" %}
**📔 Nota**: Ten en cuenta que la versión @next puede sufrir problemas de vez en cuando. La sintaxis y el nombre de las nuevas funciones pueden cambiar antes de que se lancen en una versión estable.
{% endhint %}
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.
Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:
```
GET https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/primeros-pasos/coding-scenes.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.