@swiftbrowser/native 0.18.3 → 0.21.0

package/swift/Sources/SwiftBrowserNative/Host/AudioEngineNodes.swift

@@ -0,0 +1,70 @@
+#if canImport(SwiftUI) && !canImport(FoundationBridge)
+import AVFoundation
+import SwiftBrowserProtocol
+
+/// A node of a kind a package adds to the app's `AVAudioEngine`
+/// (AudioEngineBridge.swift): SwiftBrowserDSP's `program`, a synthesizer
+/// rendered on the audio thread. The bridge attaches `node`, gives it the
+/// values the app attaches it with and sets, and hands it the notes a
+/// sampler would take; volume and pan go to the node's `AVAudioMixing`
+/// first, as for the engine's own nodes. An app that adds no such package
+/// pays nothing for this hook.
+@MainActor
+public protocol AudioEngineCustomNode: AnyObject {
+    /// What the engine attaches and connects: a source takes no input.
+    var node: AVAudioNode { get }
+
+    /// A property, from `attach`'s values or a `set`: false for one it does
+    /// not have. Throws a `HostRequestFailure`-shaped error (`kind: detail`)
+    /// for a value it cannot take.
+    func set(_ key: String, _ value: JSONValue) throws -> Bool
+
+    /// `startNote`, `stopNote`, `controller` or `pitchBend`, with the
+    /// command's params (`note`, `velocity`, `controller`, `value`,
+    /// `channel`): false for a node that takes no notes.
+    func note(_ action: String, _ params: JSONObject) throws -> Bool
+
+    /// The engine stopped or reset, or the node was detached: stop sounding.
+    func halt()
+}
+
+public extension AudioEngineCustomNode {
+    func note(_ action: String, _ params: JSONObject) throws -> Bool { false }
+    func halt() {}
+}
+
+/// What a package's node is made with.
+public struct AudioEngineNodeContext {
+    /// The format to render in: stereo at the engine's output rate (or the
+    /// offline rendering's format), the one the engine's players send in.
+    public let format: AVAudioFormat
+}
+
+/// The node kinds packages add, by the name the app attaches them with
+/// (@swiftbrowser/web's `registerAudioNodeKind` is the page's side). Register
+/// at launch, before the bundle loads.
+@MainActor
+public enum AudioEngineNodes {
+    public typealias Make = @MainActor (AudioEngineNodeContext) throws -> any AudioEngineCustomNode
+
+    private static var kinds: [String: Make] = [:]
+
+    /// The engine's own kinds, which a package cannot replace.
+    private static let own: Set<String> = ["player", "sampler", "mixer", "reverb", "delay", "distortion", "eq", "timePitch"]
+
+    /// Adds `kind`, replacing one of the same name a package added before.
+    public static func register(_ kind: String, _ make: @escaping Make) {
+        precondition(!own.contains(kind), "\(kind) is one of the engine's own node kinds")
+        kinds[kind] = make
+    }
+
+    /// Whether a package added `kind`.
+    public static func isRegistered(_ kind: String) -> Bool {
+        kinds[kind] != nil
+    }
+
+    static func make(_ kind: String, _ context: AudioEngineNodeContext) throws -> (any AudioEngineCustomNode)? {
+        try kinds[kind].map { try $0(context) }
+    }
+}
+#endif

package/swift/Sources/SwiftBrowserNative/Host/BodyStream.swift

@@ -0,0 +1,166 @@
+#if canImport(SwiftUI)
+import Foundation
+
+/// A request body streamed from its parts: bytes the page sent beside the
+/// request, and ranges of files on disk (a picked file, a dropped one, one in
+/// the app's directories), read a piece at a time through a `FileHandle` as
+/// `URLSession` asks for them, so a body of gigabytes costs no memory. The
+/// files are those the app may read (`FilesBridge.readable`); a folder opened
+/// in place keeps its security scope for the read.
+enum BodyPart: Sendable {
+    case bytes(Data)
+    case file(URL, start: Int, end: Int)
+
+    var length: Int {
+        switch self {
+        case .bytes(let data): return data.count
+        case .file(_, let start, let end): return max(0, end - start)
+        }
+    }
+
+    /// `{ "$bytes": n }` (the nth view beside the request) or `{ url, start, end }` of a file the app may read.
+    init(part: JSONValue, bytes: [HostBytes]) throws {
+        if let index = part["$bytes"].int {
+            guard bytes.indices.contains(index) else { throw HostRequestFailure("unsupported: body part \(index) was not sent") }
+            self = .bytes(bytes[index].data)
+            return
+        }
+        guard let urlString = part["url"].string, let start = part["start"].int, let end = part["end"].int else {
+            throw HostRequestFailure("unsupported: a body part is neither bytes nor a file range")
+        }
+        #if !canImport(FoundationBridge)
+        guard let url = FilesBridge.readableURL(urlString) else { throw HostRequestFailure("unsupported: \(urlString) is not a file the app may read") }
+        self = .file(url, start: max(0, start), end: max(0, end))
+        #else
+        throw HostRequestFailure("unsupported: a body streamed from a file needs the native files bridge")
+        #endif
+    }
+}
+
+#if !canImport(FoundationBridge)
+/// An `InputStream` over the parts in order, for `URLRequest.httpBodyStream`.
+final class PartsInputStream: InputStream, @unchecked Sendable {
+    private let parts: [BodyPart]
+    private var index = 0
+    private var offset = 0
+    private var handle: FileHandle?
+    private var stopAccess: (() -> Void)?
+    private var status: Stream.Status = .notOpen
+    private var error: Error?
+    private weak var delegate_: StreamDelegate?
+
+    init(parts: [BodyPart]) {
+        self.parts = parts
+        super.init(data: Data())
+    }
+
+    override var streamStatus: Stream.Status { status }
+    override var streamError: Error? { error }
+    override var delegate: StreamDelegate? {
+        get { delegate_ }
+        set { delegate_ = newValue }
+    }
+    override var hasBytesAvailable: Bool { status == .open && index < parts.count }
+
+    override func open() {
+        status = .open
+    }
+
+    override func close() {
+        try? handle?.close()
+        handle = nil
+        stopAccess?()
+        stopAccess = nil
+        status = .closed
+    }
+
+    override func property(forKey key: Stream.PropertyKey) -> Any? { nil }
+    override func setProperty(_ property: Any?, forKey key: Stream.PropertyKey) -> Bool { false }
+    override func schedule(in aRunLoop: RunLoop, forMode mode: RunLoop.Mode) {}
+    override func remove(from aRunLoop: RunLoop, forMode mode: RunLoop.Mode) {}
+
+    /// Fills `buffer` from the current part, moving to the next as each ends; 0 at the end, -1 on a read error.
+    override func read(_ buffer: UnsafeMutablePointer<UInt8>, maxLength: Int) -> Int {
+        guard status == .open else { return -1 }
+        while index < parts.count {
+            let part = parts[index]
+            let remaining = part.length - offset
+            if remaining <= 0 {
+                advance()
+                continue
+            }
+            let count = min(maxLength, remaining)
+            switch part {
+            case .bytes(let data):
+                _ = data.copyBytes(to: buffer, from: offset..<(offset + count))
+                offset += count
+                return count
+            case .file(let url, let start, _):
+                do {
+                    let handle = try openHandle(url, at: start + offset)
+                    guard let data = try handle.read(upToCount: count), !data.isEmpty else {
+                        throw HostRequestFailure("unavailable: \(url.lastPathComponent) ended before its range")
+                    }
+                    _ = data.copyBytes(to: buffer, count: data.count)
+                    offset += data.count
+                    return data.count
+                } catch {
+                    self.error = error
+                    status = .error
+                    return -1
+                }
+            }
+        }
+        status = .atEnd
+        return 0
+    }
+
+    private func openHandle(_ url: URL, at position: Int) throws -> FileHandle {
+        if let handle { return handle }
+        #if !canImport(FoundationBridge)
+        stopAccess = PickedFiles.shared.beginAccessing(url)
+        #endif
+        let handle = try FileHandle(forReadingFrom: url)
+        try handle.seek(toOffset: UInt64(position))
+        self.handle = handle
+        return handle
+    }
+
+    private func advance() {
+        try? handle?.close()
+        handle = nil
+        stopAccess?()
+        stopAccess = nil
+        index += 1
+        offset = 0
+    }
+}
+
+/// The session delegate that makes a fresh stream of a task's parts when
+/// `URLSession` must send the body again (a redirect, an authentication
+/// challenge): a stream cannot be rewound, its parts can be read again.
+final class BodyStreams: NSObject, URLSessionTaskDelegate, @unchecked Sendable {
+    private let lock = NSLock()
+    private var parts: [Int: [BodyPart]] = [:]
+
+    func register(_ task: URLSessionTask, parts: [BodyPart]) {
+        lock.lock()
+        self.parts[task.taskIdentifier] = parts
+        lock.unlock()
+    }
+
+    func urlSession(_ session: URLSession, task: URLSessionTask, needNewBodyStream completionHandler: @escaping (InputStream?) -> Void) {
+        lock.lock()
+        let parts = parts[task.taskIdentifier]
+        lock.unlock()
+        completionHandler(parts.map { PartsInputStream(parts: $0) })
+    }
+
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        lock.lock()
+        parts[task.taskIdentifier] = nil
+        lock.unlock()
+    }
+}
+#endif
+#endif

package/swift/Sources/SwiftBrowserNative/Host/FilesBridge.swift

@@ -49,6 +49,14 @@ struct FilesBridge: Sendable {
         return roots
     }
 
+    /// Whether `url` is in one of the app's directories, or a file the viewer picked or dropped (PickedFiles),
+    /// which the app may read and copy in (`readRange`, `importItem`, `attributes`) but not write.
+    private func readable(_ url: URL) -> Bool {
+        let path = url.path
+        if roots.contains(where: { path == $0.path || path.hasPrefix($0.path + "/") }) { return true }
+        return PickedFiles.shared.contains(url)
+    }
+
     /// Runs `body` on `url` under file coordination when the URL is in the iCloud container, else as it is.
     private func coordinated<T>(_ url: URL, writing: NSFileCoordinator.WritingOptions?, _ body: (URL) throws -> T) throws -> T {
         guard ICloudContainer.shared.contains(url) else { return try body(url) }
@@ -84,20 +92,43 @@ struct FilesBridge: Sendable {
         throw HostRequestFailure("unavailable: \(url.absoluteString) did not download from iCloud Drive")
     }
 
-    /// The file URL `params[key]` names, under today's container, inside the app's directories.
-    private func url(_ params: JSONObject, _ key: String) throws -> URL {
+    /// The file URL `params[key]` names, under today's container, inside the app's directories (or, `reading`, a picked file's).
+    private func url(_ params: JSONObject, _ key: String, reading: Bool = false) throws -> URL {
         guard let string = params[key]?.string, let parsed = URL(string: string) else {
             throw HostRequestFailure("unsupported: files: \(key) is not a URL")
         }
         guard parsed.isFileURL else { throw HostRequestFailure("unsupported: \(string) is not a file URL") }
         let url = AppFiles.current(parsed).standardizedFileURL
         let path = url.path
-        guard roots.contains(where: { path == $0.path || path.hasPrefix($0.path + "/") }) else {
+        let inApp = roots.contains(where: { path == $0.path || path.hasPrefix($0.path + "/") })
+        guard inApp || (reading && readable(url)) else {
             throw HostRequestFailure("unsupported: \(string) is not in the app's directories")
         }
         return url
     }
 
+    /// The file URL `string` names when the app may read it (in its directories, or picked or dropped); nil otherwise. For a body streamed from disk (BodyStream.swift).
+    static func readableURL(_ string: String) -> URL? {
+        let bridge = FilesBridge()
+        guard let parsed = URL(string: string), parsed.isFileURL else { return nil }
+        let url = AppFiles.current(parsed).standardizedFileURL
+        return bridge.readable(url) ? url : nil
+    }
+
+    /// The file's bytes from `start` up to `end` (clamped), through a `FileHandle`, so a large file is read a piece at a time.
+    private func readRange(_ url: URL, start: Int, end: Int?) throws -> Data {
+        try coordinated(url, writing: nil) { target in
+            let handle = try FileHandle(forReadingFrom: target)
+            defer { try? handle.close() }
+            let size = try handle.seekToEnd()
+            let from = min(UInt64(max(0, start)), size)
+            let to = min(end.map { UInt64(max(0, $0)) } ?? size, size)
+            guard from < to else { return Data() }
+            try handle.seek(toOffset: from)
+            return try handle.read(upToCount: Int(to - from)) ?? Data()
+        }
+    }
+
     private func isDirectory(_ url: URL) -> Bool? {
         var directory: ObjCBool = false
         if manager.fileExists(atPath: url.path, isDirectory: &directory) { return directory.boolValue }
@@ -128,19 +159,51 @@ struct FilesBridge: Sendable {
             try await ensureDownloaded(url)
             return .object(["url": .string(url.absoluteString)])
         case "read":
-            let url = try url(params, "url")
+            let url = try url(params, "url", reading: true)
             switch isDirectory(url) {
             case nil: throw HostRequestFailure("notFound: no file at \(url.absoluteString)")
             case true?: throw HostRequestFailure("isDirectory: \(url.absoluteString) is a directory")
             case false?: break
             }
             try await ensureDownloaded(url)
-            let data = try coordinated(url, writing: nil) { try Data(contentsOf: $0) }
-            return .object(["data": .string(data.base64EncodedString())])
+            let data = try PickedFiles.shared.accessing(url) { try coordinated(url, writing: nil) { try Data(contentsOf: $0) } }
+            return .object(["data": RequestBytes.value(data)])
+        case "readRange":
+            // `fileManager.contents(url, { start, end })`: a piece of the file, `FileHandle`'s seek and read.
+            let url = try url(params, "url", reading: true)
+            switch isDirectory(url) {
+            case nil: throw HostRequestFailure("notFound: no file at \(url.absoluteString)")
+            case true?: throw HostRequestFailure("isDirectory: \(url.absoluteString) is a directory")
+            case false?: break
+            }
+            try await ensureDownloaded(url)
+            let start = params["start"]?.int ?? Int(params["start"]?.double ?? 0)
+            let end = params["end"]?.int ?? params["end"]?.double.map { Int($0) }
+            let data = try PickedFiles.shared.accessing(url) { try readRange(url, start: start, end: end) }
+            return .object(["data": RequestBytes.value(data)])
+        case "importItem":
+            // `fileManager.write(url, pickedFile)`: the picked file copied on disk into the app's directories, no bytes across the bridge.
+            let from = try url(params, "from", reading: true)
+            let to = try url(params, "to")
+            guard isDirectory(from) == false else { throw HostRequestFailure("notFound: no file at \(from.absoluteString)") }
+            if isDirectory(to) == true { throw HostRequestFailure("isDirectory: \(to.absoluteString) is a directory") }
+            try requireDirectory(to.deletingLastPathComponent(), for: to)
+            try await ensureDownloaded(from)
+            try PickedFiles.shared.accessing(from) {
+                try coordinated(to, writing: .forReplacing) { target in
+                    if manager.fileExists(atPath: target.path) { try manager.removeItem(at: target) }
+                    try manager.copyItem(at: from, to: target)
+                }
+            }
+            return .object([:])
+        case "release":
+            // The app is done with what it picked: the folder's security scope ends and the copies in tmp go.
+            PickedFiles.shared.release(params["urls"]?.array?.compactMap { $0.string.flatMap(URL.init(string:)) })
+            return .object([:])
         case "write":
             let url = try url(params, "url")
-            guard let data = Data(base64Encoded: params["data"]?.string ?? "") else {
-                throw HostRequestFailure("unsupported: files: data is not base64")
+            guard let data = RequestBytes.data(params["data"]) else {
+                throw HostRequestFailure("unsupported: files: data is neither bytes nor base64")
             }
             if isDirectory(url) == true { throw HostRequestFailure("isDirectory: \(url.absoluteString) is a directory") }
             try requireDirectory(url.deletingLastPathComponent(), for: url)
@@ -169,9 +232,9 @@ struct FilesBridge: Sendable {
             }).sorted { $0.localizedStandardCompare($1) == .orderedAscending }
             return .object(["urls": .array(names.map { .string(url.appendingPathComponent($0).absoluteString) })])
         case "attributes":
-            let url = try url(params, "url")
+            let url = try url(params, "url", reading: true)
             guard let directory = isDirectory(url) else { return .null }
-            let attributes = try manager.attributesOfItem(atPath: url.path)
+            let attributes = try PickedFiles.shared.accessing(url) { try manager.attributesOfItem(atPath: url.path) }
             let size = directory ? 0 : ((attributes[.size] as? NSNumber)?.doubleValue ?? 0)
             let modified = (attributes[.modificationDate] as? Date).map { JSONValue.number(($0.timeIntervalSince1970 * 1000).rounded()) } ?? .null
             let created = (attributes[.creationDate] as? Date).map { JSONValue.number(($0.timeIntervalSince1970 * 1000).rounded()) } ?? .null
@@ -203,6 +266,77 @@ struct FilesBridge: Sendable {
 
 #endif
 
+#if !canImport(FoundationBridge)
+/// The files and folders the viewer picked (`pickFiles`) or dropped: the page
+/// gets their URLs and sizes, not their bytes, and reads them through the
+/// files bridge (`readRange`, `importItem`) while they are registered here.
+/// A folder opened in place keeps its security scope until the app releases
+/// it (`files` `release`) or picks again; copies the pickers made in tmp are
+/// deleted then too.
+final class PickedFiles: @unchecked Sendable {
+    static let shared = PickedFiles()
+
+    private let lock = NSLock()
+    /// Files the app may read, by standardized path; the scoped folders they came from, if any.
+    private var files: [String: URL] = [:]
+    private var scopedFolders: [URL] = []
+    /// Folders in tmp the pickers copied into, removed on release.
+    private var temporaryFolders: [URL] = []
+
+    /// Registers files the app may read: `scoped` is a folder whose security scope is open (stopped on release).
+    func register(_ urls: [URL], scoped folder: URL? = nil, temporary: URL? = nil) {
+        lock.lock()
+        defer { lock.unlock() }
+        for url in urls { files[url.standardizedFileURL.path] = url }
+        if let folder { scopedFolders.append(folder) }
+        if let temporary { temporaryFolders.append(temporary) }
+    }
+
+    func contains(_ url: URL) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        let path = url.standardizedFileURL.path
+        if files[path] != nil { return true }
+        return scopedFolders.contains { path.hasPrefix($0.standardizedFileURL.path + "/") }
+    }
+
+    /// Runs `body` with the folder's security scope open where `url` is in a scoped folder.
+    func accessing<T>(_ url: URL, _ body: () throws -> T) rethrows -> T {
+        let stop = beginAccessing(url)
+        defer { stop?() }
+        return try body()
+    }
+
+    /// Opens the security scope of the folder `url` is in, if any, until the closure answered is called (a stream reading over time).
+    func beginAccessing(_ url: URL) -> (() -> Void)? {
+        lock.lock()
+        let path = url.standardizedFileURL.path
+        let folder = scopedFolders.first { path.hasPrefix($0.standardizedFileURL.path + "/") }
+        lock.unlock()
+        guard let folder, folder.startAccessingSecurityScopedResource() else { return nil }
+        return { folder.stopAccessingSecurityScopedResource() }
+    }
+
+    /// Forgets the given files (all of them when nil), ending scopes and deleting the pickers' copies no file still names.
+    func release(_ urls: [URL]?) {
+        lock.lock()
+        if let urls {
+            for url in urls { files[url.standardizedFileURL.path] = nil }
+        } else {
+            files.removeAll()
+        }
+        let stillNamed = Set(files.values.map { $0.standardizedFileURL.path })
+        let doneFolders = scopedFolders.filter { folder in !stillNamed.contains { $0.hasPrefix(folder.standardizedFileURL.path + "/") } }
+        scopedFolders.removeAll { doneFolders.contains($0) }
+        let doneTemporary = temporaryFolders.filter { folder in !stillNamed.contains { $0.hasPrefix(folder.standardizedFileURL.path + "/") } }
+        temporaryFolders.removeAll { doneTemporary.contains($0) }
+        lock.unlock()
+        for folder in doneFolders { folder.stopAccessingSecurityScopedResource() }
+        for folder in doneTemporary { try? FileManager.default.removeItem(at: folder) }
+    }
+}
+#endif
+
 /// Files the app keeps (a recording's, `fileManager`'s) are named by their
 /// URL, and iOS moves an app's container when it is installed again: a file
 /// URL into an old `Documents` that is not there anymore is the same path