Explore: Output<Publishers> wrapper replaces cancellables-on-VM

[Sajjon]

Draft / exploration — not for merge as-is. Two stacked commits, both shifting state OUT of the ViewModel and INTO the value returned by transform.

Commit 1 — fold cancellables into Output<Publishers>

VM's cancellables bag is removed. transform(input:) -> Output<Publishers> returns the publisher bag plus an [AnyCancellable] built via @BindingsBuilder. SceneController retains them.

Commit 2 — remove BaseViewModel, fold navigation into Output<Publishers, NavigationStep>

Output gains a second generic for the navigation step and an AnyPublisher<Step, Never> field. AbstractViewModel gains a 4th generic param. BaseViewModel is deleted entirely. Navigator<Step> is instantiated locally inside transform — the VM holds nothing.

Consumer-facing diff (SignUpViewModel)

Before:

final class SignUpViewModel: BaseViewModel<SignUpUserAction, InputFromView, Output> {
    let service: SignUpServicing
    init(service: SignUpServicing) { self.service = service; super.init() }

    override func transform(input: Input) -> Output {
        let activity = ActivityIndicator()
        input.fromView.submitTrigger
            .map { ... }
            .sink { [weak self] user in self?.navigator.next(.signedUp(user)) }
            .store(in: &cancellables)
        return Output(isSubmitEnabled: ..., isLoading: ...)
    }
}

After:

final class SignUpViewModel: AbstractViewModel<
    InputFromView,
    InputFromController,
    SignUpViewModel.Publishers,
    SignUpUserAction
> {
    let service: SignUpServicing
    init(service: SignUpServicing) { self.service = service; super.init() }

    override func transform(input: Input) -> Output<Publishers, SignUpUserAction> {
        let navigator = Navigator<SignUpUserAction>()
        let activity  = ActivityIndicator()
        return Output(
            publishers: Publishers(isSubmitEnabled: ..., isLoading: ...),
            navigation: navigator.navigation
        ) {
            input.fromView.submitTrigger
                .map { ... }
                .sink { [navigator] user in navigator.next(.signedUp(user)) }
        }
    }
}

Coordinator-side change

Coordinating+Scene+{Push,Present,Replace}.swift now subscribe via scene.navigation (a publisher re-exposed by SceneController after transform returns) instead of viewModel.navigator.navigation. The where V.ViewModel: Navigating constraints are gone — NavigationStep is an associated type on ViewModelType now.

Tradeoffs (full list)

Wins:

• VM is truly stateless. No cancellables, no navigator.
• One return type carries everything: publishers + navigation + subscriptions.
• BaseViewModel and the Navigating-on-VM conformance disappear.
• [navigator] strong-capture is honest now — SceneController owns the lifetime.

Costs:

• AbstractViewModel grows from 3 → 4 generics. Consumer declarations are wordier (recoverable with a per-app typealias).
• Big API break: every consumer transform override changes shape; every coordinator push(...) constraint stops requiring Navigating.
• Late navigation subscription: scene.navigation only valid after transform runs. Already implicitly true today (push subscribes after scene init), but now visible.
• Consumer's Publishers struct collides with Combine.Publishers enum (mild — Swift resolves to the nested type at use sites).
• ~10 docstring example blocks still reference the old BaseViewModel<…> shape (InputFromController.swift, InputType.swift, ActivityIndicator.swift, ErrorTracker.swift, Publisher+Operators.swift, Coordinating.swift — non-code, non-build-blocking). Cleanup pass needed before any merge.

Test plan

• just test passes (26 Core + Combine + DIPrimitives).
• just example-build succeeds.
• Pre-commit + pre-push hooks pass.
• CI green.

Discussion points

1. Worth the 4th generic on AbstractViewModel + breaking-API churn for "VM is stateless"?
2. Publishers name vs Bindings? (Combine collision is mild but real.)
3. Should Navigator<Step> stay as an opt-in helper, or should we just use PassthroughSubject directly?
4. Provide a per-app typealias convenience (e.g. typealias SceneViewModel<FromView, Publishers, Step> = AbstractViewModel<FromView, InputFromController, Publishers, Step>) shipped as a public typealias in NanoViewControllerController?

🤖 Generated with Claude Code