BridgeJS: Add JSTypedClosure API

```swift
@JSFunction static func jsApplyInt(
    _ value: Int,
    _ transform: JSTypedClosure<(Int) -> Int>
) throws(JSException) -> Int
```

Author: kateinoigakukun

Package.swift

@@ -9,12 +9,15 @@ let useLegacyResourceBundling =
     Context.environment["JAVASCRIPTKIT_USE_LEGACY_RESOURCE_BUNDLING"].flatMap(Bool.init) ?? false
 
 let testingLinkerFlags: [LinkerSetting] = [
-    .unsafeFlags([
-        "-Xlinker", "--stack-first",
-        "-Xlinker", "--global-base=524288",
-        "-Xlinker", "-z",
-        "-Xlinker", "stack-size=524288",
-    ])
+    .unsafeFlags(
+        [
+            "-Xlinker", "--stack-first",
+            "-Xlinker", "--global-base=524288",
+            "-Xlinker", "-z",
+            "-Xlinker", "stack-size=524288",
+        ],
+        .when(platforms: [.wasi])
+    )
 ]
 
 let package = Package(

Package@swift-6.2.swift

@@ -16,12 +16,15 @@ let tracingTrait = Trait(
 )
 
 let testingLinkerFlags: [LinkerSetting] = [
-    .unsafeFlags([
-        "-Xlinker", "--stack-first",
-        "-Xlinker", "--global-base=524288",
-        "-Xlinker", "-z",
-        "-Xlinker", "stack-size=524288",
-    ])
+    .unsafeFlags(
+        [
+            "-Xlinker", "--stack-first",
+            "-Xlinker", "--global-base=524288",
+            "-Xlinker", "-z",
+            "-Xlinker", "stack-size=524288",
+        ],
+        .when(platforms: [.wasi])
+    )
 ]
 
 let package = Package(

Plugins/BridgeJS/Sources/BridgeJSCore/ClosureCodegen.swift

@@ -32,15 +32,14 @@ public struct ClosureCodegen {
     func renderClosureHelpers(_ signature: ClosureSignature) throws -> [DeclSyntax] {
         let mangledName = signature.mangleName
         let helperName = "_BJS_Closure_\(mangledName)"
-        let boxClassName = "_BJS_ClosureBox_\(mangledName)"
 
         let closureParams = signature.parameters.enumerated().map { _, type in
             "\(type.swiftType)"
         }.joined(separator: ", ")
 
         let swiftEffects = (signature.isAsync ? " async" : "") + (signature.isThrows ? " throws" : "")
         let swiftReturnType = signature.returnType.swiftType
-        let closureType = "(\(closureParams))\(swiftEffects) -> \(swiftReturnType)"
+        let swiftClosureType = "(\(closureParams))\(swiftEffects) -> \(swiftReturnType)"
 
         let externName = "invoke_js_callback_\(signature.moduleName)_\(mangledName)"
 
@@ -69,13 +68,15 @@ public struct ClosureCodegen {
         // Generate extern declaration using CallJSEmission
         let externDecl = builder.renderImportDecl()
 
-        let boxClassDecl: DeclSyntax = """
-            private final class \(raw: boxClassName): _BridgedSwiftClosureBox {
-                let closure: \(raw: closureType)
-                init(_ closure: @escaping \(raw: closureType)) {
-                    self.closure = closure
-                }
+        let makeClosureExternDecl: DeclSyntax = """
+            #if arch(wasm32)
+            @_extern(wasm, module: "bjs", name: "make_swift_closure_\(raw: signature.moduleName)_\(raw: signature.mangleName)")
+            fileprivate func make_swift_closure_\(raw: signature.moduleName)_\(raw: signature.mangleName)(_ boxPtr: UnsafeMutableRawPointer) -> Int32
+            #else
+            fileprivate func make_swift_closure_\(raw: signature.moduleName)_\(raw: signature.mangleName)(_ boxPtr: UnsafeMutableRawPointer) -> Int32 {
+                fatalError("Only available on WebAssembly")
             }
+            #endif
             """
 
         let helperEnumDecl = EnumDeclSyntax(
@@ -84,33 +85,6 @@ public struct ClosureCodegen {
             },
             name: .identifier(helperName),
             memberBlockBuilder: {
-                DeclSyntax(
-                    FunctionDeclSyntax(
-                        modifiers: DeclModifierListSyntax {
-                            DeclModifierSyntax(name: .keyword(.static))
-                        },
-                        name: .identifier("bridgeJSLower"),
-                        signature: FunctionSignatureSyntax(
-                            parameterClause: FunctionParameterClauseSyntax {
-                                FunctionParameterSyntax(
-                                    firstName: .wildcardToken(),
-                                    secondName: .identifier("closure"),
-                                    colon: .colonToken(),
-                                    type: TypeSyntax("@escaping \(raw: closureType)")
-                                )
-                            },
-                            returnClause: ReturnClauseSyntax(
-                                arrow: .arrowToken(),
-                                type: IdentifierTypeSyntax(name: .identifier("UnsafeMutableRawPointer"))
-                            )
-                        ),
-                        body: CodeBlockSyntax {
-                            "let box = \(raw: boxClassName)(closure)"
-                            "return Unmanaged.passRetained(box).toOpaque()"
-                        }
-                    )
-                )
-
                 DeclSyntax(
                     FunctionDeclSyntax(
                         modifiers: DeclModifierListSyntax {
@@ -128,7 +102,7 @@ public struct ClosureCodegen {
                             },
                             returnClause: ReturnClauseSyntax(
                                 arrow: .arrowToken(),
-                                type: IdentifierTypeSyntax(name: .identifier(closureType))
+                                type: IdentifierTypeSyntax(name: .identifier(swiftClosureType))
                             )
                         ),
                         body: CodeBlockSyntax {
@@ -178,11 +152,32 @@ public struct ClosureCodegen {
                 )
             }
         )
-        return [externDecl, boxClassDecl, DeclSyntax(helperEnumDecl)]
+        let typedClosureExtension: DeclSyntax = """
+            extension JSTypedClosure where Signature == \(raw: swiftClosureType) {
+                init(fileID: StaticString = #fileID, line: UInt32 = #line, _ body: @escaping \(raw: swiftClosureType)) {
+                    self.init(
+                        makeClosure: make_swift_closure_\(raw: signature.moduleName)_\(raw: signature.mangleName),
+                        body: body,
+                        fileID: fileID,
+                        line: line
+                    )
+                }
+            }
+            """
+
+        return [
+            externDecl, makeClosureExternDecl, DeclSyntax(helperEnumDecl), typedClosureExtension,
+        ]
     }
 
     func renderClosureInvokeHandler(_ signature: ClosureSignature) throws -> DeclSyntax {
-        let boxClassName = "_BJS_ClosureBox_\(signature.mangleName)"
+        let closureParams = signature.parameters.enumerated().map { _, type in
+            "\(type.swiftType)"
+        }.joined(separator: ", ")
+        let swiftEffects = (signature.isAsync ? " async" : "") + (signature.isThrows ? " throws" : "")
+        let swiftReturnType = signature.returnType.swiftType
+        let swiftClosureType = "(\(closureParams))\(swiftEffects) -> \(swiftReturnType)"
+        let boxType = "_BridgeJSTypedClosureBox<\(swiftClosureType)>"
         let abiName = "invoke_swift_closure_\(signature.moduleName)_\(signature.mangleName)"
 
         // Build ABI parameters directly with WasmCoreType (no string conversion needed)
@@ -205,7 +200,7 @@ public struct ClosureCodegen {
             liftedParams.append("\(paramType.swiftType).bridgeJSLiftParameter(\(argNames.joined(separator: ", ")))")
         }
 
-        let closureCallExpr = ExprSyntax("box.closure(\(raw: liftedParams.joined(separator: ", ")))")
+        let closureCallExpr = ExprSyntax("closure(\(raw: liftedParams.joined(separator: ", ")))")
 
         // Determine return type
         let abiReturnWasmType: WasmCoreType?
@@ -217,6 +212,8 @@ public struct ClosureCodegen {
             abiReturnWasmType = nil
         }
 
+        let throwReturn = abiReturnWasmType?.swiftReturnPlaceholderStmt ?? "return"
+
         // Build signature using SwiftSignatureBuilder
         let funcSignature = SwiftSignatureBuilder.buildABIFunctionSignature(
             abiParameters: abiParams,
@@ -225,7 +222,13 @@ public struct ClosureCodegen {
 
         // Build body
         let body = CodeBlockItemListSyntax {
-            "let box = Unmanaged<\(raw: boxClassName)>.fromOpaque(boxPtr).takeUnretainedValue()"
+            "let box = Unmanaged<\(raw: boxType)>.fromOpaque(boxPtr).takeUnretainedValue()"
+            """
+            guard let closure = box.closure else {
+                box._bridgeJSThrowReleasedClosure()
+                \(raw: throwReturn)
+            }
+            """
             if signature.returnType == .void {
                 closureCallExpr
             } else {
@@ -315,7 +318,7 @@ public struct ClosureCodegen {
                     for setter in type.setters {
                         collectClosureSignatures(from: setter.type, into: &closureSignatures)
                     }
-                    for method in type.methods {
+                    for method in type.methods + type.staticMethods {
                         collectClosureSignatures(from: method.parameters, into: &closureSignatures)
                         collectClosureSignatures(from: method.returnType, into: &closureSignatures)
                     }

Plugins/BridgeJS/Sources/BridgeJSCore/ExportSwift.swift

@@ -364,8 +364,8 @@ public class ExportSwift {
             }
 
             switch returnType {
-            case .closure(let signature):
-                append("return _BJS_Closure_\(raw: signature.mangleName).bridgeJSLower(ret)")
+            case .closure:
+                append("return JSTypedClosure(ret)._bridgeJSLowerReturn()")
             case .array, .nullable(.array, _):
                 let stackCodegen = StackCodegen()
                 for stmt in stackCodegen.lowerStatements(for: returnType, accessor: "ret", varPrefix: "ret") {
@@ -423,14 +423,7 @@ public class ExportSwift {
         }
 
         private func returnPlaceholderStmt() -> String {
-            switch abiReturnType {
-            case .i32: return "return 0"
-            case .i64: return "return 0"
-            case .f32: return "return 0.0"
-            case .f64: return "return 0.0"
-            case .pointer: return "return UnsafeMutableRawPointer(bitPattern: -1).unsafelyUnwrapped"
-            case .none: return "return"
-            }
+            return abiReturnType?.swiftReturnPlaceholderStmt ?? "return"
         }
     }
 
@@ -1756,6 +1749,35 @@ extension BridgeType {
         }
     }
 
+    /// Swift-side parameter type to use when sending a closure into JavaScript (ImportTS).
+    var swiftImportParameterType: String {
+        switch self {
+        case .closure(let signature):
+            let paramTypes = signature.parameters.map { $0.swiftType }.joined(separator: ", ")
+            let effectsStr = (signature.isAsync ? " async" : "") + (signature.isThrows ? " throws" : "")
+            return "JSTypedClosure<(\(paramTypes))\(effectsStr) -> \(signature.returnType.swiftType)>"
+        case .nullable(let wrapped, let kind):
+            if wrapped.isClosureType {
+                let wrappedType = wrapped.swiftImportParameterType
+                switch kind {
+                case .null:
+                    return "Optional<\(wrappedType)>"
+                case .undefined:
+                    return "JSUndefinedOr<\(wrappedType)>"
+                }
+            } else {
+                return swiftType
+            }
+        default:
+            return swiftType
+        }
+    }
+
+    var isClosureType: Bool {
+        if case .closure = self { return true }
+        return false
+    }
+
     struct LiftingIntrinsicInfo: Sendable {
         let parameters: [(name: String, type: WasmCoreType)]
 
@@ -1853,7 +1875,7 @@ extension BridgeType {
         case .namespaceEnum:
             throw BridgeJSCoreError("Namespace enums are not supported to pass as parameters")
         case .closure:
-            return .swiftHeapObject
+            return .jsObject
         case .array, .dictionary:
             return .array
         }

Plugins/BridgeJS/Sources/BridgeJSCore/ImportTS.swift

@@ -97,9 +97,9 @@ public struct ImportTS {
 
             let initializerExpr: ExprSyntax
             switch param.type {
-            case .closure(let signature):
+            case .closure:
                 initializerExpr = ExprSyntax(
-                    "_BJS_Closure_\(raw: signature.mangleName).bridgeJSLower(\(raw: param.name))"
+                    "\(raw: param.name)._bridgeJSLowerParameter()"
                 )
             default:
                 initializerExpr = ExprSyntax("\(raw: param.name).bridgeJSLowerParameter()")
@@ -722,12 +722,12 @@ struct SwiftSignatureBuilder {
     }
 
     /// Builds a parameter type syntax from a BridgeType.
-    ///
-    /// Swift closure parameters must be `@escaping` because they are boxed and can be invoked from JavaScript.
     static func buildParameterTypeSyntax(from type: BridgeType) -> TypeSyntax {
         switch type {
         case .closure:
-            return TypeSyntax("@escaping \(raw: type.swiftType)")
+            return TypeSyntax("\(raw: type.swiftImportParameterType)")
+        case .nullable(let wrapped, _) where wrapped.isClosureType:
+            return TypeSyntax("\(raw: type.swiftImportParameterType)")
         default:
             return buildTypeSyntax(from: type)
         }
@@ -930,8 +930,8 @@ extension BridgeType {
         case .jsValue: return .jsValue
         case .void: return .void
         case .closure:
-            // Swift closure is boxed and passed to JS as a pointer.
-            return LoweringParameterInfo(loweredParameters: [("pointer", .pointer)])
+            // Swift closure is passed to JS as a JS function reference.
+            return LoweringParameterInfo(loweredParameters: [("funcRef", .i32)])
         case .unsafePointer:
             return LoweringParameterInfo(loweredParameters: [("pointer", .pointer)])
         case .swiftHeapObject(let className):

Plugins/BridgeJS/Sources/BridgeJSCore/SwiftToSkeleton.swift

@@ -100,6 +100,17 @@ public final class SwiftToSkeleton {
             return lookupType(for: attributedType.baseType, errors: &errors)
         }
 
+        if let identifierType = type.as(IdentifierTypeSyntax.self),
+            identifierType.name.text == "JSTypedClosure",
+            let genericArgs = identifierType.genericArgumentClause?.arguments,
+            genericArgs.count == 1,
+            let argument = genericArgs.firstAsTypeSyntax,
+            let signatureType = lookupType(for: argument, errors: &errors),
+            case .closure(let signature) = signatureType
+        {
+            return .closure(signature)
+        }
+
         // (T1, T2, ...) -> R
         if let functionType = type.as(FunctionTypeSyntax.self) {
             var parameters: [BridgeType] = []
@@ -2537,3 +2548,18 @@ private final class ImportSwiftMacrosAPICollector: SyntaxAnyVisitor {
         }
     }
 }
+
+extension GenericArgumentListSyntax {
+    /// Compatibility helper for accessing the first argument as a TypeSyntax
+    ///
+    /// Note: SwiftSyntax 601 and later support InlineArrayTypeSyntax and
+    /// ``GenericArgumentSyntax/argument`` is now a ``TypeSyntax`` or ``ExprSyntax``.
+    fileprivate var firstAsTypeSyntax: TypeSyntax? {
+        guard let first = self.first else { return nil }
+        #if canImport(SwiftSyntax601)
+        return first.argument.as(TypeSyntax.self)
+        #else
+        return TypeSyntax(first.argument)
+        #endif
+    }
+}