Task+Timeout.swift

extension Task where Failure == Error {

  // Start a new Task with a timeout. If the timeout expires before the operation is 
  // completed then the task is cancelled and an error is thrown.
  init(priority: TaskPriority? = nil, timeout: TimeInterval, operation: @escaping @Sendable () async throws -> Success) {
    self = Task(priority: priority) {
      try await withThrowingTaskGroup(of: Success.self) { group -> Success in
        group.addTask(operation: operation)
        group.addTask {
          try await _Concurrency.Task.sleep(nanoseconds: UInt64(timeout * 1_000_000_000))
          throw TimeoutError()
        }
        guard let success = try await group.next() else {
          throw _Concurrency.CancellationError()
        }
        group.cancelAll()
        return success
      }
    }
  }
}

private struct TimeoutError: LocalizedError {
  var errorDescription: String? = "Task timed out before completion"
}

It can be confusing because Swift's concurrency design is intentionally vague about the details of how code is actually run and does not have a construct for threads and instead uses high-level semantic properties, expressed in terms of actor isolation.

When actor isolation is not specified, tasks are performed on the default concurrent executor. John McCall's commentary on its relationship with threads is enlightening

The default concurrent executor is used to run jobs that don't need to run somewhere more specific. It is based on a fixed-width thread pool that scales to the number of available cores.

Apple documentation is shit as usual. Thank you @swhitty & @MrDzmitry for the great discussion! It was a great learning resource for me on async/await.