> ## 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.

# कार्य

> कार्यों का निरीक्षण करें और async ऑपरेशनों के पूरा होने की प्रतीक्षा करें

Youka में हर async ऑपरेशन अंततः एक task के रूप में चलता है, लेकिन प्राथमिक SDK surface अब raw task IDs के बजाय operation handles लौटाता है। अधिकांश कॉलर्स को `client.projects.wait(...)` या `client.exports.wait(...)` का उपयोग करना चाहिए और `client.tasks.*` तक केवल तब पहुँचना चाहिए जब उन्हें low-level task inspection की आवश्यकता हो।

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

ID के आधार पर किसी task की वर्तमान स्थिति प्राप्त करें।

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

### Task statuses

| Status        | Terminal? | Meaning                                         |
| ------------- | --------- | ----------------------------------------------- |
| `created`     | No        | Task बन गया है लेकिन अभी queued नहीं हुआ है।    |
| `queued`      | No        | Task चलने के लिए इंतज़ार कर रहा है।             |
| `in-progress` | No        | Task अभी निष्पादित हो रहा है।                   |
| `completed`   | Yes       | Task सफलतापूर्वक पूरा हो गया।                   |
| `finalized`   | Yes       | Task पूरा हो गया और post-processing हो चुकी है। |
| `failed`      | Yes       | Task किसी त्रुटि के साथ विफल हो गया।            |
| `cancelled`   | Yes       | Task रद्द कर दिया गया।                          |
| `timed-out`   | Yes       | Task ने अपनी time limit पार कर ली।              |

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

किसी task को poll करें जब तक वह terminal state तक न पहुँच जाए। सफलता पर अंतिम task लौटाता है; विफलता पर `YoukaTaskError` throw करता है।

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

### Options

<ParamField path="pollIntervalMs" type="number">
  polls के बीच milliseconds। डिफ़ॉल्ट `2000` है।
</ParamField>

<ParamField path="signal" type="AbortSignal">
  wait को abort करें। in-flight request और कोई भी pending delay तुरंत
  cancel कर दिए जाते हैं।
</ParamField>

### Errors

जब task `failed`, `cancelled`, या `timed-out` पर समाप्त होता है, तो `client.tasks.wait(...)` `YoukaTaskError` throw करता है:

```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?)`

किसी project-scoped operation के पूरा होने की प्रतीक्षा करें, फिर project को दोबारा fetch करें। operation handle, terminal task, और updated project लौटाता है।

```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>
  आम तौर पर `client.projects.create(...)`,
  `client.projects.separateStems(...)`, या `client.projects.syncLyrics(...)` का परिणाम।
</ParamField>

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

किसी cloud export के terminal state तक पहुँचने की प्रतीक्षा करें। `client.exports.create(...)` द्वारा लौटाया गया `ExportOperation` या `exportId` string में से कोई एक पास करें।

```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);
```

## Cancellation

लंबे समय तक चलने वाले wait को cancel करने के लिए `AbortSignal` पास करें:

```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;
  }
}
```

वही signal underlying task या export polling request को भी cancel कर देता है।

## What's next

* [Errors](/hi/sdk/errors) — `YoukaTaskError` और retryable errors को handle करें
* [Exports](/hi/sdk/exports) — किसी export के पूरा होने की प्रतीक्षा करें
* [API async jobs](/hi/api/async-jobs) — raw HTTP में वही pattern