[API reference](https://evolu.dev/docs/api-reference) › [@evolu/common](https://evolu.dev/docs/api-reference/common) › [Task](https://evolu.dev/docs/api-reference/common/Task) › waitForAbort

```ts
const waitForAbort: Task<never>;
```

Defined in: [packages/common/src/Task.ts:4903](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Task.ts#L4903)

Waits until the current [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) aborts, then rejects with its
[AbortError](https://evolu.dev/docs/api-reference/common/Task/variables/AbortError).

Use it to keep long-running services and Run-owned resources alive until
their owning Run shuts down.

### Example

```ts
import {
  assertEqual,
  assertFalse,
  assertType,
  assertTrue,
  AbortError,
  createRun,
  ok,
  waitForAbort,
  type Task,
} from "@evolu/common";

interface ServerDep {
  readonly port: number;
}

interface Server extends AsyncDisposable {}

const serverStarted = Promise.withResolvers<void>();
let serverStopped = false;
const startServer: Task<Server, never, ServerDep> = (run) => {
  assertEqual(run.deps.port, 3000);
  serverStarted.resolve();
  return ok({
    [Symbol.asyncDispose]: () => {
      serverStopped = true;
      return Promise.resolve();
    },
  });
};

const serve = (): Task<never, never, ServerDep> => async (run) => {
  await using _ = await run.ok(startServer);
  return await run(waitForAbort);
};

assertType<Task<never, never, ServerDep>, ReturnType<typeof serve>>();

await using run = createRun();
const fiber = run.abortable(serve(), { port: 3000 });
await serverStarted.promise;
fiber.abort();

const result = await fiber;
assertFalse(result.ok);
assertTrue(AbortError.is(result.error));
assertTrue(serverStopped);
```