@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/AVFoundation/Capture.swift

@@ -0,0 +1,688 @@
+// Capture for the browser, as far as code scanners use it: a session with
+// the camera as its input, a metadata output that reports machine-readable
+// codes, a photo output, and a preview layer (docs/ops-protocol.md, "Code
+// scanning").
+//
+// The page owns the camera. `startRunning()` asks it to scan (a `scanner`
+// host request with the metadata output's `BarcodeDetector` formats): it
+// opens the camera over the page, or, where the browser cannot scan, asks the
+// viewer to type the code. The code it answers with reaches the metadata
+// output's delegate as an `AVMetadataMachineReadableCodeObject`, on the
+// delegate's queue, as a frame with a code does on iOS. One scan per request:
+// after a code, or when the viewer closes the camera, the session keeps
+// running and its preview layer offers to scan again.
+//
+// The photo output's photo is the camera frame the code was read in (a JPEG
+// the page sends with the code), or a one-pixel placeholder where there was
+// none (a typed code, a headless run). Devices are the page's two cameras,
+// back and front, each a wide-angle camera; their configuration (torch,
+// focus, exposure, zoom) is kept, and the torch is asked of the page when it
+// scans. Authorization is granted: the browser asks the viewer when the
+// camera opens.
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+import struct SwiftUI.CGFloat
+import struct SwiftUI.CGPoint
+import struct SwiftUI.CGRect
+import UIKit
+
+// MARK: - Devices
+
+public enum AVAuthorizationStatus: Int, Sendable {
+    case notDetermined = 0, restricted, denied, authorized
+}
+
+/// A camera: the page's back or front camera.
+open class AVCaptureDevice: @unchecked Sendable {
+    public struct DeviceType: RawRepresentable, Hashable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public init(_ rawValue: String) { self.rawValue = rawValue }
+        public static let builtInWideAngleCamera = DeviceType("AVCaptureDeviceTypeBuiltInWideAngleCamera")
+        public static let builtInUltraWideCamera = DeviceType("AVCaptureDeviceTypeBuiltInUltraWideCamera")
+        public static let builtInTelephotoCamera = DeviceType("AVCaptureDeviceTypeBuiltInTelephotoCamera")
+        public static let builtInDualCamera = DeviceType("AVCaptureDeviceTypeBuiltInDualCamera")
+        public static let builtInDualWideCamera = DeviceType("AVCaptureDeviceTypeBuiltInDualWideCamera")
+        public static let builtInTripleCamera = DeviceType("AVCaptureDeviceTypeBuiltInTripleCamera")
+        public static let builtInTrueDepthCamera = DeviceType("AVCaptureDeviceTypeBuiltInTrueDepthCamera")
+        public static let builtInLiDARDepthCamera = DeviceType("AVCaptureDeviceTypeBuiltInLiDARDepthCamera")
+        public static let builtInMicrophone = DeviceType("AVCaptureDeviceTypeBuiltInMicrophone")
+        public static let microphone = DeviceType("AVCaptureDeviceTypeMicrophone")
+        public static let external = DeviceType("AVCaptureDeviceTypeExternal")
+    }
+
+    public enum Position: Int, Sendable { case unspecified = 0, back, front }
+    public enum TorchMode: Int, Sendable { case off = 0, on, auto }
+    public enum FlashMode: Int, Sendable { case off = 0, on, auto }
+    public enum FocusMode: Int, Sendable { case locked = 0, autoFocus, continuousAutoFocus }
+    public enum ExposureMode: Int, Sendable { case locked = 0, autoExpose, continuousAutoExposure, custom }
+
+    /// A capture format: a 1920 × 1080 video stream with a 65° field of view.
+    open class Format: @unchecked Sendable {
+        public let formatDescription = CMFormatDescription(dimensions: CMVideoDimensions(width: 1920, height: 1080))
+        public let videoFieldOfView: Float = 65
+        public let videoMaxZoomFactor: CGFloat = 16
+        init() {}
+    }
+
+    public let deviceType: DeviceType
+    public let position: Position
+    public let uniqueID: String
+    public let localizedName: String
+    public let activeFormat = Format()
+    public var formats: [Format] { [activeFormat] }
+
+    /// Asked of the page when it scans (a camera track's torch, where it has one).
+    open var torchMode: TorchMode = .off
+    open var hasTorch: Bool { position == .back }
+    open var isTorchAvailable: Bool { hasTorch }
+    open var isTorchActive: Bool { torchMode == .on }
+    open var torchLevel: Float { torchMode == .on ? 1 : 0 }
+    open var hasFlash: Bool { false }
+    open var focusMode: FocusMode = .continuousAutoFocus
+    open var exposureMode: ExposureMode = .continuousAutoExposure
+    open var focusPointOfInterest = CGPoint(x: 0.5, y: 0.5)
+    open var exposurePointOfInterest = CGPoint(x: 0.5, y: 0.5)
+    /// The page does not focus on a point.
+    open var isFocusPointOfInterestSupported: Bool { false }
+    open var isExposurePointOfInterestSupported: Bool { false }
+    open var isSmoothAutoFocusSupported: Bool { false }
+    open var isSmoothAutoFocusEnabled = false
+    open var autoFocusRangeRestriction = 0
+    /// Not known: -1, as for a camera that does not report it.
+    open var minimumFocusDistance: Int { -1 }
+    open var videoZoomFactor: CGFloat = 1
+    open var minAvailableVideoZoomFactor: CGFloat { 1 }
+    open var maxAvailableVideoZoomFactor: CGFloat { activeFormat.videoMaxZoomFactor }
+    open var isConnected: Bool { true }
+
+
+    init(position: Position) {
+        deviceType = .builtInWideAngleCamera
+        self.position = position
+        uniqueID = position == .front ? "browser-camera-front" : "browser-camera-back"
+        localizedName = position == .front ? "Front Camera" : "Back Camera"
+    }
+
+    static let back = AVCaptureDevice(position: .back)
+    static let front = AVCaptureDevice(position: .front)
+
+    /// The back camera for video; nil for anything else.
+    open class func `default`(for mediaType: AVMediaType) -> AVCaptureDevice? {
+        mediaType == .video ? back : nil
+    }
+
+    open class func `default`(_ deviceType: DeviceType, for mediaType: AVMediaType?, position: Position) -> AVCaptureDevice? {
+        guard deviceType == .builtInWideAngleCamera, mediaType == nil || mediaType == .video else { return nil }
+        return position == .front ? front : back
+    }
+
+    open class func authorizationStatus(for mediaType: AVMediaType) -> AVAuthorizationStatus { .authorized }
+
+    /// Granted (the browser asks when the camera opens), on the main queue.
+    /// The handler is not `@Sendable`, as Objective-C's block is not.
+    open class func requestAccess(for mediaType: AVMediaType, completionHandler handler: @escaping (Bool) -> Void) {
+        nonisolated(unsafe) let handler = handler
+        FoundationBridge.DispatchQueue.main.async { handler(true) }
+    }
+
+    @available(*, deprecated, message: "Use AVCaptureDevice.DiscoverySession")
+    open class func devices(for mediaType: AVMediaType) -> [AVCaptureDevice] {
+        mediaType == .video ? [back, front] : []
+    }
+
+    /// The cameras of the given types, media type and position.
+    open class DiscoverySession: @unchecked Sendable {
+        public let devices: [AVCaptureDevice]
+
+        public init(deviceTypes: [DeviceType], mediaType: AVMediaType?, position: Position) {
+            guard deviceTypes.contains(.builtInWideAngleCamera), mediaType == nil || mediaType == .video else {
+                devices = []
+                return
+            }
+            switch position {
+            case .back: devices = [AVCaptureDevice.back]
+            case .front: devices = [AVCaptureDevice.front]
+            case .unspecified: devices = [AVCaptureDevice.back, AVCaptureDevice.front]
+            }
+        }
+    }
+
+    open func hasMediaType(_ mediaType: AVMediaType) -> Bool { mediaType == .video }
+    open func lockForConfiguration() throws {}
+    open func unlockForConfiguration() {}
+    open func isTorchModeSupported(_ torchMode: TorchMode) -> Bool { hasTorch }
+    open func setTorchModeOn(level torchLevel: Float) throws { torchMode = .on }
+    open func isFocusModeSupported(_ focusMode: FocusMode) -> Bool { true }
+    open func isExposureModeSupported(_ exposureMode: ExposureMode) -> Bool { true }
+    open func ramp(toVideoZoomFactor factor: CGFloat, withRate rate: Float) { videoZoomFactor = factor }
+    open func cancelVideoZoomRamp() {}
+}
+
+// MARK: - Core Media's format descriptions
+
+/// The pixel size of a video format.
+public struct CMVideoDimensions: Hashable, Sendable {
+    public var width: Int32
+    public var height: Int32
+    public init(width: Int32, height: Int32) {
+        self.width = width
+        self.height = height
+    }
+}
+
+/// A media format's description: here, a video stream's size.
+public final class CMFormatDescription: @unchecked Sendable {
+    let dimensions: CMVideoDimensions
+    init(dimensions: CMVideoDimensions) { self.dimensions = dimensions }
+}
+
+public typealias CMVideoFormatDescription = CMFormatDescription
+
+public func CMVideoFormatDescriptionGetDimensions(_ videoDesc: CMFormatDescription) -> CMVideoDimensions { videoDesc.dimensions }
+
+// MARK: - Inputs, outputs and connections
+
+open class AVCaptureInput: @unchecked Sendable {
+    init() {}
+}
+
+/// A camera as a session's input.
+open class AVCaptureDeviceInput: AVCaptureInput, @unchecked Sendable {
+    public let device: AVCaptureDevice
+
+    public init(device: AVCaptureDevice) throws {
+        self.device = device
+        super.init()
+    }
+}
+
+public enum AVCaptureVideoOrientation: Int, Sendable {
+    case portrait = 1, portraitUpsideDown, landscapeRight, landscapeLeft
+}
+
+/// What links a session's input to one of its outputs (or a preview layer).
+open class AVCaptureConnection: @unchecked Sendable {
+    public private(set) weak var output: AVCaptureOutput?
+    open var isEnabled = true
+    open var isActive: Bool { true }
+    open var isVideoOrientationSupported: Bool { true }
+    open var videoOrientation: AVCaptureVideoOrientation = .portrait
+    open var videoRotationAngle: CGFloat = 90
+    open var isVideoMirroringSupported: Bool { true }
+    open var isVideoMirrored = false
+    open var automaticallyAdjustsVideoMirroring = true
+
+    init(output: AVCaptureOutput?) { self.output = output }
+
+    open func isVideoRotationAngleSupported(_ videoRotationAngle: CGFloat) -> Bool { true }
+}
+
+open class AVCaptureOutput: @unchecked Sendable {
+    public internal(set) var connections: [AVCaptureConnection] = []
+    weak var session: AVCaptureSession?
+
+    init() {}
+
+    open func connection(with mediaType: AVMediaType) -> AVCaptureConnection? {
+        mediaType == .video ? connections.first : nil
+    }
+}
+
+// MARK: - Metadata
+
+/// Something a capture found in a frame; codes are `AVMetadataMachineReadableCodeObject`s.
+open class AVMetadataObject: @unchecked Sendable {
+    /// The kinds of machine-readable code (Apple's raw values).
+    public struct ObjectType: RawRepresentable, Hashable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public init(_ rawValue: String) { self.rawValue = rawValue }
+
+        public static let qr = ObjectType(rawValue: "org.iso.QRCode")
+        public static let aztec = ObjectType(rawValue: "org.iso.Aztec")
+        public static let dataMatrix = ObjectType(rawValue: "org.iso.DataMatrix")
+        public static let pdf417 = ObjectType(rawValue: "org.iso.PDF417")
+        public static let microQR = ObjectType(rawValue: "org.iso.MicroQR")
+        public static let microPDF417 = ObjectType(rawValue: "org.iso.MicroPDF417")
+        public static let code39 = ObjectType(rawValue: "org.iso.Code39")
+        public static let code39Mod43 = ObjectType(rawValue: "org.iso.Code39Mod43")
+        public static let code93 = ObjectType(rawValue: "com.intermec.Code93")
+        public static let code128 = ObjectType(rawValue: "org.iso.Code128")
+        public static let ean8 = ObjectType(rawValue: "org.gs1.EAN-8")
+        public static let ean13 = ObjectType(rawValue: "org.gs1.EAN-13")
+        public static let upce = ObjectType(rawValue: "org.gs1.UPC-E")
+        public static let interleaved2of5 = ObjectType(rawValue: "org.ansi.Interleaved2of5")
+        public static let itf14 = ObjectType(rawValue: "org.gs1.ITF14")
+        public static let codabar = ObjectType(rawValue: "org.codabar")
+        public static let gs1DataBar = ObjectType(rawValue: "org.gs1.GS1DataBar")
+        public static let gs1DataBarExpanded = ObjectType(rawValue: "org.gs1.GS1DataBarExpanded")
+        public static let gs1DataBarLimited = ObjectType(rawValue: "org.gs1.GS1DataBarLimited")
+        public static let face = ObjectType(rawValue: "face")
+        public static let humanBody = ObjectType(rawValue: "mdta/com.apple.quicktime.detected-human-body")
+
+        /// Every code type the page's `BarcodeDetector` can look for.
+        static let codes: [ObjectType] = [.qr, .microQR, .aztec, .dataMatrix, .pdf417, .microPDF417, .code39, .code39Mod43,
+                                          .code93, .code128, .ean8, .ean13, .upce, .interleaved2of5, .itf14, .codabar]
+
+        /// The `BarcodeDetector` format that finds this kind of code, if any.
+        public var _barcodeFormat: String? {
+            switch self {
+            case .qr, .microQR: "qr_code"
+            case .aztec: "aztec"
+            case .dataMatrix: "data_matrix"
+            case .pdf417, .microPDF417: "pdf417"
+            case .code39, .code39Mod43: "code_39"
+            case .code93: "code_93"
+            case .code128: "code_128"
+            case .ean8: "ean_8"
+            case .ean13: "ean_13"
+            case .upce: "upc_e"
+            case .interleaved2of5, .itf14: "itf"
+            case .codabar: "codabar"
+            default: nil
+            }
+        }
+    }
+
+    public let type: ObjectType
+    public let bounds: CGRect
+    public let time: CMTime
+    public let duration: CMTime
+
+    init(type: ObjectType, bounds: CGRect) {
+        self.type = type
+        self.bounds = bounds
+        time = .zero
+        duration = .zero
+    }
+}
+
+/// A code read in a frame: its contents and corners.
+open class AVMetadataMachineReadableCodeObject: AVMetadataObject, @unchecked Sendable {
+    public let stringValue: String?
+    /// The code's corners, in the frame's pixels as the page reports them.
+    public let corners: [CGPoint]
+
+    public init(type: ObjectType, stringValue: String?, corners: [CGPoint]) {
+        self.stringValue = stringValue
+        self.corners = corners
+        let xs = corners.map(\.x), ys = corners.map(\.y)
+        let bounds = corners.isEmpty ? CGRect.zero
+            : CGRect(x: xs.min()!, y: ys.min()!, width: xs.max()! - xs.min()!, height: ys.max()! - ys.min()!)
+        super.init(type: type, bounds: bounds)
+    }
+}
+
+/// Main-actor isolated: the page has one thread, and a view controller (as
+/// CodeScanner's is) conforms in Swift 6 as it may to Objective-C's protocol.
+@MainActor
+public protocol AVCaptureMetadataOutputObjectsDelegate: AnyObject {
+    func metadataOutput(_ output: AVCaptureMetadataOutput, didOutput metadataObjects: [AVMetadataObject], from connection: AVCaptureConnection)
+}
+
+extension AVCaptureMetadataOutputObjectsDelegate {
+    public func metadataOutput(_ output: AVCaptureMetadataOutput, didOutput metadataObjects: [AVMetadataObject], from connection: AVCaptureConnection) {}
+}
+
+/// Reports the codes the page reads to its delegate.
+open class AVCaptureMetadataOutput: AVCaptureOutput, @unchecked Sendable {
+    public private(set) weak var metadataObjectsDelegate: (any AVCaptureMetadataOutputObjectsDelegate)?
+    public private(set) var metadataObjectsCallbackQueue: FoundationBridge.DispatchQueue?
+    /// The kinds of code to look for; only kinds the page can read are available.
+    open var metadataObjectTypes: [AVMetadataObject.ObjectType]! = []
+    open var availableMetadataObjectTypes: [AVMetadataObject.ObjectType] { session == nil ? [] : AVMetadataObject.ObjectType.codes }
+    open var rectOfInterest = CGRect(x: 0, y: 0, width: 1, height: 1)
+
+    public override init() { super.init() }
+
+    open func setMetadataObjectsDelegate(_ objectsDelegate: (any AVCaptureMetadataOutputObjectsDelegate)?, queue objectsCallbackQueue: FoundationBridge.DispatchQueue?) {
+        metadataObjectsDelegate = objectsDelegate
+        metadataObjectsCallbackQueue = objectsCallbackQueue
+        session?.outputChanged()
+    }
+
+    /// The page's formats for the requested kinds of code.
+    var barcodeFormats: [String] {
+        var formats: [String] = []
+        for type in metadataObjectTypes ?? [] {
+            if let format = type._barcodeFormat, !formats.contains(format) { formats.append(format) }
+        }
+        return formats
+    }
+
+    /// The kind of code `format` is among the requested ones (UPC-A, which
+    /// `BarcodeDetector` reports on its own, is EAN-13 to AVFoundation).
+    func objectType(forFormat format: String?) -> AVMetadataObject.ObjectType {
+        let types = metadataObjectTypes ?? []
+        let wanted = format == "upc_a" ? "ean_13" : format
+        return types.first { $0._barcodeFormat == wanted } ?? types.first ?? .qr
+    }
+
+    func deliver(_ object: AVMetadataObject) {
+        guard let delegate = metadataObjectsDelegate, let connection = connections.first else { return }
+        nonisolated(unsafe) let held = (delegate, object, connection)
+        let send: @Sendable () -> Void = { MainActor.assumeIsolated { held.0.metadataOutput(self, didOutput: [held.1], from: held.2) } }
+        if let queue = metadataObjectsCallbackQueue { queue.async(execute: send) } else { send() }
+    }
+}
+
+// MARK: - Photos
+
+open class AVCapturePhotoSettings: @unchecked Sendable {
+    public let uniqueID: Int64
+    open var flashMode: AVCaptureDevice.FlashMode = .off
+    open var isHighResolutionPhotoEnabled = false
+    nonisolated(unsafe) private static var serial: Int64 = 0
+
+    public init() {
+        Self.serial += 1
+        uniqueID = Self.serial
+    }
+
+    public convenience init(from photoSettings: AVCapturePhotoSettings) {
+        self.init()
+        flashMode = photoSettings.flashMode
+    }
+}
+
+open class AVCaptureResolvedPhotoSettings: @unchecked Sendable {
+    public let uniqueID: Int64
+    init(uniqueID: Int64) { self.uniqueID = uniqueID }
+}
+
+/// A captured photo: the frame the last code was read in.
+open class AVCapturePhoto: @unchecked Sendable {
+    let data: Data
+    public let resolvedSettings: AVCaptureResolvedPhotoSettings
+    public let timestamp = CMTime.zero
+    public var isRawPhoto: Bool { false }
+
+    init(data: Data, resolvedSettings: AVCaptureResolvedPhotoSettings) {
+        self.data = data
+        self.resolvedSettings = resolvedSettings
+    }
+
+    open func fileDataRepresentation() -> Data? { data }
+    open func cgImageRepresentation() -> CGImage? { UIImage(data: data)?.cgImage }
+}
+
+/// Main-actor isolated, as `AVCaptureMetadataOutputObjectsDelegate` is.
+@MainActor
+public protocol AVCapturePhotoCaptureDelegate: AnyObject {
+    func photoOutput(_ output: AVCapturePhotoOutput, willBeginCaptureFor resolvedSettings: AVCaptureResolvedPhotoSettings)
+    func photoOutput(_ output: AVCapturePhotoOutput, willCapturePhotoFor resolvedSettings: AVCaptureResolvedPhotoSettings)
+    func photoOutput(_ output: AVCapturePhotoOutput, didCapturePhotoFor resolvedSettings: AVCaptureResolvedPhotoSettings)
+    func photoOutput(_ output: AVCapturePhotoOutput, didFinishProcessingPhoto photo: AVCapturePhoto, error: (any Error)?)
+    func photoOutput(_ output: AVCapturePhotoOutput, didFinishCaptureFor resolvedSettings: AVCaptureResolvedPhotoSettings, error: (any Error)?)
+}
+
+extension AVCapturePhotoCaptureDelegate {
+    public func photoOutput(_ output: AVCapturePhotoOutput, willBeginCaptureFor resolvedSettings: AVCaptureResolvedPhotoSettings) {}
+    public func photoOutput(_ output: AVCapturePhotoOutput, willCapturePhotoFor resolvedSettings: AVCaptureResolvedPhotoSettings) {}
+    public func photoOutput(_ output: AVCapturePhotoOutput, didCapturePhotoFor resolvedSettings: AVCaptureResolvedPhotoSettings) {}
+    public func photoOutput(_ output: AVCapturePhotoOutput, didFinishProcessingPhoto photo: AVCapturePhoto, error: (any Error)?) {}
+    public func photoOutput(_ output: AVCapturePhotoOutput, didFinishCaptureFor resolvedSettings: AVCaptureResolvedPhotoSettings, error: (any Error)?) {}
+}
+
+/// Takes a photo: the camera frame of the last code the session read, on the main queue.
+open class AVCapturePhotoOutput: AVCaptureOutput, @unchecked Sendable {
+    open var isHighResolutionCaptureEnabled = false
+    open var maxPhotoQualityPrioritization = 0
+    open var supportedFlashModes: [AVCaptureDevice.FlashMode] { [.off] }
+
+    public override init() { super.init() }
+
+    open func capturePhoto(with settings: AVCapturePhotoSettings, delegate: any AVCapturePhotoCaptureDelegate) {
+        let resolved = AVCaptureResolvedPhotoSettings(uniqueID: settings.uniqueID)
+        let photo = AVCapturePhoto(data: session?.lastFrame ?? _placeholderPhoto, resolvedSettings: resolved)
+        nonisolated(unsafe) let held = delegate
+        FoundationBridge.DispatchQueue.main.async {
+            MainActor.assumeIsolated {
+                held.photoOutput(self, willBeginCaptureFor: resolved)
+                held.photoOutput(self, willCapturePhotoFor: resolved)
+                held.photoOutput(self, didCapturePhotoFor: resolved)
+                held.photoOutput(self, didFinishProcessingPhoto: photo, error: nil)
+                held.photoOutput(self, didFinishCaptureFor: resolved, error: nil)
+            }
+        }
+    }
+}
+
+/// A one-pixel white PNG: the photo when no frame came with the code.
+let _placeholderPhoto = Data(base64Encoded: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4nGP4//8/AAX+Av4N70a4AAAAAElFTkSuQmCC")!
+
+// MARK: - Sessions
+
+/// A capture session: while it runs, the page scans for its metadata output.
+open class AVCaptureSession: @unchecked Sendable {
+    public struct Preset: RawRepresentable, Hashable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let high = Preset(rawValue: "AVCaptureSessionPresetHigh")
+        public static let medium = Preset(rawValue: "AVCaptureSessionPresetMedium")
+        public static let low = Preset(rawValue: "AVCaptureSessionPresetLow")
+        public static let photo = Preset(rawValue: "AVCaptureSessionPresetPhoto")
+        public static let hd1280x720 = Preset(rawValue: "AVCaptureSessionPreset1280x720")
+        public static let hd1920x1080 = Preset(rawValue: "AVCaptureSessionPreset1920x1080")
+        public static let vga640x480 = Preset(rawValue: "AVCaptureSessionPreset640x480")
+    }
+
+    /// Where the session is with the page's scanner, drawn by its preview layers.
+    public enum _ScanState: Equatable, Sendable {
+        /// Not running, or waiting to be asked to scan again.
+        case idle
+        /// The page is scanning (its camera or a typed code is up).
+        case scanning
+        /// The last scan delivered a code.
+        case found
+        /// The page could not scan; the message says why.
+        case failed(String)
+    }
+
+    open var sessionPreset: Preset = .high
+    public private(set) var inputs: [AVCaptureInput] = []
+    public private(set) var outputs: [AVCaptureOutput] = []
+    public private(set) var isRunning = false
+    public private(set) var _scanState: _ScanState = .idle { didSet { if _scanState != oldValue { notifyPreviews() } } }
+    /// The camera frame of the last code the page read (a JPEG), for photo outputs.
+    var lastFrame: Data?
+    private var previews: [WeakPreview] = []
+
+    public init() {}
+
+    open var connections: [AVCaptureConnection] { outputs.flatMap(\.connections) }
+
+    open func canAddInput(_ input: AVCaptureInput) -> Bool { !inputs.contains { $0 === input } }
+    open func addInput(_ input: AVCaptureInput) { if canAddInput(input) { inputs.append(input) } }
+    open func removeInput(_ input: AVCaptureInput) { inputs.removeAll { $0 === input } }
+
+    open func canAddOutput(_ output: AVCaptureOutput) -> Bool { !outputs.contains { $0 === output } && output.session == nil }
+
+    open func addOutput(_ output: AVCaptureOutput) {
+        guard canAddOutput(output) else { return }
+        outputs.append(output)
+        output.session = self
+        output.connections = [AVCaptureConnection(output: output)]
+        outputChanged()
+    }
+
+    open func removeOutput(_ output: AVCaptureOutput) {
+        outputs.removeAll { $0 === output }
+        output.session = nil
+        output.connections = []
+    }
+
+    open func beginConfiguration() {}
+    open func commitConfiguration() {}
+
+    /// Starts the session; the page is asked to scan for the metadata output.
+    open func startRunning() {
+        guard !isRunning else { return }
+        isRunning = true
+        _scanState = .idle
+        _scan()
+    }
+
+    /// Stops the session. A scan the page has open finishes; its code is dropped.
+    open func stopRunning() {
+        guard isRunning else { return }
+        isRunning = false
+        if _scanState != .scanning { _scanState = .idle }
+    }
+
+    /// A metadata output that wants codes, if the session has a camera.
+    private var scanningOutput: AVCaptureMetadataOutput? {
+        guard inputs.contains(where: { $0 is AVCaptureDeviceInput }) else { return nil }
+        return outputs.lazy.compactMap { $0 as? AVCaptureMetadataOutput }.first {
+            $0.metadataObjectsDelegate != nil && !$0.barcodeFormats.isEmpty
+        }
+    }
+
+    private var camera: AVCaptureDevice? {
+        inputs.lazy.compactMap { ($0 as? AVCaptureDeviceInput)?.device }.first
+    }
+
+    /// Asks the page for a code (see the top of the file); the preview
+    /// layer's button calls it again after a scan.
+    public func _scan() {
+        guard isRunning, _scanState != .scanning, let output = scanningOutput else { return }
+        _scanState = .scanning
+        let params: _JSON = .object([
+            "action": .string("scan"),
+            "formats": .array(output.barcodeFormats.map { .string($0) }),
+            "torch": .bool(camera?.torchMode == .on),
+            "vibrate": .bool(false),
+            "facing": .string(camera?.position == .front ? "user" : "environment"),
+        ])
+        Task { @MainActor in
+            do {
+                let answer = try await _CaptureHost.request(params)
+                self.finishScan(answer, output: output)
+            } catch {
+                let message = (error as? _HostRequestError)?.message ?? String(describing: error)
+                self._scanState = self.isRunning ? .failed(message) : .idle
+            }
+        }
+    }
+
+    private func finishScan(_ answer: _JSON, output: AVCaptureMetadataOutput) {
+        guard isRunning, case .object(let fields) = answer, case .string(let string)? = fields["string"] else {
+            _scanState = .idle
+            return
+        }
+        var format: String?
+        if case .string(let value)? = fields["format"] { format = value }
+        var corners: [CGPoint] = []
+        if case .array(let points)? = fields["corners"] {
+            for point in points {
+                if case .object(let xy) = point, case .number(let x)? = xy["x"], case .number(let y)? = xy["y"] {
+                    corners.append(CGPoint(x: x, y: y))
+                }
+            }
+        }
+        lastFrame = nil
+        if case .string(let image)? = fields["image"] { lastFrame = Data(base64Encoded: image) }
+        _scanState = .found
+        output.deliver(AVMetadataMachineReadableCodeObject(type: output.objectType(forFormat: format), stringValue: string, corners: corners))
+    }
+
+    func outputChanged() {
+        // A delegate set after `startRunning()` (from another queue on iOS) starts the scan.
+        if isRunning, _scanState == .idle { _scan() }
+    }
+
+    fileprivate func register(_ preview: AVCaptureVideoPreviewLayer) {
+        previews.removeAll { $0.layer == nil || $0.layer === preview }
+        previews.append(WeakPreview(layer: preview))
+    }
+
+    private func notifyPreviews() {
+        for preview in previews { preview.layer?._changed() }
+    }
+
+    private struct WeakPreview {
+        weak var layer: AVCaptureVideoPreviewLayer?
+    }
+}
+
+/// Sends a `scanner` host request; tests substitute it.
+@MainActor public enum _CaptureHost {
+    public static var request: (_ params: _JSON) async throws -> _JSON = { params in
+        try await _Runtime.shared._hostRequest(kind: "scanner", params: params)
+    }
+}
+
+// MARK: - Preview
+
+/// Shows a session: the page's camera is over the page while it scans, so
+/// the layer draws what to do next, filling its view (a button to scan again
+/// after a code, or after the viewer closed the camera).
+open class AVCaptureVideoPreviewLayer: CALayer, @unchecked Sendable {
+    open var session: AVCaptureSession? { didSet { if let session { session.register(self) }; _changed() } }
+    open var videoGravity: AVLayerVideoGravity = .resizeAspect
+    public private(set) lazy var connection: AVCaptureConnection? = AVCaptureConnection(output: nil)
+
+    public required init() { super.init() }
+
+    public init(session: AVCaptureSession) {
+        super.init()
+        self.session = session
+        session.register(self)
+    }
+
+    public init(sessionWithNoConnection session: AVCaptureSession) {
+        super.init()
+        self.session = session
+        session.register(self)
+    }
+
+    open func setSessionWithNoConnection(_ session: AVCaptureSession) { self.session = session }
+
+    /// Layer and capture coordinates are the same here (the page has the frames).
+    open func captureDevicePointConverted(fromLayerPoint pointInLayer: CGPoint) -> CGPoint { pointInLayer }
+    open func layerPointConverted(fromCaptureDevicePoint captureDevicePointOfInterest: CGPoint) -> CGPoint { captureDevicePointOfInterest }
+    open func metadataOutputRectConverted(fromLayerRect rectInLayerCoordinates: CGRect) -> CGRect { rectInLayerCoordinates }
+    open func layerRectConverted(fromMetadataOutputRect rectInMetadataOutputCoordinates: CGRect) -> CGRect { rectInMetadataOutputCoordinates }
+    open func transformedMetadataObject(for metadataObject: AVMetadataObject) -> AVMetadataObject? { metadataObject }
+
+    open override var _drawing: AnyView? {
+        guard let session else { return nil }
+        return AnyView(_CapturePreview(state: session.isRunning ? session._scanState : .idle, running: session.isRunning) { [weak session] in
+            session?._scan()
+        })
+    }
+}
+
+/// What a preview layer draws: black, as a camera preview starts, and what to do next.
+struct _CapturePreview: View {
+    let state: AVCaptureSession._ScanState
+    let running: Bool
+    let scan: @MainActor @Sendable () -> Void
+
+    var body: some View {
+        ZStack {
+            Color.black
+            VStack(spacing: 16) {
+                switch state {
+                case .scanning:
+                    ProgressView().tint(.white)
+                    Text("Scanning…").foregroundColor(.white)
+                case .failed(let message):
+                    Image(systemName: "camera.badge.ellipsis").font(.largeTitle).foregroundColor(.white)
+                    Text(message).font(.footnote).foregroundColor(.white).multilineTextAlignment(.center)
+                    Button("Try Again", systemImage: "arrow.clockwise", action: scan).buttonStyle(.borderedProminent)
+                case .idle, .found:
+                    if running {
+                        Image(systemName: "qrcode.viewfinder").font(.system(size: 64)).foregroundColor(.white)
+                        Button(state == .found ? "Scan Again" : "Scan a Code", systemImage: "camera", action: scan)
+                            .buttonStyle(.borderedProminent)
+                    }
+                }
+            }
+            .padding(24)
+        }
+    }
+}