Problem

A fintech payments gateway processes millions of charge requests per day. To prevent double-charging when clients retry (due to timeouts or flaky mobile networks), the gateway uses an idempotency key: multiple concurrent requests with the same key must share the same result.

You are implementing an in-memory, thread-safe “idempotency ledger” for a single process.

Task

Implement:

process_request_threadsafe(key: str, expensive_work: Callable[[], int]) -> int

Requirements:

1. Same key, concurrent callers: If multiple threads call process_request_threadsafe with the same key at the same time, exactly one thread may run expensive_work(). All other threads must wait and then return the same computed value.
2. Different keys, parallelism: Calls for different keys should not be serialized by a global lock while expensive_work() runs. (It’s fine to use a global lock for short state transitions.)
3. Failure semantics: If expensive_work() raises an exception, the key must not be marked as completed. Waiting callers should be released, and a later call for the same key should be allowed to retry (and may run expensive_work() again).

Output behavior

• On success, return the computed integer.
• On failure, propagate the exception to the caller.

Examples

Example 1

• Input: key = "x", two concurrent callers, expensive_work() -> 7
• Output: both callers return 7, and expensive_work executes once.

Example 2

• Input: keys ["a","b","c"] concurrently, each expensive_work returns 1,2,3
• Output: results [1,2,3], each key computed once; work for different keys can overlap.

Notes

• You may assume keys are short strings.
• Your solution should be safe under high contention (many threads hitting the same key).
• You do not need to implement eviction/TTL; assume the process lifetime is bounded for this exercise.