expo-modules-jsi 58.0.7 → 58.0.9

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 58.0.9
+
+### Patch Changes
+
+- [iOS] Add a `JavaScriptCodable` conformance for `Set`: it encodes to a JS `Set` and decodes from a JS `Set` or an array, collapsing duplicate elements. ([#50859](https://github.com/expo/expo/pull/50859) by [@tsapeta](https://github.com/tsapeta))
+- `JavaScriptRuntime.evalAsync` now evaluates on the JavaScript thread when called from another thread on a runtime with a scheduler, instead of on the calling thread. ([#51015](https://github.com/expo/expo/pull/51015) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] Speed up `JavaScriptObject.defineProperty` by looking up `Object.defineProperty` once per runtime and building the descriptor in C++. ([#51004](https://github.com/expo/expo/pull/51004) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] Fix the xcframework failing to build with Xcode 26 (Swift 6.2): `RuntimeScheduler` constructors annotated with `SWIFT_RETURNS_RETAINED` were rejected, and host function and host object getter callbacks failed with `sending '...' risks causing data races`. ([#51040](https://github.com/expo/expo/pull/51040) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] Speed up integer arguments and results of native functions by running the integer conversions specialized inside `ExpoModulesJSI` instead of unspecialized in the calling module. A host function that adds two `Int`s runs about 7× faster. ([#51055](https://github.com/expo/expo/pull/51055) by [@tsapeta](https://github.com/tsapeta))
+
+## 58.0.8
+
+### Patch Changes
+
+- [iOS] Add `decodableKinds` to `JavaScriptDecodable`: the kinds of JavaScript value (`JavaScriptValueKinds`) that `decode` can accept, so code that picks between several types can skip the ones that can't match. ([#50905](https://github.com/expo/expo/pull/50905) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] Fix crash reports symbolicated on the device showing no function names for `ExpoModulesJSI` frames. ([#50698](https://github.com/expo/expo/pull/50698) by [@tsapeta](https://github.com/tsapeta))
+- Return strings, objects and arrays from host functions and host object getters without cloning the engine handle, and build short ASCII strings from JS inline. ([#50937](https://github.com/expo/expo/pull/50937) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] Add `JavaScriptRuntime.cached(_:_:)` with typed `JavaScriptRuntime.Cache.Key`s, to create a value once per runtime and reuse it, for example a JavaScript constructor or a property name. A lookup reads one array slot, about 5× faster than the string-keyed `JavaScriptPropNameID.cached(_:_:)`. ([#50888](https://github.com/expo/expo/pull/50888) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] Add `JavaScriptValue.withUnownedValue(in:_:)`, and give the owning `JavaScriptDecodable.decode` a default that borrows the value and decodes it through the `JavaScriptUnownedValue` overload, so a conformer can implement only that one. Arrays, dictionaries, dates, records and enums now decode unowned values without copying them first. ([#50960](https://github.com/expo/expo/pull/50960) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] Add `JavaScriptArray.mapUnowned(_:)`, `JavaScriptObject.withUnownedProperty(_:_:)`, and `isArray()` and `getArray(in:)` on `JavaScriptUnownedValue`. Arrays, dictionaries and dates now decode through their unowned overload without copying the value or wrapping each element in a `JavaScriptValue`, and their owning decodes forward to it. ([#50980](https://github.com/expo/expo/pull/50980) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] Keep checkout paths out of the Swift compilation cache key so modules importing ExpoModulesCore can reuse cached compilation results across checkouts and worktrees. ([#50354](https://github.com/expo/expo/pull/50354) by [@janicduplessis](https://github.com/janicduplessis))
+
 ## 58.0.7
 
 ### Patch Changes

package/apple/Benchmarks/ContainerCodingBenchmarks.swift

@@ -0,0 +1,74 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import ExpoModulesJSI
+import Testing
+
+/// Benchmarks comparing the `Array` and `Set` `JavaScriptCodable` conformances. `Set` decoding from a
+/// JS array shares the `Array` fast path and adds only the hashing, while decoding from a JS `Set` and
+/// encoding to one go through the global `Array.from` and `Set` constructor, so each case is measured
+/// against its `Array` counterpart at a small and a large element count.
+extension JSIBenchmarks {
+  // MARK: - Decode
+
+  @Test(arguments: [10, 1000])
+  func `decode an array of ints as Array`(count: Int) async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("Array.from({ length: \(count) }, (_, i) => i)")
+      try benchmark("[Int].decode: JS array of \(count)", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try [Int].decode(value, in: runtime)
+        }
+      }
+    }
+  }
+
+  @Test(arguments: [10, 1000])
+  func `decode an array of ints as Set`(count: Int) async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("Array.from({ length: \(count) }, (_, i) => i)")
+      try benchmark("Set<Int>.decode: JS array of \(count)", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try Set<Int>.decode(value, in: runtime)
+        }
+      }
+    }
+  }
+
+  @Test(arguments: [10, 1000])
+  func `decode a set of ints as Set`(count: Int) async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("new Set(Array.from({ length: \(count) }, (_, i) => i))")
+      try benchmark("Set<Int>.decode: JS Set of \(count)", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try Set<Int>.decode(value, in: runtime)
+        }
+      }
+    }
+  }
+
+  // MARK: - Encode
+
+  @Test(arguments: [10, 1000])
+  func `encode an Array of ints`(count: Int) async throws {
+    try await benchmarkCase { runtime in
+      let array = Array(0..<count)
+      try benchmark("[Int].encode: \(count) elements", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try [Int].encode(array, in: runtime)
+        }
+      }
+    }
+  }
+
+  @Test(arguments: [10, 1000])
+  func `encode a Set of ints`(count: Int) async throws {
+    try await benchmarkCase { runtime in
+      let set = Set(0..<count)
+      try benchmark("Set<Int>.encode: \(count) elements", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try Set<Int>.encode(set, in: runtime)
+        }
+      }
+    }
+  }
+}

package/apple/Benchmarks/HostFunctionBenchmarks.swift

@@ -87,6 +87,47 @@ extension JSIBenchmarks {
     }
   }
 
+  // The integer codables, as bindings call them: `Int.decode` for an `Int` argument and `Int?.decode`
+  // for an optional one.
+
+  @Test
+  func `host function adding two Ints`() async throws {
+    try await benchmarkCase { runtime in
+      let fn = runtime.createFunction("add") {
+        [runtime] (this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer) in
+        let a = try Int.decode(arguments.unownedValue(at: 0), in: runtime)
+        let b = try Int.decode(arguments.unownedValue(at: 1), in: runtime)
+        return try Int.encode(a + b, in: runtime)
+      }
+      runtime.global().setProperty("benchFn", value: fn)
+      let driver = try runtime.eval(
+        "(function(n) { for (var i = 0; i < n; i++) benchFn(3, 38); })"
+      ).getFunction()
+      try benchmark("host function: add two Ints", runtime: runtime) { iterations in
+        _ = try driver.call(arguments: iterations)
+      }
+    }
+  }
+
+  @Test
+  func `host function adding two optional Ints`() async throws {
+    try await benchmarkCase { runtime in
+      let fn = runtime.createFunction("add") {
+        [runtime] (this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer) in
+        let a = try Int?.decode(arguments.unownedValue(at: 0), in: runtime) ?? 0
+        let b = try Int?.decode(arguments.unownedValue(at: 1), in: runtime) ?? 0
+        return try Int.encode(a + b, in: runtime)
+      }
+      runtime.global().setProperty("benchFn", value: fn)
+      let driver = try runtime.eval(
+        "(function(n) { for (var i = 0; i < n; i++) benchFn(3, 38); })"
+      ).getFunction()
+      try benchmark("host function: add two optional Ints", runtime: runtime) { iterations in
+        _ = try driver.call(arguments: iterations)
+      }
+    }
+  }
+
   // MARK: - Unowned-this form with string arguments
 
   @Test

package/apple/Benchmarks/RuntimeCacheBenchmarks.swift

@@ -0,0 +1,71 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import ExpoModulesJSI
+import Testing
+
+private let answerPropNameKey = JavaScriptRuntime.Cache.Key<JavaScriptPropNameID>()
+
+/// Benchmarks for values cached per runtime with ``JavaScriptRuntime/cached(_:_:)``, read against
+/// the string-keyed ``JavaScriptPropNameID/cached(_:_:)`` registry.
+extension JSIBenchmarks {
+  @Test
+  func `runtime cache hit`() async throws {
+    try await benchmarkCase { runtime in
+      _ = runtime.cached(answerPropNameKey) { JavaScriptPropNameID(runtime, string: "answer") }
+      try benchmark("JavaScriptRuntime.cached(_:_:): hit", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = runtime.cached(answerPropNameKey) { JavaScriptPropNameID(runtime, string: "answer") }
+        }
+      }
+    }
+  }
+
+  @Test
+  func `object property by runtime-cached PropNameID`() async throws {
+    try await benchmarkCase { runtime in
+      let object = try runtime.eval("({ answer: 42 })").getObject()
+      try benchmark("JavaScriptObject.getProperty(_:): runtime-cached PropNameID", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = object.getProperty(runtime.cached(answerPropNameKey) { JavaScriptPropNameID(runtime, string: "answer") })
+        }
+      }
+    }
+  }
+
+  @Test
+  func `string-keyed PropNameID cache hit`() async throws {
+    try await benchmarkCase { runtime in
+      try benchmark("JavaScriptPropNameID.cached(_:_:): hit", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = JavaScriptPropNameID.cached(runtime, "answer")
+        }
+      }
+    }
+  }
+
+  @Test
+  func `object property by string-keyed cached PropNameID`() async throws {
+    try await benchmarkCase { runtime in
+      let object = try runtime.eval("({ answer: 42 })").getObject()
+      try benchmark("JavaScriptObject.getProperty(_:): string-cached PropNameID", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = object.getProperty(.cached(runtime, "answer"))
+        }
+      }
+    }
+  }
+
+  @Test
+  func `object property by prebuilt PropNameID`() async throws {
+    try await benchmarkCase { runtime in
+      let object = try runtime.eval("({ answer: 42 })").getObject()
+      let propName = JavaScriptPropNameID(runtime, string: "answer")
+      try benchmark("JavaScriptObject.getProperty(_:): prebuilt PropNameID", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = object.getProperty(propName)
+        }
+      }
+      withExtendedLifetime(propName) {}
+    }
+  }
+}

package/apple/Benchmarks/UnownedDecodeBenchmarks.swift

@@ -0,0 +1,121 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import ExpoModulesJSI
+import Foundation
+import Testing
+
+/// Decoding from a borrowed `JavaScriptUnownedValue`, the path a `@JS` argument takes, and from an owning
+/// `JavaScriptValue`, the path a nested value takes. A type without its own unowned decode copies the
+/// value into an owning `JavaScriptValue` first.
+extension JSIBenchmarks {
+  @Test
+  func `unowned decode of an array`() async throws {
+    try await benchmarkCase { runtime in
+      let buffer = JavaScriptValuesBuffer.allocate(in: runtime, with: try runtime.eval("[1, 2, 3, 4, 5, 6, 7, 8]"))
+      try benchmark("[Double].decode(unowned): 8 elements", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try [Double].decode(buffer.unownedValue(at: 0), in: runtime)
+        }
+      }
+    }
+  }
+
+  @Test
+  func `unowned decode of a dictionary`() async throws {
+    try await benchmarkCase { runtime in
+      let buffer = JavaScriptValuesBuffer.allocate(in: runtime, with: try runtime.eval("({ a: 1, b: 2, c: 3, d: 4 })"))
+      try benchmark("[String: Double].decode(unowned): 4 entries", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try [String: Double].decode(buffer.unownedValue(at: 0), in: runtime)
+        }
+      }
+    }
+  }
+
+  @Test
+  func `unowned decode of a date`() async throws {
+    try await benchmarkCase { runtime in
+      let buffer = JavaScriptValuesBuffer.allocate(in: runtime, with: try runtime.eval("1700000000000"))
+      try benchmark("Date.decode(unowned): number", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try Date.decode(buffer.unownedValue(at: 0), in: runtime)
+        }
+      }
+    }
+  }
+
+  @Test
+  func `owning decode of an array`() async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("[1, 2, 3, 4, 5, 6, 7, 8]")
+      try benchmark("[Double].decode(owning): 8 elements", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try [Double].decode(value, in: runtime)
+        }
+      }
+    }
+  }
+
+  @Test
+  func `owning decode of a dictionary`() async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("({ a: 1, b: 2, c: 3, d: 4 })")
+      try benchmark("[String: Double].decode(owning): 4 entries", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try [String: Double].decode(value, in: runtime)
+        }
+      }
+    }
+  }
+
+  @Test
+  func `owning decode of nested arrays`() async throws {
+    try await benchmarkCase { runtime in
+      let value = try runtime.eval("[[1, 2], [3, 4], [5, 6], [7, 8]]")
+      try benchmark("[[Double]].decode(owning): 4 x 2 elements", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try [[Double]].decode(value, in: runtime)
+        }
+      }
+    }
+  }
+
+  @Test
+  func `unowned decode of nested arrays`() async throws {
+    try await benchmarkCase { runtime in
+      let buffer = JavaScriptValuesBuffer.allocate(
+        in: runtime,
+        with: try runtime.eval("[[1, 2], [3, 4], [5, 6], [7, 8]]")
+      )
+      try benchmark("[[Double]].decode(unowned): 4 x 2 elements", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try [[Double]].decode(buffer.unownedValue(at: 0), in: runtime)
+        }
+      }
+    }
+  }
+
+  @Test
+  func `unowned decode of a date string`() async throws {
+    try await benchmarkCase { runtime in
+      let buffer = JavaScriptValuesBuffer.allocate(in: runtime, with: try runtime.eval("'2026-10-02T12:00:00Z'"))
+      try benchmark("Date.decode(unowned): ISO string", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try Date.decode(buffer.unownedValue(at: 0), in: runtime)
+        }
+      }
+    }
+  }
+
+  @Test
+  func `unowned decode of a date object`() async throws {
+    try await benchmarkCase { runtime in
+      let buffer = JavaScriptValuesBuffer.allocate(in: runtime, with: try runtime.eval("new Date(1700000000000)"))
+      try benchmark("Date.decode(unowned): Date object", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = try Date.decode(buffer.unownedValue(at: 0), in: runtime)
+        }
+      }
+    }
+  }
+}

package/apple/Benchmarks/ValueAccessBenchmarks.swift

@@ -129,4 +129,27 @@ extension JSIBenchmarks {
       }
     }
   }
+
+  @Test
+  func `define a property`() async throws {
+    try await benchmarkCase { runtime in
+      try benchmark("JavaScriptObject.defineProperty(_:value:options:)", runtime: runtime) { iterations in
+        for index in 0..<iterations {
+          let object = runtime.createObject()
+          object.defineProperty("__expo_shared_object_id__", value: index, options: [.writable])
+        }
+      }
+    }
+  }
+
+  @Test
+  func `create an object`() async throws {
+    try await benchmarkCase { runtime in
+      try benchmark("JavaScriptRuntime.createObject()", runtime: runtime) { iterations in
+        for _ in 0..<iterations {
+          _ = runtime.createObject()
+        }
+      }
+    }
+  }
 }

package/apple/Sources/ExpoModulesJSI/Coding/JavaScriptCodable+Containers.swift

@@ -10,19 +10,36 @@
 // MARK: - Array
 
 extension Array: JavaScriptDecodable where Element: JavaScriptDecodable {
+  // A non-array value is decoded as a single-element array, so it's accepted when the element is.
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return Element.decodableKinds.union(.object)
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws
     -> [Element]
+  {
+    // Forwards to the unowned overload, which holds the implementation.
+    let runtime = copy runtime
+    return try value.withUnownedValue(in: runtime) { unownedValue in
+      return try decode(unownedValue, in: runtime)
+    }
+  }
+
+  @JavaScriptActor
+  @inlinable
+  public static func decode(_ value: borrowing JavaScriptUnownedValue, in runtime: borrowing JavaScriptRuntime) throws
+    -> [Element]
   {
     // A non-array value is "arrayized" into a single-element array, so a caller that passes a
     // scalar where an array is expected still works.
     guard value.isArray() else {
       return [try Element.decode(value, in: runtime)]
     }
-    // `map` reads the length once and uses the unchecked element accessor, avoiding a
-    // per-element weak-runtime load and bounds check on this hot path.
-    return try value.getArray().map { element in
+    // Each element is lent out unowned, so it's decoded without a `JavaScriptValue` per element.
+    return try value.getArray(in: runtime).mapUnowned { element in
       return try Element.decode(element, in: runtime)
     }
   }
@@ -45,6 +62,11 @@ extension Array: JavaScriptEncodable where Element: JavaScriptEncodable {
 // MARK: - Optional
 
 extension Optional: JavaScriptDecodable where Wrapped: JavaScriptDecodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return Wrapped.decodableKinds.union([.null, .undefined])
+  }
+
   // Optional copies nothing itself, so it overrides the zero-copy overload too and forwards the
   // borrowed value straight through — a wrapped primitive argument stays fully zero-copy.
   @JavaScriptActor
@@ -87,22 +109,42 @@ extension Optional: JavaScriptEncodable where Wrapped: JavaScriptEncodable {
 // MARK: - Dictionary
 
 extension Dictionary: JavaScriptDecodable where Key == String, Value: JavaScriptDecodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .object
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws
     -> [String: Value]
   {
-    let object = try value.asObject()
+    // Forwards to the unowned overload, which holds the implementation.
+    let runtime = copy runtime
+    return try value.withUnownedValue(in: runtime) { unownedValue in
+      return try decode(unownedValue, in: runtime)
+    }
+  }
+
+  @JavaScriptActor
+  @inlinable
+  public static func decode(_ value: borrowing JavaScriptUnownedValue, in runtime: borrowing JavaScriptRuntime) throws
+    -> [String: Value]
+  {
+    // Reads the object straight from the borrowed value and lends each property out unowned, so it's
+    // decoded without a `JavaScriptValue` per property.
+    let object = try value.asObject(in: runtime)
     let keys = object.getPropertyNames()
     var result = [String: Value](minimumCapacity: keys.count)
     for key in keys {
-      let property = object.getProperty(key)
-      // Treat an `undefined`-valued property as an absent entry. Without this a non-optional
-      // `Value` would reject an object that simply omits the property as `undefined`.
-      if property.isUndefined() {
-        continue
+      let decoded: Value? = try object.withUnownedProperty(key) { property in
+        // Treat an `undefined`-valued property as an absent entry. Without this a non-optional
+        // `Value` would reject an object that simply omits the property as `undefined`.
+        return property.isUndefined() ? nil : try Value.decode(property, in: runtime)
+      }
+      if let decoded {
+        result[key] = decoded
       }
-      result[key] = try Value.decode(property, in: runtime)
     }
     return result
   }

package/apple/Sources/ExpoModulesJSI/Coding/JavaScriptCodable+Data.swift

@@ -9,6 +9,11 @@ import Foundation
 // read/write rather than a single accessor.
 
 extension Data: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return .object
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Data

package/apple/Sources/ExpoModulesJSI/Coding/JavaScriptCodable+Date.swift

@@ -9,22 +9,44 @@ import Foundation
 // A `Date` is an absolute instant with no timezone/calendar; resolution is milliseconds.
 
 extension Date: JavaScriptCodable {
+  @inlinable
+  public static var decodableKinds: JavaScriptValueKinds {
+    return [.number, .string, .object]
+  }
+
   @JavaScriptActor
   @inlinable
   public static func decode(_ value: borrowing JavaScriptValue, in runtime: borrowing JavaScriptRuntime) throws -> Date
   {
-    // The cheap tag checks come before `is("Date")`, which does a global lookup plus an `instanceof`
-    // walk; a number or string can't be a `Date`, so the order is behavior-neutral.
+    // Forwards to the unowned overload, which holds the implementation.
+    let runtime = copy runtime
+    return try value.withUnownedValue(in: runtime) { unownedValue in
+      return try decode(unownedValue, in: runtime)
+    }
+  }
+
+  @JavaScriptActor
+  @inlinable
+  public static func decode(_ value: borrowing JavaScriptUnownedValue, in runtime: borrowing JavaScriptRuntime) throws
+    -> Date
+  {
+    // The cheap tag checks come before the `instanceof` check, which needs a global lookup; a number or
+    // a string can't be a `Date`, so the order is behavior-neutral. Only the string branch copies the
+    // value, since the `Date` constructor takes owning arguments; a string is the rare input.
     if value.isNumber() {
       return try dateFromMilliseconds(value.getDouble())
     }
     if value.isString() {
       let dateConstructor = try runtime.global().getPropertyAsFunction("Date")
-      let constructed = try dateConstructor.callAsConstructor(value.copy()).asObject()
+      let constructed = try dateConstructor.callAsConstructor(value.copied(in: runtime)).asObject()
       return try dateFromMilliseconds(constructed.callFunction("getTime").asDouble())
     }
-    if value.is("Date") {
-      return try dateFromMilliseconds(value.asObject().callFunction("getTime").asDouble())
+    if value.isObject() {
+      let dateConstructor = try runtime.global().getPropertyAsFunction("Date")
+      let object = value.getObject(in: runtime)
+      if object.instanceOf(dateConstructor) {
+        return try dateFromMilliseconds(object.callFunction("getTime").asDouble())
+      }
     }
     throw InvalidDateException()
   }