Added tracing unit coverage and wired the trait into the Makefile’s unittest target.

- New `Tests/JavaScriptKitTests/JSTracingTests.swift` exercises JS→JS call hooks (ensures method info/method name/args) and JSClosure hooks (verifies file/line metadata and end callbacks) under `#if Tracing`.
- Refactored tracing-overloaded helpers to avoid conditional parameters and added `Sendable` to `JSTracing` to satisfy Swift 6 safety (`Sources/JavaScriptKit/FundamentalObjects/JSObject+CallAsFunction.swift`, `Sources/JavaScriptKit/JSTracing.swift`).
- `make unittest` now enables the `Tracing` trait so tracing hooks compile during test runs (`Makefile`).

I attempted `swift test --traits Tracing`; the build passed the new tracing warnings but the compiler crashed later with an unrelated wasm memory.grow codegen bug, so tests didn’t finish. You can rerun `make unittest SWIFT_SDK_ID=<id>`; expect the same toolchain crash until Swift fixes that issue.

Author: kateinoigakukun

Makefile

@@ -12,6 +12,7 @@ unittest:
 		exit 2; \
 	}
 	env JAVASCRIPTKIT_EXPERIMENTAL_BRIDGEJS=1 swift package --swift-sdk "$(SWIFT_SDK_ID)" \
+	    --traits Tracing \
 	    --disable-sandbox \
 	    js test --prelude ./Tests/prelude.mjs -Xnode --expose-gc
 

Sources/JavaScriptKit/FundamentalObjects/JSObject+CallAsFunction.swift

@@ -132,29 +132,37 @@ extension JSObject {
         return result
     }
 
+    #if Tracing
     final func invokeNonThrowingJSFunction(
         arguments: [JSValue],
-        this: JSObject
-        #if Tracing
-        , tracedMethodName: String? = nil
-        #endif
+        this: JSObject,
+        tracedMethodName: String? = nil
     ) -> RawJSValue {
-        #if Tracing
         let traceEnd = JSTracingHooks.beginJSCall(
             .method(receiver: this, methodName: tracedMethodName, arguments: arguments)
         )
-        #endif
         let result = arguments.withRawJSValues {
             invokeNonThrowingJSFunction(
                 rawValues: $0,
                 this: this
             )
         }
-        #if Tracing
         traceEnd?()
-        #endif
         return result
     }
+    #else
+    final func invokeNonThrowingJSFunction(
+        arguments: [JSValue],
+        this: JSObject
+    ) -> RawJSValue {
+        arguments.withRawJSValues {
+            invokeNonThrowingJSFunction(
+                rawValues: $0,
+                this: this
+            )
+        }
+    }
+    #endif
 
     #if !hasFeature(Embedded)
     final func invokeNonThrowingJSFunction(arguments: [ConvertibleToJSValue]) -> RawJSValue {
@@ -166,25 +174,28 @@ extension JSObject {
         #endif
     }
 
+    #if Tracing
     final func invokeNonThrowingJSFunction(
         arguments: [ConvertibleToJSValue],
-        this: JSObject
-        #if Tracing
-        , tracedMethodName: String? = nil
-        #endif
+        this: JSObject,
+        tracedMethodName: String? = nil
     ) -> RawJSValue {
-        #if Tracing
         let jsValues = arguments.map { $0.jsValue }
         return invokeNonThrowingJSFunction(
             arguments: jsValues,
             this: this,
             tracedMethodName: tracedMethodName
         )
-        #else
+    }
+    #else
+    final func invokeNonThrowingJSFunction(
+        arguments: [ConvertibleToJSValue],
+        this: JSObject
+    ) -> RawJSValue {
         arguments.withRawJSValues { invokeNonThrowingJSFunction(rawValues: $0, this: this) }
-        #endif
     }
     #endif
+    #endif
 
     final private func invokeNonThrowingJSFunction(rawValues: [RawJSValue]) -> RawJSValue {
         rawValues.withUnsafeBufferPointer { [id] bufferPointer in

Sources/JavaScriptKit/JSTracing.swift

@@ -1,7 +1,7 @@
 #if Tracing
 
 /// Hooks for tracing Swift <-> JavaScript bridge calls.
-public struct JSTracing {
+public struct JSTracing: Sendable {
     public static let `default` = JSTracing()
 
     public enum JSCallInfo {

Tests/JavaScriptKitTests/JSTracingTests.swift

@@ -0,0 +1,53 @@
+#if Tracing
+import JavaScriptKit
+import XCTest
+
+final class JSTracingTests: XCTestCase {
+    func testJSCallHookReportsMethod() throws {
+        var startInfo: [JSTracing.JSCallInfo] = []
+        var ended = 0
+        let remove = JSTracing.default.addJSCallHook { info in
+            startInfo.append(info)
+            return { ended += 1 }
+        }
+        defer { remove() }
+
+        let globalObject1 = JSObject.global.globalObject1
+        let prop5 = try XCTUnwrap(globalObject1.prop_5.object)
+        _ = prop5.func6!(true, 1, 2)
+
+        XCTAssertEqual(startInfo.count, 1)
+        guard case let .method(receiver, methodName, arguments) = startInfo.first else {
+            XCTFail("Expected method info")
+            return
+        }
+        XCTAssertEqual(receiver.id, prop5.id)
+        XCTAssertEqual(methodName, "func6")
+        XCTAssertEqual(arguments, [.boolean(true), .number(1), .number(2)])
+        XCTAssertEqual(ended, 1)
+    }
+
+    func testJSClosureCallHookReportsMetadata() throws {
+        var startInfo: [JSTracing.JSClosureCallInfo] = []
+        var ended = 0
+        let remove = JSTracing.default.addJSClosureCallHook { info in
+            startInfo.append(info)
+            return { ended += 1 }
+        }
+        defer { remove() }
+
+        let globalObject1 = JSObject.global.globalObject1
+        let prop6 = try XCTUnwrap(globalObject1.prop_6.object)
+        let closure = JSClosure(file: "TracingTests.swift", line: 4242) { _ in .number(7) }
+        prop6.host_func_1 = .object(closure)
+
+        let callHost = try XCTUnwrap(prop6.call_host_1.function)
+        XCTAssertEqual(callHost(), .number(7))
+
+        XCTAssertEqual(startInfo.count, 1)
+        XCTAssertEqual(startInfo.first?.fileID, "TracingTests.swift")
+        XCTAssertEqual(startInfo.first?.line, 4242)
+        XCTAssertEqual(ended, 1)
+    }
+}
+#endif