@independo/capacitor-inderun 1.0.1-dev.1 → 1.1.0-dev.2

package/ios/Sources/IndeRunCapacitorPlugin/IndeRunCapacitorStreamRegistry.swift

@@ -0,0 +1,121 @@
+import Foundation
+import IndeRunCore
+
+/// Tracks the streaming runs the bridge is currently pumping, keyed by the
+/// bridge-local `streamId`.
+///
+/// Two things make this more than a dictionary. A cancel can arrive before the run
+/// it refers to exists — `startStream` has to reach route selection before there is
+/// anything to cancel — so a cancel requested in that window is recorded and applied
+/// on attach. And cancelling a run is *not* cancelling the pump task: the engine
+/// answers a cancel with its one `cancelled` terminal event, which the pump still has
+/// to deliver. Task cancellation is reserved for teardown, where the webview is going
+/// away and nobody is left to receive a terminal.
+///
+/// Deliberately free of any Capacitor dependency, so it is exercised by `swift test`
+/// on macOS where `canImport(Capacitor)` is false.
+final class StreamRegistry {
+    enum AttachOutcome: Equatable {
+        case attached
+        /// A cancel arrived before the run did; the caller must apply it.
+        case cancelRequested(reason: String?)
+    }
+
+    private struct Entry {
+        var run: StreamRun?
+        var task: Task<Void, Never>?
+        var cancelRequested = false
+        var cancelReason: String?
+    }
+
+    private let lock = NSLock()
+    private var entries: [String: Entry] = [:]
+
+    var activeCount: Int {
+        lock.lock()
+        defer { lock.unlock() }
+        return entries.count
+    }
+
+    /// Reserves the id so a cancel arriving before the run can be recorded rather
+    /// than dropped as unknown.
+    func open(streamId: String) {
+        lock.lock()
+        defer { lock.unlock() }
+        if entries[streamId] == nil {
+            entries[streamId] = Entry()
+        }
+    }
+
+    func attach(streamId: String, run: StreamRun) -> AttachOutcome {
+        lock.lock()
+        guard var entry = entries[streamId] else {
+            // Torn down while the engine was still selecting a route.
+            lock.unlock()
+            return .cancelRequested(reason: nil)
+        }
+        if entry.cancelRequested {
+            let reason = entry.cancelReason
+            lock.unlock()
+            return .cancelRequested(reason: reason)
+        }
+        entry.run = run
+        entries[streamId] = entry
+        lock.unlock()
+        return .attached
+    }
+
+    func store(task: Task<Void, Never>, for streamId: String) {
+        lock.lock()
+        defer { lock.unlock() }
+        guard var entry = entries[streamId] else {
+            task.cancel()
+            return
+        }
+        entry.task = task
+        entries[streamId] = entry
+    }
+
+    /// Cancels the run if it has attached, otherwise records the request for attach.
+    /// An unknown id — already finished, or never started — is a silent no-op, which
+    /// is what makes cancelling after the terminal harmless.
+    func requestCancel(streamId: String, reason: String?) {
+        lock.lock()
+        guard var entry = entries[streamId] else {
+            lock.unlock()
+            return
+        }
+        if entry.cancelRequested {
+            lock.unlock()
+            return
+        }
+        entry.cancelRequested = true
+        entry.cancelReason = reason
+        let run = entry.run
+        entries[streamId] = entry
+        lock.unlock()
+
+        // Never under the lock: cancel reaches into engine code.
+        run?.cancel(reason: reason)
+    }
+
+    func finish(streamId: String) {
+        lock.lock()
+        defer { lock.unlock() }
+        entries.removeValue(forKey: streamId)
+    }
+
+    /// Teardown. Cancels each run first so providers unwind, then the pump tasks,
+    /// which at this point have nobody left to deliver to.
+    func cancelAll(reason: String?) {
+        lock.lock()
+        let draining = entries
+        entries.removeAll()
+        lock.unlock()
+
+        for (_, entry) in draining {
+            entry.run?.cancel(reason: reason)
+            entry.task?.cancel()
+        }
+    }
+}

package/ios/Tests/IndeRunCapacitorTests/IndeRunCapacitorStreamCodecTests.swift

@@ -0,0 +1,178 @@
+import XCTest
+import Foundation
+import IndeRunContracts
+import IndeRunCore
+@testable import IndeRunCapacitorPlugin
+
+/// Encoding is what the JS side actually consumes, so these assert the exact key
+/// sets rather than round-tripping: an optional that encodes as `null` instead of
+/// being absent changes which union branch the consumer reconstitutes.
+final class IndeRunCapacitorStreamCodecTests: XCTestCase {
+
+    private func event(
+        type: String,
+        sequence: Int = 0,
+        payload: Payload?,
+        runId: String = "run_1"
+    ) -> StreamEvent {
+        StreamEvent(
+            payload: payload,
+            runId: runId,
+            schemaVersion: .the10,
+            sequence: sequence,
+            timestamp: 1_700_000_000_000,
+            type: type
+        )
+    }
+
+    func testEncodesContentDeltaWithOnlyTheTextField() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let encoded = try bridge.encode(
+            streamEvent: event(type: "content_delta", payload: .content(text: "hello"))
+        )
+
+        XCTAssertEqual(encoded["schemaVersion"] as? String, "1.0")
+        XCTAssertEqual(encoded["runId"] as? String, "run_1")
+        XCTAssertEqual(encoded["sequence"] as? Int, 0)
+        XCTAssertEqual(encoded["type"] as? String, "content_delta")
+
+        let payload = try XCTUnwrap(encoded["payload"] as? [String: Any])
+        XCTAssertEqual(payload["text"] as? String, "hello")
+        XCTAssertEqual(Set(payload.keys), ["text"])
+    }
+
+    func testEncodesTerminalCompletedOutcome() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let outcome = StreamTerminalOutcome.completed(
+            runId: "run_1",
+            finalText: "all done",
+            finishReason: .stop,
+            usage: TaskResultUsage(inputTokens: 3, outputTokens: 5, totalTokens: 8),
+            telemetry: StreamTerminalOutcomeTelemetry(providerUsed: "openai", totalMs: 42)
+        )
+
+        let encoded = try bridge.encode(
+            streamEvent: event(type: "terminal", sequence: 4, payload: Payload(terminalOutcome: outcome))
+        )
+        let payload = try XCTUnwrap(encoded["payload"] as? [String: Any])
+
+        XCTAssertEqual(payload["outcome"] as? String, "completed")
+        XCTAssertEqual(payload["finalText"] as? String, "all done")
+        XCTAssertEqual(payload["finishReason"] as? String, "stop")
+        XCTAssertEqual((payload["usage"] as? [String: Any])?["totalTokens"] as? Int, 8)
+        XCTAssertEqual((payload["telemetry"] as? [String: Any])?["providerUsed"] as? String, "openai")
+        // The error/cancellation branches' fields must not leak into a completion.
+        XCTAssertNil(payload["error"])
+        XCTAssertNil(payload["partialText"])
+        XCTAssertNil(payload["reason"])
+    }
+
+    /// Terminal errors nest deeper than anything `run()` produces, which is the case
+    /// that would break `encodeObject`'s `as? JSObject` cast if a nil ever encoded as
+    /// NSNull.
+    func testEncodesTerminalErrorOutcomeWithNestedDetails() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let error = IndeRunError(
+            details: ["endpoint": JSONAny("https://example.test")],
+            errorClass: .RateLimited,
+            message: "Too many requests.",
+            providerId: "openai",
+            retryable: true,
+            retryAfterMs: 2_000,
+            runId: "run_1",
+            schemaVersion: .the10
+        )
+        let outcome = StreamTerminalOutcome.failed(runId: "run_1", error: error, partialText: "half ")
+
+        let encoded = try bridge.encode(
+            streamEvent: event(type: "terminal", sequence: 7, payload: Payload(terminalOutcome: outcome))
+        )
+        let payload = try XCTUnwrap(encoded["payload"] as? [String: Any])
+        let encodedError = try XCTUnwrap(payload["error"] as? [String: Any])
+
+        XCTAssertEqual(payload["outcome"] as? String, "error")
+        XCTAssertEqual(payload["partialText"] as? String, "half ")
+        XCTAssertEqual(encodedError["errorClass"] as? String, "RateLimited")
+        XCTAssertEqual(encodedError["retryAfterMs"] as? Int, 2_000)
+        XCTAssertEqual((encodedError["details"] as? [String: Any])?["endpoint"] as? String,
+                       "https://example.test")
+    }
+
+    func testEncodesTerminalCancelledOutcomeWithAndWithoutReason() throws {
+        let bridge = IndeRunCapacitorBridge()
+
+        let withReason = try bridge.encode(
+            streamEvent: event(
+                type: "terminal",
+                payload: Payload(
+                    terminalOutcome: .cancelled(runId: "run_1", partialText: "part", reason: "user left")
+                )
+            )
+        )
+        XCTAssertEqual((withReason["payload"] as? [String: Any])?["reason"] as? String, "user left")
+
+        let withoutReason = try bridge.encode(
+            streamEvent: event(
+                type: "terminal",
+                payload: Payload(
+                    terminalOutcome: .cancelled(runId: "run_1", partialText: "part", reason: nil)
+                )
+            )
+        )
+        let payload = try XCTUnwrap(withoutReason["payload"] as? [String: Any])
+        XCTAssertEqual(payload["outcome"] as? String, "cancelled")
+        XCTAssertEqual(payload["partialText"] as? String, "part")
+        // Absent, not null: a null would decode as a present-but-empty reason.
+        XCTAssertFalse(payload.keys.contains("reason"))
+    }
+
+    func testEncodesLifecyclePhase() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let payload = Payload(
+            text: nil, phase: .providerSelected, finalText: nil, finishReason: nil, outcome: nil,
+            runId: nil, schemaVersion: nil, telemetry: nil, usage: nil, error: nil,
+            partialText: nil, reason: nil
+        )
+
+        let encoded = try bridge.encode(streamEvent: event(type: "lifecycle", payload: payload))
+        XCTAssertEqual((encoded["payload"] as? [String: Any])?["phase"] as? String, "provider_selected")
+    }
+
+    /// The schema closes its union with an open catch-all branch; an unrecognized
+    /// type must cross the bridge untouched rather than be rejected.
+    func testEncodesAnUnknownEventTypeVerbatimWithoutPayload() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let encoded = try bridge.encode(
+            streamEvent: event(type: "some_future_type", sequence: 2, payload: nil)
+        )
+
+        XCTAssertEqual(encoded["type"] as? String, "some_future_type")
+        XCTAssertFalse(encoded.keys.contains("payload"))
+    }
+
+    func testEncodesStreamRunHandleWithAndWithoutProviderId() throws {
+        let bridge = IndeRunCapacitorBridge()
+
+        let withProvider = try bridge.encode(
+            handle: StreamRunHandle(
+                providerId: "openai",
+                runId: "run_1",
+                schemaVersion: .the10,
+                startedAt: 1_700_000_000_000
+            )
+        )
+        XCTAssertEqual(withProvider["providerId"] as? String, "openai")
+        XCTAssertEqual(withProvider["runId"] as? String, "run_1")
+        XCTAssertEqual(withProvider["startedAt"] as? Double, 1_700_000_000_000)
+
+        let withoutProvider = try bridge.encode(
+            handle: StreamRunHandle(
+                providerId: nil,
+                runId: "run_1",
+                schemaVersion: .the10,
+                startedAt: 1_700_000_000_000
+            )
+        )
+        XCTAssertFalse(withoutProvider.keys.contains("providerId"))
+    }
+}

package/ios/Tests/IndeRunCapacitorTests/IndeRunCapacitorStreamPumpTests.swift

@@ -0,0 +1,215 @@
+import XCTest
+import Foundation
+import IndeRunContracts
+import IndeRunCore
+@testable import IndeRunCapacitorPlugin
+
+/// Collects what the pump hands to its sinks.
+private final class SinkRecorder: @unchecked Sendable {
+    private let lock = NSLock()
+    private var events: [JSObject] = []
+    private var errors: [JSObject] = []
+
+    func recordEvent(_ event: JSObject) {
+        lock.lock()
+        defer { lock.unlock() }
+        events.append(event)
+    }
+
+    func recordError(_ error: JSObject) {
+        lock.lock()
+        defer { lock.unlock() }
+        errors.append(error)
+    }
+
+    var eventTypes: [String] {
+        lock.lock()
+        defer { lock.unlock() }
+        return events.compactMap { $0["type"] as? String }
+    }
+
+    var eventSequences: [Int] {
+        lock.lock()
+        defer { lock.unlock() }
+        return events.compactMap { $0["sequence"] as? Int }
+    }
+
+    var errorClasses: [String] {
+        lock.lock()
+        defer { lock.unlock() }
+        return errors.compactMap { $0["errorClass"] as? String }
+    }
+}
+
+final class IndeRunCapacitorStreamPumpTests: XCTestCase {
+
+    private func event(_ sequence: Int, type: String = "content_delta") -> StreamEvent {
+        StreamEvent(
+            payload: .content(text: "chunk\(sequence)"),
+            runId: "run_1",
+            schemaVersion: .the10,
+            sequence: sequence,
+            timestamp: 1_700_000_000_000,
+            type: type
+        )
+    }
+
+    private func cancelledTerminal(_ sequence: Int) -> StreamEvent {
+        StreamEvent(
+            payload: Payload(
+                terminalOutcome: .cancelled(runId: "run_1", partialText: "part", reason: "stopped")
+            ),
+            runId: "run_1",
+            schemaVersion: .the10,
+            sequence: sequence,
+            timestamp: 1_700_000_000_000,
+            type: "terminal"
+        )
+    }
+
+    private func makeRun(
+        continuation: inout AsyncThrowingStream<StreamEvent, Error>.Continuation?,
+        cancel: @escaping @Sendable (String?) -> Void = { _ in }
+    ) -> StreamRun {
+        let (events, made) = AsyncThrowingStream<StreamEvent, Error>.makeStream()
+        continuation = made
+        return StreamRun(
+            handle: StreamRunHandle(
+                providerId: nil,
+                runId: "run_1",
+                schemaVersion: .the10,
+                startedAt: 1_700_000_000_000
+            ),
+            events: events,
+            cancel: cancel
+        )
+    }
+
+    private func pump(_ bridge: IndeRunCapacitorBridge, _ run: StreamRun, _ recorder: SinkRecorder) -> Task<Void, Never> {
+        Task {
+            await bridge.pump(
+                streamId: "s1",
+                run: run,
+                onEvent: { _, event in recorder.recordEvent(event) },
+                onError: { _, error in recorder.recordError(error) }
+            )
+        }
+    }
+
+    func testForwardsEveryEventInOrderAndFinishesTheRegistryEntry() async {
+        let bridge = IndeRunCapacitorBridge()
+        let recorder = SinkRecorder()
+        var continuation: AsyncThrowingStream<StreamEvent, Error>.Continuation?
+        let run = makeRun(continuation: &continuation)
+
+        bridge.streams.open(streamId: "s1")
+        bridge.streams.attach(streamId: "s1", run: run)
+        let task = pump(bridge, run, recorder)
+
+        continuation?.yield(event(0))
+        continuation?.yield(event(1))
+        continuation?.finish()
+        await task.value
+
+        XCTAssertEqual(recorder.eventSequences, [0, 1])
+        XCTAssertTrue(recorder.errorClasses.isEmpty)
+        XCTAssertEqual(bridge.streams.activeCount, 0)
+    }
+
+    /// A provider failure is already a terminal event by the time it reaches the
+    /// pump; anything actually thrown out of the sequence is a bridge fault.
+    func testMapsAThrownStreamErrorToASingleNormalizedErrorSink() async {
+        let bridge = IndeRunCapacitorBridge()
+        let recorder = SinkRecorder()
+        var continuation: AsyncThrowingStream<StreamEvent, Error>.Continuation?
+        let run = makeRun(continuation: &continuation)
+
+        bridge.streams.open(streamId: "s1")
+        let task = pump(bridge, run, recorder)
+
+        continuation?.yield(event(0))
+        continuation?.finish(
+            throwing: IndeRunException(errorClass: .Internal, message: "pump blew up")
+        )
+        await task.value
+
+        XCTAssertEqual(recorder.eventSequences, [0])
+        XCTAssertEqual(recorder.errorClasses, ["Internal"])
+        XCTAssertEqual(bridge.streams.activeCount, 0)
+    }
+
+    /// Cancelling a run must not stop the pump: the engine answers a cancel with its
+    /// one `cancelled` terminal, and that still has to be delivered.
+    func testCancelDuringEmitStillForwardsTheCancelledTerminal() async {
+        let bridge = IndeRunCapacitorBridge()
+        let recorder = SinkRecorder()
+        var continuation: AsyncThrowingStream<StreamEvent, Error>.Continuation?
+
+        // Stand in for the engine: a cancel produces the cancelled terminal and ends
+        // the sequence.
+        nonisolated(unsafe) var capture: AsyncThrowingStream<StreamEvent, Error>.Continuation?
+        let run = makeRun(continuation: &continuation, cancel: { _ in
+            capture?.yield(
+                StreamEvent(
+                    payload: Payload(
+                        terminalOutcome: .cancelled(runId: "run_1", partialText: "chunk0", reason: "stopped")
+                    ),
+                    runId: "run_1",
+                    schemaVersion: .the10,
+                    sequence: 1,
+                    timestamp: 1_700_000_000_000,
+                    type: "terminal"
+                )
+            )
+            capture?.finish()
+        })
+        capture = continuation
+
+        bridge.streams.open(streamId: "s1")
+        bridge.streams.attach(streamId: "s1", run: run)
+        let task = pump(bridge, run, recorder)
+
+        continuation?.yield(event(0))
+        bridge.streams.requestCancel(streamId: "s1", reason: "stopped")
+        await task.value
+
+        XCTAssertEqual(recorder.eventTypes, ["content_delta", "terminal"])
+        XCTAssertTrue(recorder.errorClasses.isEmpty)
+    }
+
+    /// Teardown cancels the pump task itself. That is our own doing, with no one left
+    /// to receive anything, so it must not be reported as a bridge failure.
+    func testOwnTaskCancellationProducesNoErrorSink() async {
+        let bridge = IndeRunCapacitorBridge()
+        let recorder = SinkRecorder()
+        var continuation: AsyncThrowingStream<StreamEvent, Error>.Continuation?
+        let run = makeRun(continuation: &continuation)
+
+        bridge.streams.open(streamId: "s1")
+        let task = pump(bridge, run, recorder)
+
+        continuation?.yield(event(0))
+        continuation?.finish(throwing: CancellationError())
+        await task.value
+
+        XCTAssertEqual(recorder.eventSequences, [0])
+        XCTAssertTrue(recorder.errorClasses.isEmpty)
+    }
+
+    func testForwardsAnUnknownEventTypeWithoutTreatingItAsTerminal() async {
+        let bridge = IndeRunCapacitorBridge()
+        let recorder = SinkRecorder()
+        var continuation: AsyncThrowingStream<StreamEvent, Error>.Continuation?
+        let run = makeRun(continuation: &continuation)
+
+        bridge.streams.open(streamId: "s1")
+        let task = pump(bridge, run, recorder)
+
+        continuation?.yield(event(0, type: "some_future_type"))
+        continuation?.yield(cancelledTerminal(1))
+        continuation?.finish()
+        await task.value
+
+        XCTAssertEqual(recorder.eventTypes, ["some_future_type", "terminal"])
+    }
+}

package/ios/Tests/IndeRunCapacitorTests/IndeRunCapacitorStreamRegistryTests.swift

@@ -0,0 +1,154 @@
+import XCTest
+import Foundation
+import IndeRunContracts
+import IndeRunCore
+@testable import IndeRunCapacitorPlugin
+
+/// Records the cancel calls a fake `StreamRun` receives, so a test can assert both
+/// that a cancel arrived and what reason it carried.
+private final class CancelRecorder: @unchecked Sendable {
+    private let lock = NSLock()
+    private var calls: [String?] = []
+
+    func record(_ reason: String?) {
+        lock.lock()
+        defer { lock.unlock() }
+        calls.append(reason)
+    }
+
+    var count: Int {
+        lock.lock()
+        defer { lock.unlock() }
+        return calls.count
+    }
+
+    var reasons: [String?] {
+        lock.lock()
+        defer { lock.unlock() }
+        return calls
+    }
+}
+
+final class IndeRunCapacitorStreamRegistryTests: XCTestCase {
+
+    private func makeRun(recorder: CancelRecorder) -> StreamRun {
+        let (events, continuation) = AsyncThrowingStream<StreamEvent, Error>.makeStream()
+        continuation.finish()
+        return StreamRun(
+            handle: StreamRunHandle(
+                providerId: nil,
+                runId: "run_1",
+                schemaVersion: .the10,
+                startedAt: 1_700_000_000_000
+            ),
+            events: events,
+            cancel: { reason in recorder.record(reason) }
+        )
+    }
+
+    func testAttachesAndFinishesByStreamId() {
+        let registry = StreamRegistry()
+        let recorder = CancelRecorder()
+
+        registry.open(streamId: "s1")
+        XCTAssertEqual(registry.attach(streamId: "s1", run: makeRun(recorder: recorder)), .attached)
+        XCTAssertEqual(registry.activeCount, 1)
+
+        registry.finish(streamId: "s1")
+        XCTAssertEqual(registry.activeCount, 0)
+    }
+
+    /// A cancel can beat the engine's route selection. It must be held and applied
+    /// when the run finally attaches, not dropped.
+    func testCancelBeforeAttachIsAppliedOnAttachWithItsReason() {
+        let registry = StreamRegistry()
+        let recorder = CancelRecorder()
+
+        registry.open(streamId: "s1")
+        registry.requestCancel(streamId: "s1", reason: "user left")
+        // Nothing to cancel yet, so nothing was called.
+        XCTAssertEqual(recorder.count, 0)
+
+        let outcome = registry.attach(streamId: "s1", run: makeRun(recorder: recorder))
+        XCTAssertEqual(outcome, .cancelRequested(reason: "user left"))
+    }
+
+    func testCancelAfterFinishIsANoOp() {
+        let registry = StreamRegistry()
+        let recorder = CancelRecorder()
+
+        registry.open(streamId: "s1")
+        registry.attach(streamId: "s1", run: makeRun(recorder: recorder))
+        registry.finish(streamId: "s1")
+
+        registry.requestCancel(streamId: "s1", reason: "too late")
+        XCTAssertEqual(recorder.count, 0)
+    }
+
+    func testCancelForAnUnknownStreamIdIsANoOp() {
+        let registry = StreamRegistry()
+        registry.requestCancel(streamId: "never_opened", reason: nil)
+        XCTAssertEqual(registry.activeCount, 0)
+    }
+
+    func testRepeatedCancelCancelsTheRunExactlyOnce() {
+        let registry = StreamRegistry()
+        let recorder = CancelRecorder()
+
+        registry.open(streamId: "s1")
+        registry.attach(streamId: "s1", run: makeRun(recorder: recorder))
+
+        registry.requestCancel(streamId: "s1", reason: "first")
+        registry.requestCancel(streamId: "s1", reason: "second")
+
+        XCTAssertEqual(recorder.reasons, ["first"])
+    }
+
+    func testConcurrentStreamsAreIsolated() {
+        let registry = StreamRegistry()
+        let first = CancelRecorder()
+        let second = CancelRecorder()
+
+        registry.open(streamId: "s1")
+        registry.open(streamId: "s2")
+        registry.attach(streamId: "s1", run: makeRun(recorder: first))
+        registry.attach(streamId: "s2", run: makeRun(recorder: second))
+
+        registry.requestCancel(streamId: "s1", reason: "only the first")
+
+        XCTAssertEqual(first.reasons, ["only the first"])
+        XCTAssertEqual(second.count, 0)
+        XCTAssertEqual(registry.activeCount, 2)
+    }
+
+    func testCancelAllCancelsEveryRunOnceAndEmptiesTheRegistry() {
+        let registry = StreamRegistry()
+        let first = CancelRecorder()
+        let second = CancelRecorder()
+
+        registry.open(streamId: "s1")
+        registry.open(streamId: "s2")
+        registry.attach(streamId: "s1", run: makeRun(recorder: first))
+        registry.attach(streamId: "s2", run: makeRun(recorder: second))
+
+        registry.cancelAll(reason: "torn down")
+
+        XCTAssertEqual(first.reasons, ["torn down"])
+        XCTAssertEqual(second.reasons, ["torn down"])
+        XCTAssertEqual(registry.activeCount, 0)
+    }
+
+    func testAttachAfterTeardownReportsCancelRequested() {
+        let registry = StreamRegistry()
+        let recorder = CancelRecorder()
+
+        registry.open(streamId: "s1")
+        registry.cancelAll(reason: "torn down")
+
+        // The entry is gone, so the run that arrives late must be cancelled by its caller.
+        XCTAssertEqual(
+            registry.attach(streamId: "s1", run: makeRun(recorder: recorder)),
+            .cancelRequested(reason: nil)
+        )
+    }
+}