> ## Documentation Index
> Fetch the complete documentation index at: https://docs.youka.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Tareas

> Inspecciona tareas y espera a que terminen las operaciones asíncronas

Cada operación asíncrona en Youka acaba ejecutándose como una tarea, pero la superficie principal del SDK ahora devuelve *operation handles* en lugar de IDs de tarea sin procesar. La mayoría de los casos de uso deberían emplear `client.projects.wait(...)` o `client.exports.wait(...)` y recurrir a `client.tasks.*` solo cuando necesiten inspección de tareas de bajo nivel.

## `client.tasks.get(taskId, options?)`

Obtiene el estado actual de una tarea por ID.

```ts theme={null}
const task = await client.tasks.get("tsk_abc123");
console.log(task.status, task.type);
```

### Estados de tarea

| Estado        | ¿Terminal? | Significado                                           |
| ------------- | ---------- | ----------------------------------------------------- |
| `created`     | No         | La tarea se creó pero aún no está en cola.            |
| `queued`      | No         | La tarea está esperando para ejecutarse.              |
| `in-progress` | No         | La tarea se está ejecutando actualmente.              |
| `completed`   | Sí         | La tarea terminó correctamente.                       |
| `finalized`   | Sí         | La tarea terminó y el posprocesamiento ya está hecho. |
| `failed`      | Sí         | La tarea falló con un error.                          |
| `cancelled`   | Sí         | La tarea fue cancelada.                               |
| `timed-out`   | Sí         | La tarea alcanzó su límite de tiempo.                 |

## `client.tasks.wait(taskId, options?)`

Sondea una tarea hasta que alcance un estado terminal. Devuelve la tarea final si tiene éxito y lanza `YoukaTaskError` si falla.

```ts theme={null}
const task = await client.tasks.wait("tsk_abc123", {
  pollIntervalMs: 3_000,
  signal: abortController.signal,
});
```

### Opciones

<ParamField path="pollIntervalMs" type="number">
  Milisegundos entre sondeos. Por defecto, `2000`.
</ParamField>

<ParamField path="signal" type="AbortSignal">
  Cancela la espera. La solicitud en curso y cualquier demora pendiente se cancelan
  inmediatamente.
</ParamField>

### Errores

`client.tasks.wait(...)` lanza `YoukaTaskError` cuando la tarea termina en `failed`, `cancelled` o `timed-out`:

```ts theme={null}
import { YoukaTaskError } from "@youka/sdk";

try {
  await client.tasks.wait("tsk_abc123");
} catch (error) {
  if (error instanceof YoukaTaskError) {
    console.error(error.code); // TASK_FAILED | TASK_CANCELLED | TASK_TIMED_OUT
    console.error(error.task); // Full RestTask payload
  }
  throw error;
}
```

## `client.projects.wait(operation, options?)`

Espera a que finalice una operación con alcance de proyecto y, después, vuelve a obtener el proyecto. Devuelve el *operation handle*, la tarea terminal y el proyecto actualizado.

```ts theme={null}
const operation = await client.projects.create({
  source: { type: "path", path: "./song.mp3" },
});

const { project, task } = await client.projects.wait(operation, {
  pollIntervalMs: 2_500,
});

console.log("Project ready:", project.id);
console.log("Task finished in state:", task.status);
```

<ParamField path="operation" type="ProjectOperation" required>
  Normalmente, el resultado de `client.projects.create(...)`,
  `client.projects.separateStems(...)` o `client.projects.syncLyrics(...)`.
</ParamField>

## `client.exports.wait(operationOrId, options?)`

Espera a que una exportación en la nube alcance un estado terminal. Pasa el `ExportOperation` devuelto por `client.exports.create(...)` o una cadena `exportId`.

```ts theme={null}
const operation = await client.exports.create("prj_abc123", {
  resolution: "1080p",
  quality: "high",
});

const finalized = await client.exports.wait(operation, {
  pollIntervalMs: 3_000,
});

console.log(finalized.status, finalized.url);
```

## Cancelación

Pasa un `AbortSignal` para cancelar una espera de larga duración:

```ts theme={null}
const controller = new AbortController();

setTimeout(() => controller.abort(), 60_000);

try {
  await client.projects.wait(operation, { signal: controller.signal });
} catch (error) {
  if (error instanceof Error && error.name === "AbortError") {
    console.log("Wait cancelled after 60s");
  } else {
    throw error;
  }
}
```

La misma señal también cancela la solicitud subyacente de sondeo de tareas o exportaciones.

## Qué sigue

* [Errors](/es/sdk/errors) — gestiona `YoukaTaskError` y errores reintentables
* [Exports](/es/sdk/exports) — espera a que termine una exportación
* [API async jobs](/es/api/async-jobs) — el mismo patrón en HTTP sin procesar