@dvai-bridge/ios 4.0.0

package/ios/Sources/DVAIBridge/DVAIBridgeConfig.swift

@@ -0,0 +1,86 @@
+import Foundation
+
+public struct DVAIBridgeConfig: Sendable {
+    public enum CORSOrigin: Sendable {
+        case wildcard
+        case exact(String)
+        case allowlist([String])
+    }
+
+    public var backend: BackendKind
+    public var modelPath: String?
+    public var mmprojPath: String?
+    public var tokenizerPath: String?
+    public var gpuLayers: Int
+    public var contextSize: Int
+    public var threads: Int
+    public var embeddingMode: Bool
+    public var httpBasePort: Int
+    public var httpMaxPortAttempts: Int
+    public var corsOrigin: CORSOrigin
+    public var autoUnloadOnLowMemory: Bool
+    public var logLevel: String  // "silent" | "info" | "debug" — matches the Capacitor surface
+
+    public init(
+        backend: BackendKind = .auto,
+        modelPath: String? = nil,
+        mmprojPath: String? = nil,
+        tokenizerPath: String? = nil,
+        gpuLayers: Int = 99,
+        contextSize: Int = 2048,
+        threads: Int = 4,
+        embeddingMode: Bool = false,
+        httpBasePort: Int = 38883,
+        httpMaxPortAttempts: Int = 16,
+        corsOrigin: CORSOrigin = .wildcard,
+        autoUnloadOnLowMemory: Bool = false,
+        logLevel: String = "info"
+    ) {
+        self.backend = backend
+        self.modelPath = modelPath
+        self.mmprojPath = mmprojPath
+        self.tokenizerPath = tokenizerPath
+        self.gpuLayers = gpuLayers
+        self.contextSize = contextSize
+        self.threads = threads
+        self.embeddingMode = embeddingMode
+        self.httpBasePort = httpBasePort
+        self.httpMaxPortAttempts = httpMaxPortAttempts
+        self.corsOrigin = corsOrigin
+        self.autoUnloadOnLowMemory = autoUnloadOnLowMemory
+        self.logLevel = logLevel
+    }
+
+    /// v3.2 — copy with `httpBasePort` overridden. Used by the
+    /// OffloadProxy lifecycle to push the backend off the user-facing
+    /// port (proxy claims `httpBasePort`, backend gets `httpBasePort + 100`).
+    public func with(httpBasePort newPort: Int) -> DVAIBridgeConfig {
+        var copy = self
+        copy.httpBasePort = newPort
+        return copy
+    }
+
+    /// Translate this config into the `[String: Any]` shape the underlying
+    /// core PluginStates expect (matches the Capacitor JSObject shape).
+    internal func toCoreOpts() -> [String: Any] {
+        var opts: [String: Any] = [
+            "gpuLayers": gpuLayers,
+            "contextSize": contextSize,
+            "threads": threads,
+            "embeddingMode": embeddingMode,
+            "httpBasePort": httpBasePort,
+            "httpMaxPortAttempts": httpMaxPortAttempts,
+            "autoUnloadOnLowMemory": autoUnloadOnLowMemory,
+            "logLevel": logLevel,
+        ]
+        if let modelPath { opts["modelPath"] = modelPath }
+        if let mmprojPath { opts["mmprojPath"] = mmprojPath }
+        if let tokenizerPath { opts["tokenizerPath"] = tokenizerPath }
+        switch corsOrigin {
+        case .wildcard: opts["corsOrigin"] = "*"
+        case .exact(let s): opts["corsOrigin"] = s
+        case .allowlist(let xs): opts["corsOrigin"] = xs
+        }
+        return opts
+    }
+}

package/ios/Sources/DVAIBridge/DVAIBridgeError.swift

@@ -0,0 +1,33 @@
+import Foundation
+
+public enum DVAIBridgeError: Error, LocalizedError, Sendable {
+    case notStarted
+    case alreadyStarted(currentBackend: BackendKind, baseUrl: String)
+    case configurationInvalid(reason: String)
+    case backendUnavailable(BackendKind, reason: String)
+    case modelLoadFailed(reason: String)
+    case downloadFailed(reason: String)
+    case checksumMismatch
+    case backendError(underlying: String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .notStarted:
+            return "DVAIBridge has not been started. Call DVAIBridge.shared.start(...) first."
+        case .alreadyStarted(let backend, let baseUrl):
+            return "DVAIBridge is already running with backend \(backend) at \(baseUrl). Call stop() before starting a new session."
+        case .configurationInvalid(let reason):
+            return "Configuration invalid: \(reason)"
+        case .backendUnavailable(let backend, let reason):
+            return "Backend \(backend) is unavailable on this device: \(reason)"
+        case .modelLoadFailed(let reason):
+            return "Model load failed: \(reason)"
+        case .downloadFailed(let reason):
+            return "Download failed: \(reason)"
+        case .checksumMismatch:
+            return "Downloaded file's SHA-256 didn't match the expected value. The file has been deleted from the cache."
+        case .backendError(let msg):
+            return "Backend error: \(msg)"
+        }
+    }
+}

package/ios/Sources/DVAIBridge/Discovery/MDNSPeer.swift

@@ -0,0 +1,64 @@
+import Foundation
+
+/// Swift-side `Peer` value mirroring the TypeScript `Peer` shape in
+/// `packages/dvai-bridge-core/src/discovery/types.ts`. Used by the
+/// iOS-native discovery layer (`NWBrowserDiscovery`) and surfaced to
+/// host apps via the offload module.
+public struct MDNSPeer: Sendable, Equatable, Codable, Hashable {
+    /// Stable per-install device ID of the peer.
+    public let deviceId: String
+    /// Human-readable hint (iOS device name, hostname, etc.).
+    public let deviceName: String
+    /// Library SemVer the peer is running.
+    public let dvaiVersion: String
+    /// OpenAI-compatible base URL the peer's local server exposes.
+    public let baseUrl: String
+    /// Models the peer claims to have loaded right now.
+    public let loadedModels: [String]
+    /// Peer-reported capability map: { modelId → tok/s }.
+    public let capability: [String: Double]
+    /// Discovery source — useful for diagnostics.
+    public let via: Via
+    /// Whether the peer's URL uses TLS.
+    public let secure: Bool
+    /// Last-seen unix ms — discovery sources update this.
+    public let lastSeenAt: Int64
+
+    public enum Via: String, Sendable, Codable, Hashable {
+        case mdns
+        case `static`
+        case rendezvous
+        case custom
+    }
+
+    public init(
+        deviceId: String,
+        deviceName: String,
+        dvaiVersion: String,
+        baseUrl: String,
+        loadedModels: [String] = [],
+        capability: [String: Double] = [:],
+        via: Via = .mdns,
+        secure: Bool = false,
+        lastSeenAt: Int64 = Int64(Date().timeIntervalSince1970 * 1000)
+    ) {
+        self.deviceId = deviceId
+        self.deviceName = deviceName
+        self.dvaiVersion = dvaiVersion
+        self.baseUrl = baseUrl
+        self.loadedModels = loadedModels
+        self.capability = capability
+        self.via = via
+        self.secure = secure
+        self.lastSeenAt = lastSeenAt
+    }
+}
+
+/// Service-type advertised on mDNS for dvai-bridge instances. Mirrors the
+/// `MDNS_SERVICE_TYPE` constant in `discovery/types.ts`.
+public enum DVAIBridgeMDNS {
+    public static let serviceType = "_dvai-bridge._tcp"
+    public static let serviceDomain = "local."
+    /// Full DNS-SD service-type form used by some APIs.
+    public static let serviceTypeFull = "_dvai-bridge._tcp.local"
+}

package/ios/Sources/DVAIBridge/Discovery/NWAdvertiser.swift

@@ -0,0 +1,103 @@
+import Foundation
+import Network
+
+/// Advertises THIS device on Bonjour as a `_dvai-bridge._tcp` service
+/// using `NWListener`. The TXT record carries the fields documented in
+/// the design spec section 4.2.
+@available(iOS 14.0, macOS 11.0, *)
+public actor NWAdvertiser {
+    public struct Advertisement: Sendable, Equatable {
+        public let deviceId: String
+        public let deviceName: String
+        public let dvaiVersion: String
+        public let port: Int
+        public let secure: Bool
+        public let loadedModels: [String]
+        public let capability: [String: Double]
+
+        public init(
+            deviceId: String,
+            deviceName: String,
+            dvaiVersion: String,
+            port: Int,
+            secure: Bool = false,
+            loadedModels: [String] = [],
+            capability: [String: Double] = [:]
+        ) {
+            self.deviceId = deviceId
+            self.deviceName = deviceName
+            self.dvaiVersion = dvaiVersion
+            self.port = port
+            self.secure = secure
+            self.loadedModels = loadedModels
+            self.capability = capability
+        }
+    }
+
+    private var listener: NWListener?
+    private var advertised: Advertisement?
+
+    public init() {}
+
+    /// Start advertising. Idempotent — if already advertising, the new
+    /// advertisement supersedes the old one.
+    public func start(_ ad: Advertisement) async throws {
+        await stop()
+
+        let params = NWParameters.tcp
+        params.allowLocalEndpointReuse = true
+        // Use a TCP listener bound to the same advertisement port. The
+        // listener itself doesn't have to actually accept connections —
+        // the upstream embedded HTTP server does that on the same port.
+        // We just need the Bonjour record present.
+        let port = NWEndpoint.Port(rawValue: UInt16(ad.port)) ?? .any
+        let listener = try NWListener(using: params, on: port)
+        // Important: we're advertising a service that ANOTHER socket
+        // (the Telegraph HTTP server) actually listens on. NWListener
+        // would normally accept these connections — null-route them
+        // by just cancelling immediately. The Bonjour TXT record is
+        // what we care about.
+        listener.newConnectionHandler = { conn in
+            conn.cancel()
+        }
+
+        let txt = Self.makeTxtRecord(ad)
+        listener.service = NWListener.Service(
+            name: ad.deviceName,
+            type: DVAIBridgeMDNS.serviceType,
+            domain: nil,
+            txtRecord: txt
+        )
+
+        listener.start(queue: .global(qos: .utility))
+        self.listener = listener
+        self.advertised = ad
+    }
+
+    public func stop() async {
+        listener?.cancel()
+        listener = nil
+        advertised = nil
+    }
+
+    public func currentAdvertisement() -> Advertisement? {
+        advertised
+    }
+
+    /// Build the Bonjour TXT record for an advertisement. Mirrors the
+    /// fields documented in the design spec section 4.2.
+    static func makeTxtRecord(_ ad: Advertisement) -> NWTXTRecord {
+        var rec = NWTXTRecord()
+        rec["deviceId"] = ad.deviceId
+        rec["deviceName"] = ad.deviceName
+        rec["dvaiVersion"] = ad.dvaiVersion
+        rec["port"] = String(ad.port)
+        rec["secure"] = ad.secure ? "1" : "0"
+        rec["models"] = ad.loadedModels.joined(separator: ",")
+        if let capData = try? JSONSerialization.data(withJSONObject: ad.capability),
+           let capStr = String(data: capData, encoding: .utf8) {
+            rec["capability"] = capStr
+        }
+        return rec
+    }
+}

package/ios/Sources/DVAIBridge/Discovery/NWBrowserDiscovery.swift

@@ -0,0 +1,212 @@
+import Foundation
+import Network
+
+/// LAN peer discovery via Apple's Network framework. Uses `NWBrowser`
+/// with the Bonjour service-type `_dvai-bridge._tcp` and parses TXT
+/// records into `MDNSPeer` values.
+///
+/// Mirrors the contract of `IDiscovery` in
+/// `packages/dvai-bridge-core/src/discovery/types.ts`.
+@available(iOS 14.0, macOS 11.0, *)
+public actor NWBrowserDiscovery {
+    public enum Event: Sendable {
+        case peerUp(MDNSPeer)
+        case peerDown(deviceId: String)
+        case error(String)
+    }
+
+    private let browser: NWBrowser
+    /// Map: endpointDescription → resolved peer. NWBrowser uses
+    /// `NWBrowser.Result` whose endpoint is the stable identity for
+    /// add/remove tracking.
+    private var resultsByEndpoint: [String: MDNSPeer] = [:]
+    private let continuation: AsyncStream<Event>.Continuation
+    public nonisolated let events: AsyncStream<Event>
+    private var started = false
+    /// Our own deviceId. NWBrowser surfaces the local device's own
+    /// `_dvai-bridge._tcp` advertisement alongside remote peers, so
+    /// we filter parses whose `deviceId` matches and refuse to emit
+    /// peerUp events for them. Set by `OffloadRuntime.start()`
+    /// before `start()` is called.
+    private var selfDeviceId: String?
+
+    public init() {
+        let descriptor = NWBrowser.Descriptor.bonjourWithTXTRecord(
+            type: DVAIBridgeMDNS.serviceType,
+            domain: nil
+        )
+        self.browser = NWBrowser(for: descriptor, using: NWParameters())
+        var savedContinuation: AsyncStream<Event>.Continuation!
+        self.events = AsyncStream<Event> { c in
+            savedContinuation = c
+        }
+        self.continuation = savedContinuation
+    }
+
+    /// Configure self-filtering. Called from `OffloadRuntime.start`
+    /// once the deviceId is resolved. Without this, the OffloadProxy
+    /// would see (and try to forward to) the iPhone's own service.
+    public func setSelfDeviceId(_ id: String) {
+        self.selfDeviceId = id
+        // Drop any already-known peers that match — racing peerUp
+        // events can land before the id is set.
+        for (key, peer) in resultsByEndpoint where peer.deviceId == id {
+            resultsByEndpoint.removeValue(forKey: key)
+        }
+    }
+
+    /// Start browsing. Idempotent.
+    public func start() {
+        guard !started else { return }
+        started = true
+
+        browser.browseResultsChangedHandler = { [weak self] results, changes in
+            guard let self else { return }
+            Task { await self.handleChanges(results: results, changes: changes) }
+        }
+        browser.stateUpdateHandler = { [weak self] state in
+            guard let self else { return }
+            Task { await self.handleState(state) }
+        }
+        browser.start(queue: .global(qos: .utility))
+    }
+
+    /// Stop browsing. Idempotent.
+    public func stop() {
+        guard started else { return }
+        started = false
+        browser.cancel()
+        continuation.finish()
+    }
+
+    /// Snapshot of currently-known peers.
+    public func peers() -> [MDNSPeer] {
+        Array(resultsByEndpoint.values)
+    }
+
+    private func handleState(_ state: NWBrowser.State) {
+        switch state {
+        case .failed(let err):
+            continuation.yield(.error("NWBrowser failed: \(err)"))
+        case .cancelled:
+            continuation.yield(.error("NWBrowser cancelled"))
+        default:
+            break
+        }
+    }
+
+    private func handleChanges(
+        results: Set<NWBrowser.Result>,
+        changes: Set<NWBrowser.Result.Change>
+    ) {
+        for change in changes {
+            switch change {
+            case .added(let result):
+                if let peer = parsePeer(from: result) {
+                    if let myId = self.selfDeviceId, peer.deviceId == myId {
+                        // Skip our own advertisement — NWBrowser
+                        // doesn't filter self automatically.
+                        continue
+                    }
+                    let key = endpointKey(result.endpoint)
+                    resultsByEndpoint[key] = peer
+                    continuation.yield(.peerUp(peer))
+                }
+            case .removed(let result):
+                let key = endpointKey(result.endpoint)
+                if let peer = resultsByEndpoint.removeValue(forKey: key) {
+                    continuation.yield(.peerDown(deviceId: peer.deviceId))
+                }
+            case .changed(let old, let new, _):
+                let oldKey = endpointKey(old.endpoint)
+                let newKey = endpointKey(new.endpoint)
+                if let peer = parsePeer(from: new) {
+                    if let myId = self.selfDeviceId, peer.deviceId == myId {
+                        // Drop any cached entry — never emit self.
+                        resultsByEndpoint.removeValue(forKey: oldKey)
+                        resultsByEndpoint.removeValue(forKey: newKey)
+                        continue
+                    }
+                    if oldKey != newKey {
+                        resultsByEndpoint.removeValue(forKey: oldKey)
+                    }
+                    resultsByEndpoint[newKey] = peer
+                    continuation.yield(.peerUp(peer))
+                }
+            case .identical:
+                break
+            @unknown default:
+                break
+            }
+        }
+    }
+
+    private func endpointKey(_ endpoint: NWEndpoint) -> String {
+        return "\(endpoint)"
+    }
+
+    /// Parse an `NWBrowser.Result` (which carries the TXT metadata)
+    /// into an `MDNSPeer`. Returns nil if the TXT record doesn't
+    /// carry the minimum-required fields.
+    private func parsePeer(from result: NWBrowser.Result) -> MDNSPeer? {
+        guard case .bonjour(let txt) = result.metadata else { return nil }
+        let dict = txt.dictionary
+        guard let deviceId = dict["deviceId"], !deviceId.isEmpty else { return nil }
+        let deviceName = dict["deviceName"] ?? "Unknown"
+        let dvaiVersion = dict["dvaiVersion"] ?? "0.0.0"
+        let portStr = dict["port"] ?? "38883"
+        let port = Int(portStr) ?? 38883
+        let secure = (dict["secure"] ?? "0") == "1"
+
+        // Try to extract a host from the endpoint. NWBrowser endpoints
+        // are typically `.service(name, type, domain, _)` form; the
+        // resolved hostname:port comes through after a connection
+        // resolves. For the offload module the baseUrl is the canonical
+        // `http://{host}:{port}/v1` once we resolve, but at browse-time
+        // we synthesize a placeholder using the bonjour service name.
+        let host = bonjourServiceName(from: result.endpoint) ?? "unknown.local"
+        let scheme = secure ? "https" : "http"
+        let baseUrl = "\(scheme)://\(host):\(port)/v1"
+
+        let loadedModels = (dict["models"] ?? "").split(separator: ",").map { String($0) }.filter { !$0.isEmpty }
+        let capability = parseCapability(dict["capability"]) ?? [:]
+
+        return MDNSPeer(
+            deviceId: deviceId,
+            deviceName: deviceName,
+            dvaiVersion: dvaiVersion,
+            baseUrl: baseUrl,
+            loadedModels: loadedModels,
+            capability: capability,
+            via: .mdns,
+            secure: secure,
+            lastSeenAt: Int64(Date().timeIntervalSince1970 * 1000)
+        )
+    }
+
+    private func bonjourServiceName(from endpoint: NWEndpoint) -> String? {
+        if case .service(let name, _, _, _) = endpoint {
+            // Bonjour service-instance names sometimes already carry a
+            // `.local` suffix when the advertiser uses the device's
+            // mDNS hostname (e.g. iPhone advertising as
+            // `Deeps-iPhone.local`). Appending another `.local`
+            // unconditionally produced URLs like
+            // `http://deeps-iphone.local.local:38883` which fail to
+            // resolve. Strip a trailing `.local` (and stray trailing
+            // dot) BEFORE re-appending so the result is always
+            // `<host>.local`.
+            var trimmed = name
+            if trimmed.hasSuffix(".") { trimmed.removeLast() }
+            if trimmed.hasSuffix(".local") {
+                trimmed = String(trimmed.dropLast(".local".count))
+            }
+            return "\(trimmed).local"
+        }
+        return nil
+    }
+
+    private func parseCapability(_ raw: String?) -> [String: Double]? {
+        guard let raw = raw, let data = raw.data(using: .utf8) else { return nil }
+        return (try? JSONDecoder().decode([String: Double].self, from: data))
+    }
+}

package/ios/Sources/DVAIBridge/Internal/BackendSelector.swift

@@ -0,0 +1,59 @@
+import Foundation
+
+internal enum BackendSelector {
+    /// Resolve `.auto` to a concrete backend; pass-through for explicit choices.
+    /// - Throws `DVAIBridgeError.configurationInvalid` if `.auto` can't decide.
+    static func resolve(_ kind: BackendKind, config: DVAIBridgeConfig) throws -> BackendKind {
+        if kind != .auto { return kind }
+
+        // 1. modelPath ending in .gguf → .llama
+        if let path = config.modelPath, path.hasSuffix(".gguf") {
+            return .llama
+        }
+
+        // 2. modelPath ending in .mlmodelc / .mlpackage → .coreml
+        if let path = config.modelPath,
+           path.hasSuffix(".mlmodelc") || path.hasSuffix(".mlpackage") {
+            return .coreml
+        }
+
+        // 3. modelPath ending in .task / .litertlm → no iOS backend supports
+        //    those; fall through to error
+        if let path = config.modelPath,
+           path.hasSuffix(".task") || path.hasSuffix(".litertlm") {
+            throw DVAIBridgeError.configurationInvalid(reason:
+                "Model file '\(path)' is a MediaPipe / LiteRT-LM format. " +
+                "Use it via the Android SDK; iOS supports llama.cpp (.gguf), " +
+                "Apple Foundation Models (no file), and CoreML (.mlmodelc / .mlpackage).")
+        }
+
+        // 4. No modelPath + iOS 26+ → .foundation
+        if config.modelPath == nil {
+            if #available(iOS 26.0, macOS 26.0, *) {
+                return .foundation
+            }
+            throw DVAIBridgeError.configurationInvalid(reason:
+                "auto backend requires either modelPath (for .llama / .coreml) " +
+                "or iOS 26+ (for .foundation). Set DVAIBridgeConfig.backend explicitly.")
+        }
+
+        // 5. modelPath looks like a HuggingFace id ("<owner>/<repo>" with no
+        //    file extension) → likely MLX. Don't auto-resolve here because
+        //    not every HF id is MLX (could be GGUF in a HF repo etc.) and
+        //    .mlx requires Apple Silicon at runtime. Provide a clear hint.
+        if let path = config.modelPath,
+           path.contains("/"),
+           !path.contains(".") {
+            throw DVAIBridgeError.configurationInvalid(reason:
+                "modelPath '\(path)' looks like a HuggingFace identifier. " +
+                "If this is an MLX-converted checkpoint (e.g. 'mlx-community/...'), " +
+                "set DVAIBridgeConfig.backend = .mlx explicitly — `.auto` won't " +
+                "infer MLX because not every HF id is an MLX checkpoint.")
+        }
+
+        // 6. Unknown extension
+        throw DVAIBridgeError.configurationInvalid(reason:
+            "auto backend can't infer from modelPath '\(config.modelPath ?? "<nil>")'. " +
+            "Set DVAIBridgeConfig.backend = .llama / .foundation / .coreml / .mlx explicitly.")
+    }
+}

package/ios/Sources/DVAIBridge/Internal/ProgressBroadcaster.swift

@@ -0,0 +1,84 @@
+import Foundation
+import Combine
+
+/// Internal event broadcaster. Backs three public observation surfaces:
+/// `progressPublisher` (Combine), `progressStream` (AsyncStream), and
+/// `addProgressListener(_:)` (callback). All three observe the same source.
+internal final class ProgressBroadcaster: @unchecked Sendable {
+    // Combine
+    private let subject = PassthroughSubject<ProgressEvent, Never>()
+    var publisher: AnyPublisher<ProgressEvent, Never> { subject.eraseToAnyPublisher() }
+
+    // AsyncStream — one continuation per consumer
+    private let lock = NSLock()
+    private var continuations: [UUID: AsyncStream<ProgressEvent>.Continuation] = [:]
+
+    // Callback — one entry per addProgressListener call
+    private var callbacks: [UUID: @Sendable (ProgressEvent) -> Void] = [:]
+
+    func emit(_ event: ProgressEvent) {
+        subject.send(event)
+
+        lock.lock()
+        let conts = continuations.values
+        let cbs = Array(callbacks.values)
+        lock.unlock()
+
+        for cont in conts { cont.yield(event) }
+        for cb in cbs { cb(event) }
+    }
+
+    func makeStream() -> AsyncStream<ProgressEvent> {
+        let id = UUID()
+        return AsyncStream { continuation in
+            lock.lock()
+            continuations[id] = continuation
+            lock.unlock()
+
+            continuation.onTermination = { [weak self] _ in
+                self?.lock.lock()
+                self?.continuations.removeValue(forKey: id)
+                self?.lock.unlock()
+            }
+        }
+    }
+
+    @discardableResult
+    func addCallback(_ cb: @escaping @Sendable (ProgressEvent) -> Void) -> CancellationToken {
+        let id = UUID()
+        lock.lock()
+        callbacks[id] = cb
+        lock.unlock()
+
+        return CancellationToken { [weak self] in
+            self?.lock.lock()
+            self?.callbacks.removeValue(forKey: id)
+            self?.lock.unlock()
+        }
+    }
+}
+
+/// Caller-held token returned by `addProgressListener(_:)`. Drop or call
+/// `.cancel()` to stop receiving events.
+public final class CancellationToken: @unchecked Sendable {
+    private let cancelClosure: @Sendable () -> Void
+    private var cancelled = false
+    private let lock = NSLock()
+
+    internal init(cancel: @escaping @Sendable () -> Void) {
+        self.cancelClosure = cancel
+    }
+
+    public func cancel() {
+        lock.lock()
+        defer { lock.unlock() }
+        if !cancelled {
+            cancelled = true
+            cancelClosure()
+        }
+    }
+
+    deinit {
+        cancel()
+    }
+}