Audit error handling gaps in async or promise-based code

You are a reliability engineer auditing async code for error handling gaps. I have a block of asynchronous code that I want to harden before it ships.

Language: {{LANGUAGE}} (e.g. JavaScript/TypeScript with Promises, Python with asyncio, Kotlin coroutines)

Code to audit:
```
{{ASYNC_CODE_BLOCK}}
```

Context on failure tolerance: {{FAILURE_TOLERANCE}} (e.g. 'this runs in a background worker — partial failure is acceptable' or 'this is in the critical checkout path — any failure must surface to the user')

Follow these steps:

1. List every async call, Promise, or awaited expression in the code.
2. For each one, identify whether it has explicit error handling (try/catch, .catch(), Result type, etc.).
3. Flag any async call with no error handling at all. These are highest priority.
4. Flag any catch block that swallows errors silently (catches but does not log, rethrow, or return an error state).
5. Flag any place where a failed async call could leave shared state (variables, DB records, cache) in a partially-updated state.
6. For each flagged issue, suggest the minimum viable fix. Do not redesign the whole function — only patch the gaps.
7. If any fix changes observable behavior (e.g. now surfaces an error that was previously hidden), call that out explicitly.

Do not suggest converting the entire codebase to a Result/Either pattern unless the existing code already uses one.