@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/AVFoundation/Asset.swift

@@ -0,0 +1,487 @@
+// Assets: a URL and what the page can tell about it. `AVAsset` reads nothing
+// itself; a `load` asks the page to open the media's metadata (a `media`
+// probe: duration and video size) once per asset, as `AsyncImage` asks for an
+// image's size. A file URL is first handed to the page as a blob.
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+import struct SwiftUI.CGSize
+import struct SwiftUI.CGRect
+import UIKit
+
+/// What the page read from a media file's metadata.
+struct _AVMediaInfo: Sendable, Equatable {
+    /// Seconds; nil for a live stream or a length the file does not state.
+    var duration: Double?
+    /// The video's size in pixels; 0 × 0 for audio.
+    var width: Double
+    var height: Double
+}
+
+/// The page's side of media: blobs for files, metadata probes. Tests replace `perform`.
+@MainActor
+enum _AVMediaHost {
+    static var perform: @MainActor (_JSON) async throws -> _JSON = { params in
+        try await _Runtime.shared._hostRequest(kind: "media", params: params)
+    }
+
+    /// A URL the page can load for `url`: remote, data and blob URLs as they
+    /// are; a file's bytes as a blob URL (made once per file URL).
+    static func pageURL(for url: URL) async throws -> String {
+        guard url.isFileURL else { return url.absoluteString }
+        if let known = blobs[url] { return known }
+        let data: Data
+        do {
+            data = try Data(contentsOf: url)
+        } catch {
+            throw AVError(.contentIsUnavailable, message: "cannot read \(url.path): \(error)")
+        }
+        let answer = try await perform(.object([
+            "action": .string("file"),
+            "name": .string(url.lastPathComponent),
+            "type": .string(_mimeType(forPathExtension: url.pathExtension)),
+            "data": .string(_base64(Array(data))),
+        ]))
+        guard case .object(let fields) = answer, case .string(let pageURL)? = fields["url"] else {
+            throw AVError(.unknown, message: "the page made no URL for \(url.lastPathComponent)")
+        }
+        blobs[url] = pageURL
+        return pageURL
+    }
+
+    private static var blobs: [URL: String] = [:]
+
+    /// The metadata of the media at `url`.
+    static func probe(_ url: URL) async throws -> _AVMediaInfo {
+        let pageURL = try await pageURL(for: url)
+        let answer: _JSON
+        do {
+            answer = try await perform(.object(["action": .string("probe"), "url": .string(pageURL)]))
+        } catch {
+            throw AVError(.failedToLoadMediaData, message: "\(error)")
+        }
+        guard case .object(let fields) = answer else { throw AVError(.fileFormatNotRecognized) }
+        func number(_ key: String) -> Double? {
+            if case .number(let value)? = fields[key], value.isFinite { return value }
+            return nil
+        }
+        return _AVMediaInfo(duration: number("duration"), width: number("width") ?? 0, height: number("height") ?? 0)
+    }
+}
+
+// MARK: - Assets
+
+/// The state of a value an asset loads (`statusOfValue(forKey:error:)`).
+public enum AVKeyValueStatus: Int, Sendable {
+    case unknown, loading, loaded, failed, cancelled
+}
+
+/// A timed media resource. Make one with `AVURLAsset(url:)` (or `AVAsset(url:)`).
+open class AVAsset: @unchecked Sendable {
+    /// The resource; nil only for subclasses that have none.
+    let _url: URL?
+    private var info: _AVMediaInfo?
+    private var loadError: (any Error)?
+    private var probing: Task<_AVMediaInfo, any Error>?
+
+    public init(url URL: URL) {
+        _url = URL
+    }
+
+    init(_noURL: Void) {
+        _url = nil
+    }
+
+    /// The metadata, from the page (once).
+    @MainActor
+    func _info() async throws -> _AVMediaInfo {
+        if let info { return info }
+        if let loadError { throw loadError }
+        guard let url = _url else { throw AVError(.operationNotSupportedForAsset) }
+        let task = probing ?? Task { @MainActor in try await _AVMediaHost.probe(url) }
+        probing = task
+        do {
+            let value = try await task.value
+            info = value
+            return value
+        } catch {
+            loadError = error
+            throw error
+        }
+    }
+
+    /// Metadata the player learned while playing the asset (its `ready` event).
+    func _learn(_ value: _AVMediaInfo) {
+        if info == nil { info = value }
+    }
+
+    /// The duration, if loaded (`load(.duration)`); `.indefinite` until then
+    /// and for a live stream.
+    @available(*, deprecated, message: "Use load(.duration) instead")
+    open var duration: CMTime { _knownDuration }
+
+    var _knownDuration: CMTime { CMTime(_seconds: info?.duration) }
+
+    @available(*, deprecated, message: "Use load(.isPlayable) instead")
+    open var isPlayable: Bool { loadError == nil }
+
+    @available(*, deprecated, message: "Use load(.tracks) instead")
+    open var tracks: [AVAssetTrack] { info.map { AVAssetTrack._tracks(of: self, info: $0) } ?? [] }
+
+    open var preferredRate: Float { 1 }
+    open var preferredVolume: Float { 1 }
+    open var preferredTransform: CGAffineTransform { .identity }
+    open var providesPreciseDurationAndTiming: Bool { false }
+
+    /// Loads the values for `keys` ("duration", "playable", "tracks"), then calls `handler`.
+    open func loadValuesAsynchronously(forKeys keys: [String], completionHandler handler: (@Sendable () -> Void)? = nil) {
+        Task { @MainActor in
+            _ = try? await self._info()
+            handler?()
+        }
+    }
+
+    open func statusOfValue(forKey key: String, error outError: UnsafeMutablePointer<NSError?>?) -> AVKeyValueStatus {
+        if info != nil { return .loaded }
+        if let loadError {
+            outError?.pointee = NSError(domain: AVFoundationErrorDomain, code: (loadError as? AVError)?.code.rawValue ?? AVError.Code.unknown.rawValue,
+                                        userInfo: [NSLocalizedDescriptionKey: "\(loadError)"])
+            return .failed
+        }
+        return probing == nil ? .unknown : .loading
+    }
+
+    open func cancelLoading() {}
+
+    /// Loads one value (`AVAsyncProperty`'s key).
+    @MainActor
+    func _load(_ key: String) async throws -> any Sendable {
+        switch key {
+        case "isPlayable":
+            return (try? await _info()) != nil
+        case "duration":
+            return CMTime(_seconds: try await _info().duration)
+        case "tracks":
+            return AVAssetTrack._tracks(of: self, info: try await _info())
+        case "preferredRate", "preferredVolume":
+            return Float(1)
+        case "preferredTransform":
+            return CGAffineTransform.identity
+        case "isExportable", "isReadable":
+            return _url?.isFileURL == true
+        case "metadata", "commonMetadata":
+            return [AVMetadataItem]()
+        default:
+            throw AVError(.operationNotSupportedForAsset, message: "cannot load \(key)")
+        }
+    }
+}
+
+/// An asset at a URL: a remote file or stream, a data URL, or a file of the
+/// app's (bundle, home, temporary directory).
+open class AVURLAsset: AVAsset, @unchecked Sendable {
+    public let url: URL
+
+    /// `options` (precise timing, HTTP headers…) are kept and not applied:
+    /// the browser loads the media with its own requests.
+    public init(url URL: URL, options: [String: Any]? = nil) {
+        url = URL
+        super.init(url: URL)
+    }
+
+    public static func audiovisualTypes() -> [AVFileType] { [.mp4, .mov, .m4v, .m4a, .mp3, .wav] }
+    public static func audiovisualMIMETypes() -> [String] { ["video/mp4", "video/quicktime", "video/webm", "audio/mpeg", "audio/mp4", "audio/wav"] }
+    public static func isPlayableExtendedMIMEType(_ extendedMIMEType: String) -> Bool {
+        let type = extendedMIMEType.lowercased()
+        return type.hasPrefix("video/") || type.hasPrefix("audio/")
+    }
+}
+
+public let AVURLAssetPreferPreciseDurationAndTimingKey = "AVURLAssetPreferPreciseDurationAndTimingKey"
+public let AVURLAssetHTTPHeaderFieldsKey = "AVURLAssetHTTPHeaderFieldsKey"
+public let AVURLAssetAllowsCellularAccessKey = "AVURLAssetAllowsCellularAccessKey"
+
+/// A metadata item; assets report none (the page reads no tags).
+open class AVMetadataItem: @unchecked Sendable {
+    open var identifier: String? { nil }
+    open var stringValue: String? { nil }
+    open var value: (any Sendable)? { nil }
+}
+
+/// A track of an asset. The page reports a video's size, so an asset with a
+/// picture has one video track; audio tracks are not reported.
+open class AVAssetTrack: @unchecked Sendable {
+    public private(set) weak var asset: AVAsset?
+    public let trackID: Int32
+    public let mediaType: AVMediaType
+    public let naturalSize: CGSize
+    open var preferredTransform: CGAffineTransform { .identity }
+    open var nominalFrameRate: Float { 0 }
+    open var isPlayable: Bool { true }
+    open var timeRange: CMTimeRange { CMTimeRange(start: .zero, duration: asset?._knownDuration ?? .indefinite) }
+
+    init(asset: AVAsset, trackID: Int32, mediaType: AVMediaType, naturalSize: CGSize) {
+        self.asset = asset
+        self.trackID = trackID
+        self.mediaType = mediaType
+        self.naturalSize = naturalSize
+    }
+
+    static func _tracks(of asset: AVAsset, info: _AVMediaInfo) -> [AVAssetTrack] {
+        guard info.width > 0, info.height > 0 else { return [] }
+        return [AVAssetTrack(asset: asset, trackID: 1, mediaType: .video, naturalSize: CGSize(width: info.width, height: info.height))]
+    }
+
+    open func hasMediaCharacteristic(_ characteristic: String) -> Bool { false }
+
+    @MainActor
+    func _load(_ key: String) async throws -> any Sendable {
+        switch key {
+        case "naturalSize": return naturalSize
+        case "preferredTransform": return CGAffineTransform.identity
+        case "mediaType": return mediaType
+        case "nominalFrameRate": return Float(0)
+        case "timeRange": return CMTimeRange(start: .zero, duration: try await asset?._load("duration") as? CMTime ?? .indefinite)
+        case "isPlayable": return true
+        default: throw AVError(.operationNotSupportedForAsset, message: "cannot load \(key)")
+        }
+    }
+}
+
+extension CMTime {
+    /// Seconds from the page, at a timescale of 600 (Core Media's video
+    /// default); nil is `.indefinite`.
+    init(_seconds seconds: Double?) {
+        guard let seconds, seconds.isFinite else {
+            self = seconds == .infinity ? .positiveInfinity : .indefinite
+            return
+        }
+        self.init(seconds: seconds, preferredTimescale: 600)
+    }
+}
+
+// MARK: - Loading values
+
+/// A value of `Root` that loads asynchronously (`asset.load(.duration)`).
+public class AVPartialAsyncProperty<Root>: @unchecked Sendable {
+    let key: String
+    init(key: String) { self.key = key }
+}
+
+public final class AVAsyncProperty<Root, Value>: AVPartialAsyncProperty<Root>, @unchecked Sendable {
+    /// Whether a value has loaded (`status(of:)`).
+    public enum Status: @unchecked Sendable {
+        case notYetLoaded, loading, loaded(Value), failed(any Error)
+    }
+}
+
+extension AVAsyncProperty where Root: AVAsset, Value == CMTime {
+    public static var duration: AVAsyncProperty<Root, CMTime> { .init(key: "duration") }
+}
+extension AVAsyncProperty where Root: AVAsset, Value == Bool {
+    public static var isPlayable: AVAsyncProperty<Root, Bool> { .init(key: "isPlayable") }
+    public static var isExportable: AVAsyncProperty<Root, Bool> { .init(key: "isExportable") }
+    public static var isReadable: AVAsyncProperty<Root, Bool> { .init(key: "isReadable") }
+}
+extension AVAsyncProperty where Root: AVAsset, Value == [AVAssetTrack] {
+    public static var tracks: AVAsyncProperty<Root, [AVAssetTrack]> { .init(key: "tracks") }
+}
+extension AVAsyncProperty where Root: AVAsset, Value == Float {
+    public static var preferredRate: AVAsyncProperty<Root, Float> { .init(key: "preferredRate") }
+    public static var preferredVolume: AVAsyncProperty<Root, Float> { .init(key: "preferredVolume") }
+}
+extension AVAsyncProperty where Root: AVAsset, Value == CGAffineTransform {
+    public static var preferredTransform: AVAsyncProperty<Root, CGAffineTransform> { .init(key: "preferredTransform") }
+}
+extension AVAsyncProperty where Root: AVAsset, Value == [AVMetadataItem] {
+    public static var metadata: AVAsyncProperty<Root, [AVMetadataItem]> { .init(key: "metadata") }
+    public static var commonMetadata: AVAsyncProperty<Root, [AVMetadataItem]> { .init(key: "commonMetadata") }
+}
+extension AVAsyncProperty where Root: AVAssetTrack, Value == CGSize {
+    public static var naturalSize: AVAsyncProperty<Root, CGSize> { .init(key: "naturalSize") }
+}
+extension AVAsyncProperty where Root: AVAssetTrack, Value == CGAffineTransform {
+    public static var preferredTransform: AVAsyncProperty<Root, CGAffineTransform> { .init(key: "preferredTransform") }
+}
+extension AVAsyncProperty where Root: AVAssetTrack, Value == Float {
+    public static var nominalFrameRate: AVAsyncProperty<Root, Float> { .init(key: "nominalFrameRate") }
+}
+extension AVAsyncProperty where Root: AVAssetTrack, Value == CMTimeRange {
+    public static var timeRange: AVAsyncProperty<Root, CMTimeRange> { .init(key: "timeRange") }
+}
+
+/// Types whose values load asynchronously: assets and their tracks.
+public protocol AVAsynchronousKeyValueLoading {}
+extension AVAsset: AVAsynchronousKeyValueLoading {}
+extension AVAssetTrack: AVAsynchronousKeyValueLoading {}
+
+extension AVAsynchronousKeyValueLoading where Self: AVAsset {
+    public func load<T>(_ property: AVAsyncProperty<Self, T>) async throws -> T {
+        try await _cast(_load(property.key))
+    }
+
+    public func load<A, B>(_ a: AVAsyncProperty<Self, A>, _ b: AVAsyncProperty<Self, B>) async throws -> (A, B) {
+        (try await load(a), try await load(b))
+    }
+
+    public func load<A, B, C>(_ a: AVAsyncProperty<Self, A>, _ b: AVAsyncProperty<Self, B>, _ c: AVAsyncProperty<Self, C>) async throws -> (A, B, C) {
+        (try await load(a), try await load(b), try await load(c))
+    }
+
+    /// The video (or other) tracks, once the metadata has loaded.
+    public func loadTracks(withMediaType mediaType: AVMediaType) async throws -> [AVAssetTrack] {
+        try await load(.tracks).filter { $0.mediaType == mediaType }
+    }
+
+    public func loadTracks(withMediaType mediaType: AVMediaType, completionHandler: @escaping @Sendable ([AVAssetTrack]?, (any Error)?) -> Void) {
+        Task {
+            do { completionHandler(try await loadTracks(withMediaType: mediaType), nil) } catch { completionHandler(nil, error) }
+        }
+    }
+}
+
+extension AVAsynchronousKeyValueLoading where Self: AVAssetTrack {
+    public func load<T>(_ property: AVAsyncProperty<Self, T>) async throws -> T {
+        try await _cast(_load(property.key))
+    }
+
+    public func load<A, B>(_ a: AVAsyncProperty<Self, A>, _ b: AVAsyncProperty<Self, B>) async throws -> (A, B) {
+        (try await load(a), try await load(b))
+    }
+}
+
+private func _cast<T>(_ value: any Sendable) throws -> T {
+    guard let typed = value as? T else { throw AVError(.unknown, message: "unexpected value \(value)") }
+    return typed
+}
+
+// MARK: - Images and exports
+
+/// Frames of a video as images. Swift holds no decoded frames (the page
+/// decodes video), so every request fails with `operationNotSupportedForAsset`.
+open class AVAssetImageGenerator: @unchecked Sendable {
+    public let asset: AVAsset
+    open var appliesPreferredTrackTransform = false
+    open var maximumSize: CGSize = .zero
+    open var requestedTimeToleranceBefore: CMTime = .positiveInfinity
+    open var requestedTimeToleranceAfter: CMTime = .positiveInfinity
+    open var apertureMode: String?
+
+    public enum Result: Int, Sendable {
+        case succeeded, failed, cancelled
+    }
+
+    public init(asset: AVAsset) {
+        self.asset = asset
+    }
+
+    private var unsupported: AVError {
+        AVError(.operationNotSupportedForAsset, message: "the browser build cannot draw a video frame as an image")
+    }
+
+    open func copyCGImage(at requestedTime: CMTime, actualTime: UnsafeMutablePointer<CMTime>?) throws -> CGImage {
+        throw unsupported
+    }
+
+    open func image(at time: CMTime) async throws -> (image: CGImage, actualTime: CMTime) {
+        throw unsupported
+    }
+
+    open func generateCGImageAsynchronously(for requestedTime: CMTime,
+                                            completionHandler handler: @escaping @Sendable (CGImage?, CMTime, (any Error)?) -> Void) {
+        let error = unsupported
+        Task { handler(nil, .zero, error) }
+    }
+
+    open func generateCGImagesAsynchronously(forTimes requestedTimes: [NSValue],
+                                             completionHandler handler: @escaping @Sendable (CMTime, CGImage?, CMTime, Result, (any Error)?) -> Void) {
+        let error = unsupported
+        let count = requestedTimes.count
+        Task { for _ in 0..<count { handler(.zero, nil, .zero, .failed, error) } }
+    }
+
+    open func cancelAllCGImageGeneration() {}
+}
+
+public let AVAssetExportPresetPassthrough = "AVAssetExportPresetPassthrough"
+public let AVAssetExportPresetLowQuality = "AVAssetExportPresetLowQuality"
+public let AVAssetExportPresetMediumQuality = "AVAssetExportPresetMediumQuality"
+public let AVAssetExportPresetHighestQuality = "AVAssetExportPresetHighestQuality"
+public let AVAssetExportPresetHEVCHighestQuality = "AVAssetExportPresetHEVCHighestQuality"
+public let AVAssetExportPreset640x480 = "AVAssetExportPreset640x480"
+public let AVAssetExportPreset960x540 = "AVAssetExportPreset960x540"
+public let AVAssetExportPreset1280x720 = "AVAssetExportPreset1280x720"
+public let AVAssetExportPreset1920x1080 = "AVAssetExportPreset1920x1080"
+public let AVAssetExportPreset3840x2160 = "AVAssetExportPreset3840x2160"
+public let AVAssetExportPresetAppleM4A = "AVAssetExportPresetAppleM4A"
+
+/// Writes an asset to a file. The browser build has no encoder, so every
+/// preset exports as `AVAssetExportPresetPassthrough` does: the file is copied
+/// as it is (a file asset only; a remote one fails), and `outputFileType` is
+/// recorded, not converted to.
+open class AVAssetExportSession: @unchecked Sendable {
+    public enum Status: Int, Sendable {
+        case unknown, waiting, exporting, completed, failed, cancelled
+    }
+
+    public let asset: AVAsset
+    public let presetName: String
+    open var outputURL: URL?
+    open var outputFileType: AVFileType?
+    open var shouldOptimizeForNetworkUse = false
+    open var timeRange: CMTimeRange = CMTimeRange(start: .zero, duration: .positiveInfinity)
+    open var fileLengthLimit: Int64 = 0
+    open var metadata: [AVMetadataItem]?
+    open private(set) var status: Status = .unknown
+    open private(set) var error: (any Error)?
+    open private(set) var progress: Float = 0
+    open var supportedFileTypes: [AVFileType] { [.mp4, .mov, .m4v, .m4a] }
+
+    public init?(asset: AVAsset, presetName: String) {
+        self.asset = asset
+        self.presetName = presetName
+    }
+
+    public static func allExportPresets() -> [String] {
+        [AVAssetExportPresetPassthrough, AVAssetExportPresetLowQuality, AVAssetExportPresetMediumQuality,
+         AVAssetExportPresetHighestQuality, AVAssetExportPreset640x480, AVAssetExportPreset960x540,
+         AVAssetExportPreset1280x720, AVAssetExportPreset1920x1080]
+    }
+
+    /// Copies the asset's file to `url`.
+    public func export(to url: URL, as fileType: AVFileType) async throws {
+        outputURL = url
+        outputFileType = fileType
+        try performCopy()
+    }
+
+    open func exportAsynchronously(completionHandler handler: @escaping @Sendable () -> Void) {
+        Task {
+            try? self.performCopy()
+            handler()
+        }
+    }
+
+    open func cancelExport() {
+        if status != .completed { status = .cancelled }
+    }
+
+    private func performCopy() throws {
+        status = .exporting
+        do {
+            guard let destination = outputURL else { throw AVError(.exportFailed, message: "no outputURL") }
+            guard let source = asset._url, source.isFileURL else {
+                throw AVError(.operationNotSupportedForAsset, message: "only a file can be exported in the browser")
+            }
+            let data = try Data(contentsOf: source)
+            try data.write(to: destination)
+            progress = 1
+            status = .completed
+        } catch {
+            self.error = error
+            status = .failed
+            throw error
+        }
+    }
+}

package/Sources/AVFoundation/AudioSession.swift

@@ -0,0 +1,144 @@
+// `AVAudioSession`: how the app's audio mixes with other apps'. The browser
+// mixes a page's audio with everything else on its own terms, so the session
+// keeps the category, mode and options the app sets, every call succeeds,
+// and nothing changes in what plays. Recording is not available: the record
+// permission is denied.
+
+import Foundation
+
+public final class AVAudioSession: @unchecked Sendable {
+    private static let shared = AVAudioSession()
+
+    public static func sharedInstance() -> AVAudioSession { shared }
+
+    public struct Category: RawRepresentable, Hashable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let ambient = Category(rawValue: "AVAudioSessionCategoryAmbient")
+        public static let soloAmbient = Category(rawValue: "AVAudioSessionCategorySoloAmbient")
+        public static let playback = Category(rawValue: "AVAudioSessionCategoryPlayback")
+        public static let record = Category(rawValue: "AVAudioSessionCategoryRecord")
+        public static let playAndRecord = Category(rawValue: "AVAudioSessionCategoryPlayAndRecord")
+        public static let multiRoute = Category(rawValue: "AVAudioSessionCategoryMultiRoute")
+    }
+
+    public struct Mode: RawRepresentable, Hashable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let `default` = Mode(rawValue: "AVAudioSessionModeDefault")
+        public static let moviePlayback = Mode(rawValue: "AVAudioSessionModeMoviePlayback")
+        public static let spokenAudio = Mode(rawValue: "AVAudioSessionModeSpokenAudio")
+        public static let voiceChat = Mode(rawValue: "AVAudioSessionModeVoiceChat")
+        public static let videoChat = Mode(rawValue: "AVAudioSessionModeVideoChat")
+        public static let videoRecording = Mode(rawValue: "AVAudioSessionModeVideoRecording")
+        public static let measurement = Mode(rawValue: "AVAudioSessionModeMeasurement")
+        public static let gameChat = Mode(rawValue: "AVAudioSessionModeGameChat")
+    }
+
+    public enum RouteSharingPolicy: UInt, Sendable {
+        case `default` = 0, longFormAudio, independent, longFormVideo
+    }
+
+    public struct CategoryOptions: OptionSet, Hashable, Sendable {
+        public let rawValue: UInt
+        public init(rawValue: UInt) { self.rawValue = rawValue }
+        public static let mixWithOthers = CategoryOptions(rawValue: 0x1)
+        public static let duckOthers = CategoryOptions(rawValue: 0x2)
+        public static let allowBluetooth = CategoryOptions(rawValue: 0x4)
+        public static let defaultToSpeaker = CategoryOptions(rawValue: 0x8)
+        public static let interruptSpokenAudioAndMixWithOthers = CategoryOptions(rawValue: 0x11)
+        public static let allowBluetoothA2DP = CategoryOptions(rawValue: 0x20)
+        public static let allowAirPlay = CategoryOptions(rawValue: 0x40)
+        public static let overrideMutedMicrophoneInterruption = CategoryOptions(rawValue: 0x80)
+    }
+
+    public struct SetActiveOptions: OptionSet, Hashable, Sendable {
+        public let rawValue: UInt
+        public init(rawValue: UInt) { self.rawValue = rawValue }
+        public static let notifyOthersOnDeactivation = SetActiveOptions(rawValue: 1)
+    }
+
+    public enum RecordPermission: UInt, Sendable {
+        case undetermined = 1970168948, denied = 1684369017, granted = 1735552628
+    }
+
+    public enum InterruptionType: UInt, Sendable {
+        case began = 1, ended = 0
+    }
+
+    public struct InterruptionOptions: OptionSet, Sendable {
+        public let rawValue: UInt
+        public init(rawValue: UInt) { self.rawValue = rawValue }
+        public static let shouldResume = InterruptionOptions(rawValue: 1)
+    }
+
+    public enum RouteChangeReason: UInt, Sendable {
+        case unknown = 0, newDeviceAvailable, oldDeviceUnavailable, categoryChange, override,
+             wakeFromSleep = 6, noSuitableRouteForCategory, routeConfigurationChange
+    }
+
+    public private(set) var category: Category = .soloAmbient
+    public private(set) var mode: Mode = .default
+    public private(set) var categoryOptions: CategoryOptions = []
+    public private(set) var routeSharingPolicy: RouteSharingPolicy = .default
+    /// Whether the app made its session active (kept; nothing else changes).
+    public private(set) var _isActive = false
+
+    public var outputVolume: Float { 1 }
+    public var isOtherAudioPlaying: Bool { false }
+    public var secondaryAudioShouldBeSilencedHint: Bool { false }
+    public var sampleRate: Double { 48_000 }
+    public var outputLatency: TimeInterval { 0 }
+    public var ioBufferDuration: TimeInterval { 0.005 }
+    public var recordPermission: RecordPermission { .denied }
+    public var isInputAvailable: Bool { false }
+    public var availableCategories: [Category] { [.ambient, .soloAmbient, .playback, .record, .playAndRecord, .multiRoute] }
+
+    public func setCategory(_ category: Category) throws {
+        self.category = category
+    }
+
+    public func setCategory(_ category: Category, options: CategoryOptions) throws {
+        self.category = category
+        categoryOptions = options
+    }
+
+    public func setCategory(_ category: Category, mode: Mode, options: CategoryOptions) throws {
+        self.category = category
+        self.mode = mode
+        categoryOptions = options
+    }
+
+    public func setCategory(_ category: Category, mode: Mode, policy: RouteSharingPolicy, options: CategoryOptions) throws {
+        self.category = category
+        self.mode = mode
+        routeSharingPolicy = policy
+        categoryOptions = options
+    }
+
+    public func setMode(_ mode: Mode) throws {
+        self.mode = mode
+    }
+
+    public func setActive(_ active: Bool, options: SetActiveOptions = []) throws {
+        _isActive = active
+    }
+
+    public func setPreferredSampleRate(_ sampleRate: Double) throws {}
+    public func setPreferredIOBufferDuration(_ duration: TimeInterval) throws {}
+
+    /// Recording is not available in the browser build: the answer is no.
+    public func requestRecordPermission(_ response: @escaping @Sendable (Bool) -> Void) {
+        response(false)
+    }
+
+    public static let interruptionNotification = Notification.Name("AVAudioSessionInterruptionNotification")
+    public static let routeChangeNotification = Notification.Name("AVAudioSessionRouteChangeNotification")
+    public static let mediaServicesWereLostNotification = Notification.Name("AVAudioSessionMediaServicesWereLostNotification")
+    public static let mediaServicesWereResetNotification = Notification.Name("AVAudioSessionMediaServicesWereResetNotification")
+    public static let silenceSecondaryAudioHintNotification = Notification.Name("AVAudioSessionSilenceSecondaryAudioHintNotification")
+}
+
+public let AVAudioSessionInterruptionTypeKey = "AVAudioSessionInterruptionTypeKey"
+public let AVAudioSessionInterruptionOptionKey = "AVAudioSessionInterruptionOptionKey"
+public let AVAudioSessionRouteChangeReasonKey = "AVAudioSessionRouteChangeReasonKey"