Migrate the core Workflow runtime to Swift Concurrency

[blakemcanally]

Summary

Migrates the core Workflow module to Swift Concurrency: the runtime is now @MainActor-isolated, the core module compiles in Swift 6 language mode, and the host gains native AsyncStream observation and an async side-effect API. The change is deliberately additive — Combine publishers, the Lifetime-based side-effect API, and partner modules (WorkflowReactiveSwift, WorkflowRxSwift, WorkflowCombine) keep their existing surfaces.

This follows up on #392 (core off ReactiveSwift): that PR removed the reactive dependency; this one replaces the remaining pre-concurrency machinery (the DispatchQueue.workflowExecution convention and dispatchPrecondition checks) with compiler-enforced isolation.

What changed

1. @MainActor runtime isolation
WorkflowHost, WorkflowNode, SubtreeManager, RenderContext, and the Workflow/WorkflowAction protocol requirements are now @MainActor. Conforming types inherit isolation automatically through the conformance — most workflow code compiles unchanged. Code that touched the runtime from a non-main context, which previously crashed at runtime via dispatchPrecondition, now fails to compile instead.

2. Native async observation of a host

for await rendering in host.renderings { ... }   // replays current value, conflates for slow consumers; requires Rendering: Sendable
for await output in host.outputs { ... }         // buffers without loss; requires Output: Sendable

WorkflowHostingController.outputs mirrors the host. These are built on a small internal multicaster rather than bridging renderingPublisher.values, because Publisher.values silently drops events under backpressure (FB13156448) — a lossy bridge is not an acceptable foundation for output events.

3. Structured side effects

context.runSideEffect(key: key) { () async in ... }

The work runs in a node-owned Task and is cancelled cooperatively when the side-effect's key disappears — the async analogue of the existing Lifetime-based overload, which is unchanged.

4. Swift 6 language mode (core only)
The package manifest moves to swift-tools 6.0. Only the core Workflow target compiles in .v6 mode; every other target stays in Swift 5 mode with StrictConcurrency=targeted. No @unchecked Sendable, nonisolated(unsafe), or @preconcurrency import anywhere in core.

Source compatibility

Intent: everything compiles as before except code that was already violating the main-thread contract at runtime.

Accepted source breaks (compile-time errors replacing runtime dispatchPrecondition crashes):

• Sink is now Sendable and Sink.send is @MainActor, along with the closures it wraps (AnyWorkflow.mapOutput, AnyWorkflowAction's closure initializers and init(_ base:), StateMutationSink.send, WorkflowLogging.enabled/config). Passing sink.send or { sink.send(...) } as a UI callback compiles exactly as before (Swift 6 function-conversion rules); only calling send from a nonisolated synchronous context breaks — which previously crashed.
• WorkflowTesting's renderTester(), render(...), and send(action:) are @MainActor — consumer test suites will typically need @MainActor on test classes/methods. This repo's own suites (30+ files) show the shape of the change: annotations only, no logic edits.
• Conformances whose witnesses live in a separate extension from the conformance clause don't get isolation inference and need an explicit @MainActor (48 sample files in this PR demonstrate the sweep; it's mechanical).
• Consumers need a Swift 6 / Xcode 16+ toolchain to resolve the swift-tools-6.0 manifest (language mode for consumer code is unaffected). The repo's tuist pin moves to 4.27.0 for the same reason.

Behavioral notes:

• WorkflowHost/WorkflowNode use isolated deinit: dropping the last reference off the main actor now defers deallocation (and publisher completion / stream finish) to the main actor instead of tearing down runtime state on the releasing thread. This serializes deinit-time subject completion with accessors — previously a latent race.
• Deferred sink events (reentrancy handling) are scheduled via main-actor Task instead of DispatchQueue.main.async. Delivery stays on the main actor; relative ordering with other main-queue work is best-effort per Task scheduling semantics rather than strict queue FIFO. All reentrancy suites pass under both runtime configurations.

Open questions for reviewers

1. Sink.send isolation. The alternative — keeping send nonisolated with a MainActor.assumeIsolated crash contract — is not implementable under v6 without @unchecked escapes (region isolation rejects capturing the non-sending value into a @MainActor closure), and would break Sink crossing into @Sendable worker Tasks. We believe the isolated design is the only sound one, but it's the most visible API change here.
2. renderings requires Rendering: Sendable. Forced by AsyncStream.Continuation.yield taking sending Element. Typical non-Sendable Screen renderings can't use the stream and should keep using renderingPublisher (main-actor-confined). Is the honest-but-narrower API acceptable, or should we hold it until renderings can be Sendable-audited?
3. Runtime.Configuration and WorkflowLogging.Config gained Sendable, and WorkflowCombine.Publisher.running(in:key:)/mapOutput gained @MainActor — additive isolation attributes required by the v6 core; flagged for completeness.
4. The async runSideEffect Task inherits render-time priority, while WorkflowConcurrency's WorkerWorkflow uses .high; worth harmonizing in a follow-up?

Testing

• Core suites at baseline: 176 XCTest + 41 Swift Testing, zero failures, including the reentrancy suites (ConcurrencyTests, WorkflowHost_EventEmissionTests, SinkEventHandler suites) under both runtime configurations — the highest-risk area for the dispatch→Task change.
• New coverage: AsyncMulticasterTests (6), WorkflowHostAsyncTests (4), AsyncSideEffectTests (2), plus a hosting-controller outputs test (verified red→green on-simulator).
• Samples + Tutorial via tuist: green; the only failing bundle (WorkflowTesting-Tests on the iOS 26.5 simulator) fails identically at the base commit — pre-existing IssueReporting crash, not introduced here.
• API diff vs main: zero public symbols removed; all signature changes are isolation/Sendable annotations (enumerated above).

Follow-ups (not in this PR)

• Deprecation annotations on DispatchQueue.workflowExecution and the Lifetime-based side-effect API once adoption settles.
• Move renderingPublisher/outputPublisher behind WorkflowCombine at the next major.
• Swift 6 language mode for the remaining targets, module by module.
• Downstream consumer verification at scale before any deprecation flips.

🤖 Generated with Claude Code