@swiftbrowser/native 0.18.3 → 0.21.0

package/swift/Sources/SwiftBrowserNative/Host/JSHost.swift

@@ -28,6 +28,122 @@ public protocol JSHost: AnyObject {
 
     /// Throws the loaded scripts away: a fresh global object for the next `evaluate`.
     func reset()
+
+    /// Whether `installBytes` and `call(_:values:)` carry bytes as typed
+    /// arrays. An engine without it is given base64 in JSON instead
+    /// (docs/notes/bytes.md): the bridge installs `hostRequestBytes` only here.
+    var carriesBytes: Bool { get }
+
+    /// `install`, the arguments as `HostValue`s: a typed array or an
+    /// `ArrayBuffer` arrives as `.bytes`, copied out, anything else as
+    /// `.json`; a `.bytes` result goes back as a typed array of its kind.
+    func installBytes(_ name: String, _ body: @escaping ([HostValue]) -> HostValue?)
+
+    /// `call`, a `.bytes` argument made into a typed array of its kind.
+    @discardableResult
+    func call(_ function: String, values: [HostValue]) throws -> JSONValue
+}
+
+/// A JavaScript value at the engine boundary: JSON, or bytes crossing as a
+/// typed array (`Float32Array`, `Uint8Array`, …) or an `ArrayBuffer`.
+public enum HostValue: Sendable {
+    case json(JSONValue)
+    case bytes(HostBytes)
+}
+
+/// Bytes crossing the bridge, and the view they came from or go back as.
+public struct HostBytes: Sendable {
+    public var data: Data
+    public var kind: BytesKind
+    public init(_ data: Data, kind: BytesKind) {
+        self.data = data
+        self.kind = kind
+    }
+}
+
+/// The typed arrays JavaScript has, and a bare `ArrayBuffer`.
+public enum BytesKind: String, Sendable {
+    case int8, uint8, uint8Clamped, int16, uint16, int32, uint32, float32, float64, bigInt64, bigUint64, arrayBuffer
+}
+
+extension JSHost {
+    public var carriesBytes: Bool { false }
+
+    /// An engine without bytes: the arguments are JSON, as `install(_:_:)`
+    /// gives them, and a `.bytes` result goes back as base64.
+    public func installBytes(_ name: String, _ body: @escaping ([HostValue]) -> HostValue?) {
+        install(name, { (arguments: [JSONValue]) -> JSONValue? in
+            switch body(arguments.map(HostValue.json)) {
+            case .json(let json)?: return json
+            case .bytes(let bytes)?: return .string(bytes.data.base64EncodedString())
+            case nil: return nil
+            }
+        })
+    }
+
+    /// An engine without bytes: `.bytes` goes as base64, the form JavaScript
+    /// reads where a host has no `hostRequestBytes`.
+    @discardableResult
+    public func call(_ function: String, values: [HostValue]) throws -> JSONValue {
+        try call(function, values.map { value in
+            switch value {
+            case .json(let json): return json
+            case .bytes(let bytes): return .string(bytes.data.base64EncodedString())
+            }
+        })
+    }
+}
+
+/// The bytes a host request carries beside its JSON, and those its answer
+/// collects, for the request's task (`RequestBytes.$current`): a bridge reads
+/// a byte field with `data(_:)` and writes one with `value(_:)` without being
+/// handed either list. An app that sent no views (a host without
+/// `hostRequestBytes`, an older bundle) is answered in base64, as before.
+final class RequestBytes: @unchecked Sendable {
+    @TaskLocal static var current: RequestBytes?
+
+    let incoming: [HostBytes]
+    /// Whether the app reads an answer's bytes beside its JSON.
+    let answers: Bool
+    private let lock = NSLock()
+    private var collected: [HostBytes] = []
+
+    init(incoming: [HostBytes], answers: Bool) {
+        self.incoming = incoming
+        self.answers = answers
+    }
+
+    /// The bytes the answer collected, in the order its JSON names them.
+    var outgoing: [HostBytes] {
+        lock.lock()
+        defer { lock.unlock() }
+        return collected
+    }
+
+    /// A request field's bytes: a view sent beside it (`{ "$bytes": n }`), or base64.
+    static func data(_ value: JSONValue?) -> Data? {
+        value?.bytes(from: Self.current?.incoming ?? [])
+    }
+
+    /// Bytes for an answer's field: a view beside the JSON where the app reads them so, else base64.
+    static func value(_ data: Data) -> JSONValue {
+        guard let current = Self.current, current.answers else { return .string(data.base64EncodedString()) }
+        current.lock.lock()
+        defer { current.lock.unlock() }
+        current.collected.append(HostBytes(data, kind: .uint8))
+        return .object(["$bytes": .number(Double(current.collected.count - 1))])
+    }
+}
+
+extension JSONValue {
+    /// The bytes a request's field holds: `{ "$bytes": n }` names the nth
+    /// view sent beside the JSON (`hostRequestBytes`), and a string is base64,
+    /// the form a host without bytes is given.
+    public func bytes(from bytes: [HostBytes]) -> Data? {
+        if let index = self["$bytes"].int { return bytes.indices.contains(index) ? bytes[index].data : nil }
+        if let encoded = string { return Data(base64Encoded: encoded) }
+        return nil
+    }
 }
 
 public struct JSError: Error, CustomStringConvertible {

package/swift/Sources/SwiftBrowserNative/Host/JavaScriptCoreHost.swift

@@ -25,8 +25,22 @@ public final class JavaScriptCoreHost: JSHost {
         installExceptionHandler()
     }
 
+    /// JavaScriptCore keeps a process-wide registry of its virtual machines
+    /// under a lock of its own, and making one on a thread while another is
+    /// being made or dropped elsewhere has crashed in that lock (`VM::VM` →
+    /// `unlockSlow`, "Invalid value for lock", the iOS 26.2 simulator under
+    /// the test suites running in parallel, each with contexts and workers
+    /// of its own). So every virtual machine this package makes or drops is
+    /// made or dropped one at a time, under this lock: the app's context
+    /// here and each worker's (WorkerHost.swift).
+    nonisolated private static let virtualMachineLock = NSLock()
+
+    nonisolated static func withVirtualMachineLock<T>(_ body: () throws -> T) rethrows -> T {
+        try virtualMachineLock.withLock(body)
+    }
+
     private static func makeContext() -> (JSContext, JSValue) {
-        let context = JSContext()!
+        let context = withVirtualMachineLock { JSContext()! }
         context.name = "SwiftBrowser"
         let native = JSValue(newObjectIn: context)!
         context.setObject(native, forKeyedSubscript: "__sbNative" as NSString)
@@ -46,8 +60,10 @@ public final class JavaScriptCoreHost: JSHost {
 
     public func reset() {
         context.exceptionHandler = nil
-        (context, native) = JavaScriptCoreHost.makeContext()
         pendingError = nil
+        let fresh = JavaScriptCoreHost.makeContext()
+        // The old context (and its virtual machine) goes under the lock too.
+        JavaScriptCoreHost.withVirtualMachineLock { (context, native) = fresh }
         installExceptionHandler()
     }
 
@@ -84,6 +100,42 @@ public final class JavaScriptCoreHost: JSHost {
         return result.map(JavaScriptCoreHost.json(from:)) ?? .null
     }
 
+    public var carriesBytes: Bool { true }
+
+    public func installBytes(_ name: String, _ body: @escaping ([HostValue]) -> HostValue?) {
+        let block: @convention(block) () -> Any? = {
+            let arguments = (JSContext.currentArguments() as? [JSValue]) ?? []
+            switch body(arguments.map(JavaScriptCoreHost.hostValue(from:))) {
+            case .json(let json)?: return json.anyObject
+            case .bytes(let bytes)?:
+                guard let context = JSContext.current() else { return nil }
+                return JavaScriptCoreHost.typedArray(bytes, in: context)
+            case nil: return nil
+            }
+        }
+        native.setObject(unsafeBitCast(block, to: AnyObject.self), forKeyedSubscript: name as NSString)
+    }
+
+    @discardableResult
+    public func call(_ function: String, values: [HostValue]) throws -> JSONValue {
+        guard let callee = context.objectForKeyedSubscript(function), !callee.isUndefined else {
+            throw JSError(message: "\(function) is not defined")
+        }
+        pendingError = nil
+        let arguments: [Any] = values.map { value in
+            switch value {
+            case .json(let json): return json.anyObject
+            case .bytes(let bytes): return JavaScriptCoreHost.typedArray(bytes, in: context)
+            }
+        }
+        let result = callee.call(withArguments: arguments)
+        if let error = pendingError {
+            pendingError = nil
+            throw error
+        }
+        return result.map(JavaScriptCoreHost.json(from:)) ?? .null
+    }
+
     public func hasGlobal(_ name: String) -> Bool {
         guard let value = context.objectForKeyedSubscript(name) else { return false }
         return !value.isUndefined
@@ -99,5 +151,92 @@ public final class JavaScriptCoreHost: JSHost {
         if value.isNumber { return .number(value.toDouble()) }
         return JSONValue(any: value.toObject())
     }
+
+    // MARK: Bytes
+
+    /// A JavaScript value as a `HostValue`: a typed array's or an
+    /// `ArrayBuffer`'s bytes copied out (docs/notes/bytes.md), else JSON. The
+    /// typed-array check comes first: `toObject` would turn a view into a
+    /// dictionary of its indices, slowly. The pointer the engine gives is
+    /// read inside this call, while no JavaScript runs.
+    nonisolated static func hostValue(from value: JSValue) -> HostValue {
+        guard !value.isUndefined, !value.isNull, value.isObject, let context = value.context?.jsGlobalContextRef else { return .json(json(from: value)) }
+        var exception: JSValueRef?
+        let type = JSValueGetTypedArrayType(context, value.jsValueRef, &exception)
+        guard type != kJSTypedArrayTypeNone, let kind = bytesKind(type), let object = JSValueToObject(context, value.jsValueRef, &exception) else {
+            return .json(json(from: value))
+        }
+        if kind == .arrayBuffer {
+            let length = JSObjectGetArrayBufferByteLength(context, object, &exception)
+            guard length > 0, let pointer = JSObjectGetArrayBufferBytesPtr(context, object, &exception) else { return .bytes(HostBytes(Data(), kind: kind)) }
+            return .bytes(HostBytes(Data(bytes: pointer, count: length), kind: kind))
+        }
+        // The pointer is the backing buffer's start; the view begins at its offset.
+        let length = JSObjectGetTypedArrayByteLength(context, object, &exception)
+        let offset = JSObjectGetTypedArrayByteOffset(context, object, &exception)
+        guard length > 0, let pointer = JSObjectGetTypedArrayBytesPtr(context, object, &exception) else { return .bytes(HostBytes(Data(), kind: kind)) }
+        return .bytes(HostBytes(Data(bytes: pointer + offset, count: length), kind: kind))
+    }
+
+    /// A typed array (or `ArrayBuffer`) the engine allocates, the bytes copied in.
+    nonisolated static func typedArray(_ bytes: HostBytes, in context: JSContext) -> JSValue {
+        let global = context.jsGlobalContextRef
+        let size = elementSize(bytes.kind)
+        let count = bytes.data.count / size
+        var exception: JSValueRef?
+        let type = bytes.kind == .arrayBuffer ? kJSTypedArrayTypeUint8Array : typedArrayType(bytes.kind)
+        guard let array = JSObjectMakeTypedArray(global, type, count, &exception) else { return JSValue(nullIn: context) }
+        if count > 0, let pointer = JSObjectGetTypedArrayBytesPtr(global, array, &exception) {
+            bytes.data.copyBytes(to: pointer.assumingMemoryBound(to: UInt8.self), count: count * size)
+        }
+        if bytes.kind == .arrayBuffer, let buffer = JSObjectGetTypedArrayBuffer(global, array, &exception) {
+            return JSValue(jsValueRef: buffer, in: context)
+        }
+        return JSValue(jsValueRef: array, in: context)
+    }
+
+    private nonisolated static func elementSize(_ kind: BytesKind) -> Int {
+        switch kind {
+        case .int8, .uint8, .uint8Clamped, .arrayBuffer: return 1
+        case .int16, .uint16: return 2
+        case .int32, .uint32, .float32: return 4
+        case .float64, .bigInt64, .bigUint64: return 8
+        }
+    }
+
+    private nonisolated static func bytesKind(_ type: JSTypedArrayType) -> BytesKind? {
+        switch type {
+        case kJSTypedArrayTypeInt8Array: return .int8
+        case kJSTypedArrayTypeUint8Array: return .uint8
+        case kJSTypedArrayTypeUint8ClampedArray: return .uint8Clamped
+        case kJSTypedArrayTypeInt16Array: return .int16
+        case kJSTypedArrayTypeUint16Array: return .uint16
+        case kJSTypedArrayTypeInt32Array: return .int32
+        case kJSTypedArrayTypeUint32Array: return .uint32
+        case kJSTypedArrayTypeFloat32Array: return .float32
+        case kJSTypedArrayTypeFloat64Array: return .float64
+        case kJSTypedArrayTypeBigInt64Array: return .bigInt64
+        case kJSTypedArrayTypeBigUint64Array: return .bigUint64
+        case kJSTypedArrayTypeArrayBuffer: return .arrayBuffer
+        default: return nil
+        }
+    }
+
+    private nonisolated static func typedArrayType(_ kind: BytesKind) -> JSTypedArrayType {
+        switch kind {
+        case .int8: return kJSTypedArrayTypeInt8Array
+        case .uint8: return kJSTypedArrayTypeUint8Array
+        case .uint8Clamped: return kJSTypedArrayTypeUint8ClampedArray
+        case .int16: return kJSTypedArrayTypeInt16Array
+        case .uint16: return kJSTypedArrayTypeUint16Array
+        case .int32: return kJSTypedArrayTypeInt32Array
+        case .uint32: return kJSTypedArrayTypeUint32Array
+        case .float32: return kJSTypedArrayTypeFloat32Array
+        case .float64: return kJSTypedArrayTypeFloat64Array
+        case .bigInt64: return kJSTypedArrayTypeBigInt64Array
+        case .bigUint64: return kJSTypedArrayTypeBigUint64Array
+        case .arrayBuffer: return kJSTypedArrayTypeArrayBuffer
+        }
+    }
 }
 #endif