async let vs Task.detached when work must escape actor isolation but keep tracing context

The Solution: Non-isolated Functions with Structured Concurrency

To escape actor isolation while maintaining task-local values and cooperative cancellation, you should use async let (or a Task Group) in conjunction with a non-isolated function.

The misconception is that async let always keeps the work on the actor. In reality, async let inherits the actor isolation of the call site only if the function it calls is isolated to that actor. If you call a nonisolated function or a function in a different module that is not bound to your actor, the work is dispatched to the global concurrent pool, effectively escaping the actor's lock while remaining part of the structured concurrency tree.

Comparison of Approaches

Feature	async let + nonisolated	Task.detached	Task { }
Escapes Actor	Yes	Yes	No (Inherits isolation)
Task-Locals	Inherited	Lost	Inherited
Cancellation	Automatic/Structured	Manual/Independent	Manual/Unstructured

Implementation Steps

1. Define the heavy export logic in a nonisolated function or a separate struct/class that is not an actor.
2. Call this function using async let from within your actor method.
3. Await the result before the actor method returns to ensure structured completion.

nonisolated func performExport(data: Data) async throws {
    // This runs on the global concurrent pool
    // Task-local tracing IDs are available here
    try await Task.sleep(for: .seconds(5))
}

Addressing the Detached Task Trade-off

If you choose Task.detached, you lose automatic cancellation propagation. While the detached task is a top-level task, it does not monitor the cancellation state of the task that spawned it. To regain this, you would need to manually check Task.isCancelled within the detached block and manually link the parent's cancellation state to the child, which is redundant if structured concurrency is available.

Lifetime Considerations

The choice depends entirely on the desired lifetime:

• Run off-actor but wait for completion: Use async let + nonisolated.
• Fire-and-forget (outlive the caller): Use Task.detached and manually pass the tracing ID as a parameter. Be aware that you must manage the Task handle if you ever need to cancel it later.

Diagnostic Detail Needed: Does the export process need to continue running if the user navigates away from the screen/service that initiated the request, or should it be terminated immediately?