unowned self in a repeating Timer just delays the crash

Weak capture fixes the ticks. The controller's deinit runs and invalidate() there stops the timer, so nothing fires after the screen closes.

The thread is the part nobody has looked at. deinit runs wherever the last strong reference goes away, and invalidate() is supposed to be called on the thread whose run loop holds the timer. A controller that only ever gets released on the main thread works, but that's luck in the setup rather than anything the code promises. The trouble would only show up when something on another thread drops the last reference.

Worth noting that the same thing happens when the timer turns into a Task loop around Task.sleep, and it's easier to miss. An unstructured task has no parent, so nothing cancels it when the controller goes away. If the closure holds self strongly, the loop keeps the controller alive and deinit never gets the chance to cancel it. [weak self] only helps if the strong reference is taken inside each iteration. A guard let self above the loop holds it for the whole loop. In Kotlin a coroutine launched in a scope is cancelled with that scope, which is the part I keep missing on the Swift side. Is there anything that ties an unstructured Task to an object's lifetime, short of keeping the handle and calling cancel() in deinit?