expo-modules-jsi 56.0.7 → 56.0.8

package/apple/Sources/ExpoModulesJSI/Runtime/JavaScriptRuntime.swift

@@ -1,79 +1,66 @@
 // Copyright 2025-present 650 Industries. All rights reserved.
 
+internal import ExpoModulesJSI_Cxx
 import Foundation
-
 internal import jsi
-internal import ExpoModulesJSI_Cxx
-
-/**
- A Swift wrapper around a JavaScript runtime. Provides access to a JavaScript execution environment, allowing you to evaluate
- JavaScript code, create and manipulate JavaScript objects, functions, and values, and bridge between Swift and JavaScript.
 
- ## Threading
-
- JavaScript runtimes are single-threaded. All operations must be performed on the JavaScript
- thread. Use `schedule()` or `execute()` methods to safely run code on the correct thread.
- The runtime uses `@JavaScriptActor` to enforce thread safety at compile time.
-
- ## Lifecycle
-
- The runtime maintains a weak reference pattern for values, objects, and arrays to prevent
- retain cycles. Ensure the runtime remains alive while any derived JavaScript objects are in use.
- */
+/// A Swift wrapper around a JavaScript runtime. Provides access to a JavaScript execution environment, allowing you to evaluate
+/// JavaScript code, create and manipulate JavaScript objects, functions, and values, and bridge between Swift and JavaScript.
+///
+/// ## Threading
+///
+/// JavaScript runtimes are single-threaded. All operations must be performed on the JavaScript
+/// thread. Use `schedule()` or `execute()` methods to safely run code on the correct thread.
+/// The runtime uses `@JavaScriptActor` to enforce thread safety at compile time.
+///
+/// ## Lifecycle
+///
+/// The runtime maintains a weak reference pattern for values, objects, and arrays to prevent
+/// retain cycles. Ensure the runtime remains alive while any derived JavaScript objects are in use.
 open class JavaScriptRuntime: Equatable, @unchecked Sendable {
-  /**
-   The underlying JSI runtime this `JavaScriptRuntime` points to, exposed as
-   `IRuntime` — the abstract base interface that virtually all JSI value/object/
-   function methods take (`Value::getString`, `Object::setProperty`,
-   `Function::call`, …) since RN 0.86 split the API. Stored as the upcast result
-   of `runtimePointee` because Swift's C++ interop does not auto-upcast between
-   two `SwiftImportAs: reference` types.
-
-   Use ``runtimePointee`` instead when you specifically need a `jsi::Runtime&`
-   (e.g. constructing an `expo.RuntimeScheduler` whose binding lookup is typed on
-   `Runtime&` upstream).
-
-   Note that `facebook.jsi.IRuntime` and `facebook.jsi.Runtime` are imported as
-   reference types so for the Swift compiler they are treated like classes.
-   This is important because they:
-   - are abstract classes with many virtual methods. Swift/C++ interop does not support calling pure virtual methods on value types.
-   - are non-copyable. As value types, we would have to "borrow" them from React Native in an unsafe manner.
-   */
+  /// The underlying JSI runtime this `JavaScriptRuntime` points to, exposed as
+  /// `IRuntime` — the abstract base interface that virtually all JSI value/object/
+  /// function methods take (`Value::getString`, `Object::setProperty`,
+  /// `Function::call`, …) since RN 0.86 split the API. Stored as the upcast result
+  /// of `runtimePointee` because Swift's C++ interop does not auto-upcast between
+  /// two `SwiftImportAs: reference` types.
+  ///
+  /// Use ``runtimePointee`` instead when you specifically need a `jsi::Runtime&`
+  /// (e.g. constructing an `expo.RuntimeScheduler` whose binding lookup is typed on
+  /// `Runtime&` upstream).
+  ///
+  /// Note that `facebook.jsi.IRuntime` and `facebook.jsi.Runtime` are imported as
+  /// reference types so for the Swift compiler they are treated like classes.
+  /// This is important because they:
+  /// - are abstract classes with many virtual methods. Swift/C++ interop does not support calling pure virtual methods on value types.
+  /// - are non-copyable. As value types, we would have to "borrow" them from React Native in an unsafe manner.
   internal let pointee: facebook.jsi.IRuntime
   internal let runtimePointee: facebook.jsi.Runtime
   internal let scheduler: expo.RuntimeScheduler
 
-  /**
-   Thread ID of the JavaScript thread, captured at construction time. Used by `isOnJavaScriptThread()`
-   for a fast integer comparison instead of `Thread.current.name == "..."`.
-   Assumes runtime initializers always run on the JS thread.
-   */
+  /// Thread ID of the JavaScript thread, captured at construction time. Used by `isOnJavaScriptThread()`
+  /// for a fast integer comparison instead of `Thread.current.name == "..."`.
+  /// Assumes runtime initializers always run on the JS thread.
   private let jsThreadID: UInt64 = {
     var id: UInt64 = 0
     pthread_threadid_np(nil, &id)
     return id
   }()
 
-  /**
-   Actor for running runtime work.
-   */
+  /// Actor for running runtime work.
   lazy var runtimeActor: JavaScriptRuntimeActor = JavaScriptRuntimeActor(runtime: self)
 
-  /**
-   Creates a runtime from the JSI runtime. The scheduler runs tasks synchronously
-   on the caller's thread — for the React-backed runtime, use
-   `init(unsafePointer:nativeScheduler:dispatch:)` instead.
-   */
+  /// Creates a runtime from the JSI runtime. The scheduler runs tasks synchronously
+  /// on the caller's thread — for the React-backed runtime, use
+  /// `init(unsafePointer:nativeScheduler:dispatch:)` instead.
   internal init(_ runtime: facebook.jsi.Runtime) {
     self.runtimePointee = runtime
     self.pointee = expo.iruntime(runtime)
     self.scheduler = expo.RuntimeScheduler()
   }
 
-  /**
-   Creates a standalone Hermes runtime. Scheduled tasks run synchronously —
-   no React scheduler is wired up.
-   */
+  /// Creates a standalone Hermes runtime. Scheduled tasks run synchronously —
+  /// no React scheduler is wired up.
   public init() {
     let runtime = expo.createHermesRuntime()
     self.runtimePointee = runtime
@@ -81,11 +68,9 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
     self.scheduler = expo.RuntimeScheduler()
   }
 
-  /**
-   Creates a runtime from a raw pointer to the underlying `facebook.jsi.Runtime`.
-   Scheduled tasks run synchronously — for the React-backed runtime, use
-   `init(unsafePointer:nativeScheduler:dispatch:)` instead.
-   */
+  /// Creates a runtime from a raw pointer to the underlying `facebook.jsi.Runtime`.
+  /// Scheduled tasks run synchronously — for the React-backed runtime, use
+  /// `init(unsafePointer:nativeScheduler:dispatch:)` instead.
   public init(unsafePointer: UnsafeMutableRawPointer) {
     let runtime = unsafeBitCast(unsafePointer, to: facebook.jsi.Runtime.self)
     self.runtimePointee = runtime
@@ -93,17 +78,15 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
     self.scheduler = expo.RuntimeScheduler()
   }
 
-  /**
-   Creates a runtime bound to a host-provided React `RuntimeScheduler`. Calls to
-   `schedule(...)` / `.execute(...)` dispatch through `dispatch`, which the host
-   implements against the real `react::RuntimeScheduler`. This is the path the
-   React Native factory uses.
-
-   - `unsafePointer`: raw pointer to the underlying `facebook::jsi::Runtime`.
-   - `scheduler`: raw pointer to the `react::RuntimeScheduler` instance.
-   - `dispatch`: raw pointer to a C function with signature
-     `void (*)(void *scheduler, int priority, void (^callback)())`.
-   */
+  /// Creates a runtime bound to a host-provided React `RuntimeScheduler`. Calls to
+  /// `schedule(...)` / `.execute(...)` dispatch through `dispatch`, which the host
+  /// implements against the real `react::RuntimeScheduler`. This is the path the
+  /// React Native factory uses.
+  ///
+  /// - `unsafePointer`: raw pointer to the underlying `facebook::jsi::Runtime`.
+  /// - `scheduler`: raw pointer to the `react::RuntimeScheduler` instance.
+  /// - `dispatch`: raw pointer to a C function with signature
+  ///   `void (*)(void *scheduler, int priority, void (^callback)())`.
   public init(
     unsafePointer: UnsafeMutableRawPointer,
     scheduler: UnsafeMutableRawPointer,
@@ -116,34 +99,26 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
     self.scheduler = expo.RuntimeScheduler(scheduler, fn)
   }
 
-  /**
-   Provides scoped access to a raw pointer to the underlying `facebook.jsi.Runtime`.
-   The pointer is valid only for the duration of the closure and must not be stored or escaped.
-   */
+  /// Provides scoped access to a raw pointer to the underlying `facebook.jsi.Runtime`.
+  /// The pointer is valid only for the duration of the closure and must not be stored or escaped.
   public func withUnsafePointee<R>(_ body: (UnsafeMutableRawPointer) throws -> R) rethrows -> R {
     return try body(Unmanaged<facebook.jsi.Runtime>.passUnretained(runtimePointee).toOpaque())
   }
 
-  /**
-   Returns the runtime `global` object.
-   */
+  /// Returns the runtime `global` object.
   public func global() -> JavaScriptObject {
     return JavaScriptObject(self, pointee.global())
   }
 
   // MARK: - Creating objects
 
-  /**
-   Creates a plain JavaScript object.
-   */
+  /// Creates a plain JavaScript object.
   public func createObject() -> JavaScriptObject {
     return JavaScriptObject(self, facebook.jsi.Object(pointee))
   }
 
-  /**
-   Creates a new JavaScript object, using the provided object as the prototype.
-   Calls `Object.create(prototype)` under the hood.
-   */
+  /// Creates a new JavaScript object, using the provided object as the prototype.
+  /// Calls `Object.create(prototype)` under the hood.
   public func createObject(prototype: borrowing JavaScriptObject) -> JavaScriptObject {
     return try! global()
       .getPropertyAsObject("Object")
@@ -152,16 +127,14 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
       .getObject()
   }
 
-  /**
-   Creates a JavaScript host object with given implementations for property getter, property setter, property names getter and dealloc.
-
-   Errors thrown from `get` or `set` propagate to JavaScript as a thrown `Error`. Conform
-   the thrown type to `JavaScriptThrowable` to control the resulting `message` and `code`.
-
-   Pass `nil` for `set` to make the host object read-only — assignment from JavaScript
-   then throws an `Error` whose message names the property and explains how to make it
-   writable. `getPropertyNames` and `dealloc` default to no-ops.
-   */
+  /// Creates a JavaScript host object with given implementations for property getter, property setter, property names getter and dealloc.
+  ///
+  /// Errors thrown from `get` or `set` propagate to JavaScript as a thrown `Error`. Conform
+  /// the thrown type to `JavaScriptThrowable` to control the resulting `message` and `code`.
+  ///
+  /// Pass `nil` for `set` to make the host object read-only — assignment from JavaScript
+  /// then throws an `Error` whose message names the property and explains how to make it
+  /// writable. `getPropertyNames` and `dealloc` default to no-ops.
   public func createHostObject(
     get: @escaping @JavaScriptActor (_ propertyName: String) throws -> JavaScriptValue,
     set: (@JavaScriptActor (_ propertyName: String, _ value: JavaScriptValue) throws -> Void)? = nil,
@@ -182,7 +155,9 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
       }
     }
 
-    func setter(context: UnsafeMutableRawPointer, propertyName: UnsafePointer<CChar>, valuePointer: UnsafeMutableRawPointer) {
+    func setter(
+      context: UnsafeMutableRawPointer, propertyName: UnsafePointer<CChar>, valuePointer: UnsafeMutableRawPointer
+    ) {
       let context = Unmanaged<HostObjectContext>.fromOpaque(context).takeUnretainedValue()
 
       guard let runtime = context.runtime else {
@@ -236,10 +211,12 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
       }
     }
 
-    let context = Unmanaged.passRetained(HostObjectContext(runtime: self, get, set, getPropertyNames, dealloc)).toOpaque()
+    let context = Unmanaged.passRetained(HostObjectContext(runtime: self, get, set, getPropertyNames, dealloc))
+      .toOpaque()
     // Pass a null setter to C++ when the Swift setter is nil so that JS assignment
     // raises a `jsi::JSError` directly, without crossing the Swift boundary.
-    let callbacks = expo.HostObjectCallbacks(context, getter, set == nil ? nil : setter, propertyNamesGetter, deallocate)
+    let callbacks = expo.HostObjectCallbacks(
+      context, getter, set == nil ? nil : setter, propertyNamesGetter, deallocate)
     let hostObject = expo.HostObject.makeObject(pointee, consume callbacks)
 
     return JavaScriptObject(self, hostObject)
@@ -247,19 +224,17 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
 
   // MARK: - Creating array buffers
 
-  /**
-   Creates a new array buffer of the given size with zero-initialized memory.
-   */
+  /// Creates a new array buffer of the given size with zero-initialized memory.
   public func createArrayBuffer(size: Int) -> JavaScriptArrayBuffer {
     let jsiArrayBuffer = expo.createArrayBuffer(pointee, size)
     return JavaScriptArrayBuffer(self, jsiArrayBuffer)
   }
 
-  /**
-   Creates a new array buffer that wraps the given native data pointer.
-   The cleanup closure is called when the array buffer is garbage collected.
-   */
-  public func createArrayBuffer(data: UnsafeMutablePointer<UInt8>, size: Int, cleanup: @escaping @Sendable () -> Void) -> JavaScriptArrayBuffer {
+  /// Creates a new array buffer that wraps the given native data pointer.
+  /// The cleanup closure is called when the array buffer is garbage collected.
+  public func createArrayBuffer(data: UnsafeMutablePointer<UInt8>, size: Int, cleanup: @escaping @Sendable () -> Void)
+    -> JavaScriptArrayBuffer
+  {
     let context = Unmanaged.passRetained(CleanupContext(cleanup)).toOpaque()
     let jsiArrayBuffer = expo.createArrayBuffer(pointee, data, size, context) { context in
       Unmanaged<CleanupContext>.fromOpaque(context).release()
@@ -269,28 +244,26 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
 
   // MARK: - Creating arrays
 
-  /**
-   Creates a new Array instance.
-   */
+  /// Creates a new Array instance.
   public func createArray(length: Int = 0) -> JavaScriptArray {
     return JavaScriptArray(self, facebook.jsi.Array(pointee, length))
   }
 
   // MARK: - Creating functions
 
-  /**
-   Type of the closure that is passed to the `createFunction` function.
-   */
-  public typealias SyncFunctionClosure = @JavaScriptActor (
-    _ this: JavaScriptValue,
-    _ arguments: consuming JavaScriptValuesBuffer
-  ) throws -> JavaScriptValue
-
-  /**
-   Creates a class with the given name and native constructor.
-   */
+  /// Type of the closure that is passed to the `createFunction` function.
+  public typealias SyncFunctionClosure =
+    @JavaScriptActor (
+      _ this: JavaScriptValue,
+      _ arguments: consuming JavaScriptValuesBuffer
+    ) throws -> JavaScriptValue
+
+  /// Creates a class with the given name and native constructor.
   @JavaScriptActor
-  public func createClass(name: String, inheriting baseClass: consuming JavaScriptFunction? = nil, _ constructor: @escaping SyncFunctionClosure) throws -> JavaScriptFunction {
+  public func createClass(
+    name: String, inheriting baseClass: consuming JavaScriptFunction? = nil,
+    _ constructor: @escaping SyncFunctionClosure
+  ) throws -> JavaScriptFunction {
     // Host functions are not standard functions, thus cannot be used as class constructors.
     // We're creating one by evaluating a script that calls a "native constructor" that is a host function.
     let nativeConstructorKey = "__native_constructor__"
@@ -300,7 +273,9 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
       throw InvalidIdentifierError(identifier: name)
     }
 
-    let klassValue = try eval(label: "\(name).\(nativeConstructorKey)", "(function \(name)(...args) { return this.\(nativeConstructorKey)(...args); })")
+    let klassValue = try eval(
+      label: "\(name).\(nativeConstructorKey)",
+      "(function \(name)(...args) { return this.\(nativeConstructorKey)(...args); })")
     let klassObject = klassValue.getObject()
 
     // Create a host function that is called by the constructor
@@ -309,7 +284,7 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
     }
 
     // Set native constructor as read-only, non-configurable, non-enumerable, non-writable property.
-    let prototype = klassObject.getPropertyAsObject("prototype")
+    let prototype = try klassObject.getPropertyAsObject("prototype")
     prototype.defineProperty(nativeConstructorKey, value: nativeConstructor)
 
     // If the base class is provided, set the inherited prototype.
@@ -324,11 +299,9 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
     return klassValue.getFunction()
   }
 
-  /**
-   Creates a synchronous host function that runs the given closure when it's called.
-   The value returned by the closure is synchronously returned to JS.
-   - Returns: A JavaScript function represented as a `JavaScriptFunction`.
-   */
+  /// Creates a synchronous host function that runs the given closure when it's called.
+  /// The value returned by the closure is synchronously returned to JS.
+  /// - Returns: A JavaScript function represented as a `JavaScriptFunction`.
   @JavaScriptActor
   public func createFunction(_ name: String, _ function: sending @escaping SyncFunctionClosure) -> JavaScriptFunction {
     let closure = createFunctionClosure(runtime: self, name: name, function)
@@ -337,11 +310,9 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
     return JavaScriptFunction(self, hostFunction)
   }
 
-  /**
-   Creates a synchronous anonymous host function that runs the given closure when it's called.
-   The value returned by the closure is synchronously returned to JS.
-   - Returns: A JavaScript function represented as a `JavaScriptFunction`.
-   */
+  /// Creates a synchronous anonymous host function that runs the given closure when it's called.
+  /// The value returned by the closure is synchronously returned to JS.
+  /// - Returns: A JavaScript function represented as a `JavaScriptFunction`.
   @JavaScriptActor
   public func createFunction(_ function: sending @escaping SyncFunctionClosure) -> JavaScriptFunction {
     let closure = createFunctionClosure(runtime: self, name: nil, function)
@@ -350,24 +321,23 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
     return JavaScriptFunction(self, hostFunction)
   }
 
-  /**
-   Type of the closure that is passed to the `createAsyncFunction` function.
-   It is invoked from asynchronous context, so it can await and call other asynchronous functions.
-   */
-  public typealias AsyncFunctionClosure = @JavaScriptActor (
-    _ this: JavaScriptValue,
-    _ arguments: consuming JavaScriptValuesBuffer,
-  ) async throws -> JavaScriptValue
-
-  /**
-   Creates an asynchronous host function that runs given block when it's called.
-   The value returned by the closure is returned to JS asynchronously.
-   - Returns: A JavaScript function represented as a `JavaScriptFunction` that returns a promise.
-   */
+  /// Type of the closure that is passed to the `createAsyncFunction` function.
+  /// It is invoked from asynchronous context, so it can await and call other asynchronous functions.
+  public typealias AsyncFunctionClosure =
+    @JavaScriptActor (
+      _ this: JavaScriptValue,
+      _ arguments: consuming JavaScriptValuesBuffer,
+    ) async throws -> JavaScriptValue
+
+  /// Creates an asynchronous host function that runs given block when it's called.
+  /// The value returned by the closure is returned to JS asynchronously.
+  /// - Returns: A JavaScript function represented as a `JavaScriptFunction` that returns a promise.
   @JavaScriptActor
-  public func createAsyncFunction(_ name: String, _ function: sending @escaping AsyncFunctionClosure) -> JavaScriptFunction {
+  public func createAsyncFunction(_ name: String, _ function: sending @escaping AsyncFunctionClosure)
+    -> JavaScriptFunction
+  {
     return createFunction(name) { this, arguments in
-      let promise = JavaScriptPromise(self)
+      let promise = try JavaScriptPromise(self)
 
       // Arguments buffer needs to be copied to ensure safe async access.
       let argumentsRef = arguments.copy().ref()
@@ -390,18 +360,17 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
 
   // MARK: - Runtime execution
 
-  /**
-   Whether the runtime scheduler can dispatch work asynchronously to the JS thread.
-   Returns false for standalone runtimes (e.g. in tests) where scheduled tasks run synchronously.
-   */
+  /// Whether the runtime scheduler can dispatch work asynchronously to the JS thread.
+  /// Returns false for standalone runtimes (e.g. in tests) where scheduled tasks run synchronously.
   public var supportsAsyncScheduling: Bool {
     return scheduler.supportsAsyncScheduling()
   }
 
-  /**
-   Schedules a closure to be executed with granted synchronized access to the runtime.
-   */
-  public func schedule(priority: SchedulerPriority = .normal, @_implicitSelfCapture _ closure: @escaping @JavaScriptActor () -> sending Void) -> Void {
+  /// Schedules a closure to be executed with granted synchronized access to the runtime.
+  public func schedule(
+    priority: SchedulerPriority = .normal,
+    @_implicitSelfCapture _ closure: @escaping @JavaScriptActor () -> sending Void
+  ) {
     let cxxPriority = expo.RuntimeScheduler.Priority(rawValue: priority.rawValue) ?? .NormalPriority
     scheduler.scheduleTask(cxxPriority) {
       JavaScriptActor.assumeIsolated(closure)
@@ -411,7 +380,7 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
   public func schedule(
     priority: SchedulerPriority = .normal,
     @_implicitSelfCapture _ closure: @escaping @JavaScriptActor () async throws -> Void
-  ) -> Void {
+  ) {
     schedule(priority: priority) {
       Task.immediate_polyfill {
         try await closure()
@@ -419,13 +388,13 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
     }
   }
 
-  /**
-   Synchronously executes a closure on the JavaScript runtime thread, blocking the current thread until completion.
-   Not available in async contexts to prevent blocking the cooperative thread pool.
-   */
+  /// Synchronously executes a closure on the JavaScript runtime thread, blocking the current thread until completion.
+  /// Not available in async contexts to prevent blocking the cooperative thread pool.
   @available(*, noasync)
   @discardableResult
-  public func execute<R: Sendable>(@_implicitSelfCapture _ closure: @escaping @JavaScriptActor () throws -> R) throws -> sending R {
+  public func execute<R: Sendable>(@_implicitSelfCapture _ closure: @escaping @JavaScriptActor () throws -> R) throws
+    -> sending R
+  {
     if isOnJavaScriptThread() {
       return try JavaScriptActor.assumeIsolated(closure)
     }
@@ -460,10 +429,8 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
     return try result.get()
   }
 
-  /**
-   Synchronously executes an async closure on the JavaScript runtime thread, blocking the current thread until completion.
-   Not available in async contexts to prevent blocking the cooperative thread pool.
-   */
+  /// Synchronously executes an async closure on the JavaScript runtime thread, blocking the current thread until completion.
+  /// Not available in async contexts to prevent blocking the cooperative thread pool.
   @available(*, noasync)
   @discardableResult
   public func execute<R: Sendable>(
@@ -475,7 +442,7 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
     // to work around a Swift 6.2.3 compiler bug.
     let callerRunLoop = NonisolatedUnsafeVar(CFRunLoopGetCurrent())
 
-    func body() -> Void {
+    func body() {
       Task.immediate_polyfill(priority: .high) {
         do {
           result.value = .success(try await closure())
@@ -503,9 +470,7 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
     return try result.value.get()
   }
 
-  /**
-   Asynchronously executes a sync closure on the JavaScript runtime thread, awaiting its completion without blocking.
-   */
+  /// Asynchronously executes a sync closure on the JavaScript runtime thread, awaiting its completion without blocking.
   @discardableResult
   public func execute<R: Sendable>(
     @_implicitSelfCapture _ closure: @escaping @JavaScriptActor () throws -> R
@@ -524,9 +489,7 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
     }
   }
 
-  /**
-   Asynchronously executes an async closure on the JavaScript runtime thread, awaiting its completion without blocking.
-   */
+  /// Asynchronously executes an async closure on the JavaScript runtime thread, awaiting its completion without blocking.
   @discardableResult
   public func execute<R: Sendable>(
     @_implicitSelfCapture _ closure: @escaping @JavaScriptActor () async throws -> R
@@ -547,9 +510,7 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
     }
   }
 
-  /**
-   Checks whether the function is called on the JavaScript thread.
-   */
+  /// Checks whether the function is called on the JavaScript thread.
   @inline(__always)
   public final func isOnJavaScriptThread() -> Bool {
     var current: UInt64 = 0
@@ -557,18 +518,14 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
     return current == jsThreadID
   }
 
-  /**
-   Asserts whether we are on the JavaScript thread. Helpful for debugging threading issues.
-   */
+  /// Asserts whether we are on the JavaScript thread. Helpful for debugging threading issues.
   @inline(__always)
   public final func assertThread(file: String = #file, function: String = #function, line: Int = #line) {
     assert(isOnJavaScriptThread(), "Function '\(function)' is not run on the JavaScript thread (\(file):\(line))")
   }
 
-  /**
-   Priority of the scheduled task.
-   - Note: Keep it in sync with the equivalent C++ enum from React Native (see `SchedulerPriority.h` from `React-callinvoker`).
-   */
+  /// Priority of the scheduled task.
+  /// - Note: Keep it in sync with the equivalent C++ enum from React Native (see `SchedulerPriority.h` from `React-callinvoker`).
   public enum SchedulerPriority: Int32 {
     case immediate = 1
     case userBlocking = 2
@@ -579,9 +536,7 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
 
   // MARK: - Script evaluation
 
-  /**
-   Evaluates given JavaScript source code.
-   */
+  /// Evaluates given JavaScript source code.
   @discardableResult
   @JavaScriptActor
   public func eval(label: String? = nil, _ source: String) throws -> JavaScriptValue {
@@ -597,9 +552,7 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
     }
   }
 
-  /**
-   Evaluates the given JavaScript source code made by joining an array of strings with a newline separator.
-   */
+  /// Evaluates the given JavaScript source code made by joining an array of strings with a newline separator.
   @available(*, deprecated, message: "Spread the array into arguments instead")
   @discardableResult
   @JavaScriptActor
@@ -607,18 +560,14 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
     try eval(label: label, lines.joined(separator: "\n"))
   }
 
-  /**
-   Evaluates the given JavaScript source code made by joining arguments with a newline separator.
-   */
+  /// Evaluates the given JavaScript source code made by joining arguments with a newline separator.
   @discardableResult
   @JavaScriptActor
   public func eval(label: String? = nil, _ lines: String...) throws -> JavaScriptValue {
     try eval(label: label, lines.joined(separator: "\n"))
   }
 
-  /**
-   Evaluates given JavaScript source code in an async context. If the evaluated source returns a Promise, it awaits until the promise is resolved/rejected.
-   */
+  /// Evaluates given JavaScript source code in an async context. If the evaluated source returns a Promise, it awaits until the promise is resolved/rejected.
   @discardableResult
   @JavaScriptActor
   public func evalAsync(label: String? = nil, _ source: String) async throws -> JavaScriptValue {
@@ -638,10 +587,15 @@ open class JavaScriptRuntime: Equatable, @unchecked Sendable {
   internal var propNameIdsRegistry: [String: JavaScriptPropNameID] = [:]
 }
 
-private func createFunctionClosure(runtime: JavaScriptRuntime, name: String? = nil, _ closure: @escaping JavaScriptRuntime.SyncFunctionClosure) -> expo.HostFunctionClosure {
+private func createFunctionClosure(
+  runtime: JavaScriptRuntime, name: String? = nil, _ closure: @escaping JavaScriptRuntime.SyncFunctionClosure
+) -> expo.HostFunctionClosure {
   let context = Unmanaged.passRetained(HostFunctionContext(runtime: runtime, name: name, closure)).toOpaque()
 
-  func call(context: UnsafeMutableRawPointer, thisPtr: UnsafePointer<facebook.jsi.Value>, argumentsPtr: UnsafePointer<facebook.jsi.Value>, argumentsCount: Int) -> facebook.jsi.Value {
+  func call(
+    context: UnsafeMutableRawPointer, thisPtr: UnsafePointer<facebook.jsi.Value>,
+    argumentsPtr: UnsafePointer<facebook.jsi.Value>, argumentsCount: Int
+  ) -> facebook.jsi.Value {
     let context = Unmanaged<HostFunctionContext>.fromOpaque(context).takeUnretainedValue()
 
     guard let runtime = context.runtime else {
@@ -668,14 +622,10 @@ private func createFunctionClosure(runtime: JavaScriptRuntime, name: String? = n
 // MARK: - Errors
 
 extension JavaScriptRuntime {
-  /**
-   Thrown when an invalid JavaScript identifier is passed to APIs that interpolate
-   the name into evaluated JavaScript source, such as ``createClass(name:inheriting:_:)``.
-   */
+  /// Thrown when an invalid JavaScript identifier is passed to APIs that interpolate
+  /// the name into evaluated JavaScript source, such as ``createClass(name:inheriting:_:)``.
   public struct InvalidIdentifierError: Error, CustomStringConvertible {
-    /**
-     The identifier string that failed validation.
-     */
+    /// The identifier string that failed validation.
     public let identifier: String
 
     public var description: String {