diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index cf0224346..ef5064fe4 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -21,12 +21,12 @@ jobs:
             target: "wasm32-unknown-wasi"
           - os: ubuntu-22.04
             toolchain:
-              download-url: https://download.swift.org/development/ubuntu2204/swift-DEVELOPMENT-SNAPSHOT-2025-04-12-a/swift-DEVELOPMENT-SNAPSHOT-2025-04-12-a-ubuntu22.04.tar.gz
+              download-url: https://download.swift.org/development/ubuntu2204/swift-DEVELOPMENT-SNAPSHOT-2025-06-12-a/swift-DEVELOPMENT-SNAPSHOT-2025-06-12-a-ubuntu22.04.tar.gz
             wasi-backend: Node
             target: "wasm32-unknown-wasi"
           - os: ubuntu-22.04
             toolchain:
-              download-url: https://download.swift.org/development/ubuntu2204/swift-DEVELOPMENT-SNAPSHOT-2025-04-12-a/swift-DEVELOPMENT-SNAPSHOT-2025-04-12-a-ubuntu22.04.tar.gz
+              download-url: https://download.swift.org/development/ubuntu2204/swift-DEVELOPMENT-SNAPSHOT-2025-06-12-a/swift-DEVELOPMENT-SNAPSHOT-2025-06-12-a-ubuntu22.04.tar.gz
             wasi-backend: Node
             target: "wasm32-unknown-wasip1-threads"
 
@@ -88,3 +88,39 @@ jobs:
             echo "::error::The formatting changed some files. Please run \`./Utilities/format.swift\` and commit the changes."
             exit 1
           }
+  build-examples:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/install-swift
+        with:
+          download-url: https://download.swift.org/development/ubuntu2204/swift-DEVELOPMENT-SNAPSHOT-2025-06-12-a/swift-DEVELOPMENT-SNAPSHOT-2025-06-12-a-ubuntu22.04.tar.gz
+      - uses: swiftwasm/setup-swiftwasm@v2
+        id: setup-wasm32-unknown-wasi
+        with: { target: wasm32-unknown-wasi }
+      - uses: swiftwasm/setup-swiftwasm@v2
+        id: setup-wasm32-unknown-wasip1-threads
+        with: { target: wasm32-unknown-wasip1-threads }
+      - run: ./Utilities/build-examples.sh
+        env:
+          SWIFT_SDK_ID_wasm32_unknown_wasip1_threads: ${{ steps.setup-wasm32-unknown-wasip1-threads.outputs.swift-sdk-id }}
+          SWIFT_SDK_ID_wasm32_unknown_wasi: ${{ steps.setup-wasm32-unknown-wasi.outputs.swift-sdk-id }}
+      - name: Upload static files as artifact
+        id: deployment
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: Examples/
+  deploy-examples:
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    needs: build-examples
+    permissions:
+      pages: write
+      id-token: write
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
diff --git a/Benchmarks/Package.swift b/Benchmarks/Package.swift
index 4d59c772e..751e239e6 100644
--- a/Benchmarks/Package.swift
+++ b/Benchmarks/Package.swift
@@ -4,14 +4,24 @@ import PackageDescription
 
 let package = Package(
     name: "Benchmarks",
+    platforms: [
+        .macOS(.v10_15),
+        .iOS(.v13),
+        .tvOS(.v13),
+        .watchOS(.v6),
+        .macCatalyst(.v13),
+    ],
     dependencies: [
         .package(path: "../")
     ],
     targets: [
         .executableTarget(
             name: "Benchmarks",
-            dependencies: ["JavaScriptKit"],
-            exclude: ["Generated/JavaScript", "bridge.d.ts"],
+            dependencies: [
+                "JavaScriptKit",
+                .product(name: "JavaScriptFoundationCompat", package: "JavaScriptKit"),
+            ],
+            exclude: ["Generated/JavaScript", "bridge-js.d.ts"],
             swiftSettings: [
                 .enableExperimentalFeature("Extern")
             ]
diff --git a/Benchmarks/Sources/Benchmarks.swift b/Benchmarks/Sources/Benchmarks.swift
index 602aa843c..155acae16 100644
--- a/Benchmarks/Sources/Benchmarks.swift
+++ b/Benchmarks/Sources/Benchmarks.swift
@@ -1,4 +1,6 @@
 import JavaScriptKit
+import JavaScriptFoundationCompat
+import Foundation
 
 class Benchmark {
     init(_ title: String) {
@@ -75,4 +77,22 @@ class Benchmark {
             }
         }
     }
+
+    do {
+        let conversion = Benchmark("Conversion")
+        let data = Data(repeating: 0, count: 10_000)
+        conversion.testSuite("Data to JSTypedArray") {
+            for _ in 0..<1_000_000 {
+                _ = data.jsTypedArray
+            }
+        }
+
+        let uint8Array = data.jsTypedArray
+
+        conversion.testSuite("JSTypedArray to Data") {
+            for _ in 0..<1_000_000 {
+                _ = Data.construct(from: uint8Array)
+            }
+        }
+    }
 }
diff --git a/Benchmarks/Sources/Generated/BridgeJS.ExportSwift.swift b/Benchmarks/Sources/Generated/BridgeJS.ExportSwift.swift
new file mode 100644
index 000000000..ee86def78
--- /dev/null
+++ b/Benchmarks/Sources/Generated/BridgeJS.ExportSwift.swift
@@ -0,0 +1,17 @@
+// NOTICE: This is auto-generated code by BridgeJS from JavaScriptKit,
+// DO NOT EDIT.
+//
+// To update this file, just rebuild your project or run
+// `swift package bridge-js`.
+
+@_spi(BridgeJS) import JavaScriptKit
+
+@_expose(wasm, "bjs_run")
+@_cdecl("bjs_run")
+public func _bjs_run() -> Void {
+    #if arch(wasm32)
+    run()
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
\ No newline at end of file
diff --git a/Benchmarks/Sources/Generated/BridgeJS.ImportTS.swift b/Benchmarks/Sources/Generated/BridgeJS.ImportTS.swift
new file mode 100644
index 000000000..871938cfb
--- /dev/null
+++ b/Benchmarks/Sources/Generated/BridgeJS.ImportTS.swift
@@ -0,0 +1,56 @@
+// NOTICE: This is auto-generated code by BridgeJS from JavaScriptKit,
+// DO NOT EDIT.
+//
+// To update this file, just rebuild your project or run
+// `swift package bridge-js`.
+
+@_spi(BridgeJS) import JavaScriptKit
+
+func benchmarkHelperNoop() throws(JSException) -> Void {
+    #if arch(wasm32)
+    @_extern(wasm, module: "Benchmarks", name: "bjs_benchmarkHelperNoop")
+    func bjs_benchmarkHelperNoop() -> Void
+    #else
+    func bjs_benchmarkHelperNoop() -> Void {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
+    bjs_benchmarkHelperNoop()
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
+}
+
+func benchmarkHelperNoopWithNumber(_ n: Double) throws(JSException) -> Void {
+    #if arch(wasm32)
+    @_extern(wasm, module: "Benchmarks", name: "bjs_benchmarkHelperNoopWithNumber")
+    func bjs_benchmarkHelperNoopWithNumber(_ n: Float64) -> Void
+    #else
+    func bjs_benchmarkHelperNoopWithNumber(_ n: Float64) -> Void {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
+    bjs_benchmarkHelperNoopWithNumber(n)
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
+}
+
+func benchmarkRunner(_ name: String, _ body: JSObject) throws(JSException) -> Void {
+    #if arch(wasm32)
+    @_extern(wasm, module: "Benchmarks", name: "bjs_benchmarkRunner")
+    func bjs_benchmarkRunner(_ name: Int32, _ body: Int32) -> Void
+    #else
+    func bjs_benchmarkRunner(_ name: Int32, _ body: Int32) -> Void {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
+    var name = name
+    let nameId = name.withUTF8 { b in
+        _swift_js_make_js_string(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
+    }
+    bjs_benchmarkRunner(nameId, Int32(bitPattern: body.id))
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
+}
\ No newline at end of file
diff --git a/Benchmarks/Sources/Generated/ExportSwift.swift b/Benchmarks/Sources/Generated/ExportSwift.swift
deleted file mode 100644
index a8745b649..000000000
--- a/Benchmarks/Sources/Generated/ExportSwift.swift
+++ /dev/null
@@ -1,15 +0,0 @@
-// NOTICE: This is auto-generated code by BridgeJS from JavaScriptKit,
-// DO NOT EDIT.
-//
-// To update this file, just rebuild your project or run
-// `swift package bridge-js`.
-@_extern(wasm, module: "bjs", name: "return_string")
-private func _return_string(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-@_extern(wasm, module: "bjs", name: "init_memory")
-private func _init_memory(_ sourceId: Int32, _ ptr: UnsafeMutablePointer<UInt8>?)
-
-@_expose(wasm, "bjs_main")
-@_cdecl("bjs_main")
-public func _bjs_main() -> Void {
-    main()
-}
\ No newline at end of file
diff --git a/Benchmarks/Sources/Generated/ImportTS.swift b/Benchmarks/Sources/Generated/ImportTS.swift
deleted file mode 100644
index 583b9ba58..000000000
--- a/Benchmarks/Sources/Generated/ImportTS.swift
+++ /dev/null
@@ -1,38 +0,0 @@
-// NOTICE: This is auto-generated code by BridgeJS from JavaScriptKit,
-// DO NOT EDIT.
-//
-// To update this file, just rebuild your project or run
-// `swift package bridge-js`.
-
-@_spi(JSObject_id) import JavaScriptKit
-
-@_extern(wasm, module: "bjs", name: "make_jsstring")
-private func _make_jsstring(_ ptr: UnsafePointer<UInt8>?, _ len: Int32) -> Int32
-
-@_extern(wasm, module: "bjs", name: "init_memory_with_result")
-private func _init_memory_with_result(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-
-@_extern(wasm, module: "bjs", name: "free_jsobject")
-private func _free_jsobject(_ ptr: Int32) -> Void
-
-func benchmarkHelperNoop() -> Void {
-    @_extern(wasm, module: "Benchmarks", name: "bjs_benchmarkHelperNoop")
-    func bjs_benchmarkHelperNoop() -> Void
-    bjs_benchmarkHelperNoop()
-}
-
-func benchmarkHelperNoopWithNumber(_ n: Double) -> Void {
-    @_extern(wasm, module: "Benchmarks", name: "bjs_benchmarkHelperNoopWithNumber")
-    func bjs_benchmarkHelperNoopWithNumber(_ n: Float64) -> Void
-    bjs_benchmarkHelperNoopWithNumber(n)
-}
-
-func benchmarkRunner(_ name: String, _ body: JSObject) -> Void {
-    @_extern(wasm, module: "Benchmarks", name: "bjs_benchmarkRunner")
-    func bjs_benchmarkRunner(_ name: Int32, _ body: Int32) -> Void
-    var name = name
-    let nameId = name.withUTF8 { b in
-        _make_jsstring(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
-    }
-    bjs_benchmarkRunner(nameId, Int32(bitPattern: body.id))
-}
\ No newline at end of file
diff --git a/Benchmarks/Sources/Generated/JavaScript/ExportSwift.json b/Benchmarks/Sources/Generated/JavaScript/BridgeJS.ExportSwift.json
similarity index 53%
rename from Benchmarks/Sources/Generated/JavaScript/ExportSwift.json
rename to Benchmarks/Sources/Generated/JavaScript/BridgeJS.ExportSwift.json
index 0b1b70b70..f0fd49e51 100644
--- a/Benchmarks/Sources/Generated/JavaScript/ExportSwift.json
+++ b/Benchmarks/Sources/Generated/JavaScript/BridgeJS.ExportSwift.json
@@ -4,8 +4,12 @@
   ],
   "functions" : [
     {
-      "abiName" : "bjs_main",
-      "name" : "main",
+      "abiName" : "bjs_run",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
+      "name" : "run",
       "parameters" : [
 
       ],
diff --git a/Benchmarks/Sources/Generated/JavaScript/ImportTS.json b/Benchmarks/Sources/Generated/JavaScript/BridgeJS.ImportTS.json
similarity index 100%
rename from Benchmarks/Sources/Generated/JavaScript/ImportTS.json
rename to Benchmarks/Sources/Generated/JavaScript/BridgeJS.ImportTS.json
diff --git a/Benchmarks/Sources/bridge-js.config.json b/Benchmarks/Sources/bridge-js.config.json
new file mode 100644
index 000000000..9e26dfeeb
--- /dev/null
+++ b/Benchmarks/Sources/bridge-js.config.json
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/Benchmarks/Sources/bridge.d.ts b/Benchmarks/Sources/bridge-js.d.ts
similarity index 100%
rename from Benchmarks/Sources/bridge.d.ts
rename to Benchmarks/Sources/bridge-js.d.ts
diff --git a/Examples/ActorOnWebWorker/build.sh b/Examples/ActorOnWebWorker/build.sh
index c82a10c32..62b31144c 100755
--- a/Examples/ActorOnWebWorker/build.sh
+++ b/Examples/ActorOnWebWorker/build.sh
@@ -1,3 +1,5 @@
-swift package --swift-sdk "${SWIFT_SDK_ID:-wasm32-unknown-wasip1-threads}" -c release \
+#!/bin/bash
+set -euxo pipefail
+swift package --swift-sdk "${SWIFT_SDK_ID_wasm32_unknown_wasip1_threads:-${SWIFT_SDK_ID:-wasm32-unknown-wasip1-threads}}" -c release \
     plugin --allow-writing-to-package-directory \
     js --use-cdn --output ./Bundle
diff --git a/Examples/Basic/build.sh b/Examples/Basic/build.sh
index 826e90f81..e6e67d93c 100755
--- a/Examples/Basic/build.sh
+++ b/Examples/Basic/build.sh
@@ -1,3 +1,3 @@
 #!/bin/bash
-set -ex
-swift package --swift-sdk "${SWIFT_SDK_ID:-wasm32-unknown-wasi}" -c "${1:-debug}" js --use-cdn
+set -euxo pipefail
+swift package --swift-sdk "${SWIFT_SDK_ID_wasm32_unknown_wasi:-${SWIFT_SDK_ID:-wasm32-unknown-wasi}}" -c "${1:-debug}" js --use-cdn
diff --git a/Examples/Embedded/build.sh b/Examples/Embedded/build.sh
index f807cdbf5..c54193f17 100755
--- a/Examples/Embedded/build.sh
+++ b/Examples/Embedded/build.sh
@@ -1,4 +1,5 @@
 #!/bin/bash
+set -euxo pipefail
 package_dir="$(cd "$(dirname "$0")" && pwd)"
 JAVASCRIPTKIT_EXPERIMENTAL_EMBEDDED_WASM=true \
   swift package --package-path "$package_dir" \
diff --git a/Examples/ImportTS/Sources/bridge.d.ts b/Examples/ImportTS/Sources/bridge-js.d.ts
similarity index 100%
rename from Examples/ImportTS/Sources/bridge.d.ts
rename to Examples/ImportTS/Sources/bridge-js.d.ts
diff --git a/Examples/ImportTS/Sources/main.swift b/Examples/ImportTS/Sources/main.swift
index 4328b0a3b..4853a9665 100644
--- a/Examples/ImportTS/Sources/main.swift
+++ b/Examples/ImportTS/Sources/main.swift
@@ -1,9 +1,9 @@
 import JavaScriptKit
 
 // This function is automatically generated by the @JS plugin
-// It demonstrates how to use TypeScript functions and types imported from bridge.d.ts
+// It demonstrates how to use TypeScript functions and types imported from bridge-js.d.ts
 @JS public func run() {
-    // Call the imported consoleLog function defined in bridge.d.ts
+    // Call the imported consoleLog function defined in bridge-js.d.ts
     consoleLog("Hello, World!")
 
     // Get the document object - this comes from the imported getDocument() function
diff --git a/Examples/Multithreading/build.sh b/Examples/Multithreading/build.sh
index c82a10c32..62b31144c 100755
--- a/Examples/Multithreading/build.sh
+++ b/Examples/Multithreading/build.sh
@@ -1,3 +1,5 @@
-swift package --swift-sdk "${SWIFT_SDK_ID:-wasm32-unknown-wasip1-threads}" -c release \
+#!/bin/bash
+set -euxo pipefail
+swift package --swift-sdk "${SWIFT_SDK_ID_wasm32_unknown_wasip1_threads:-${SWIFT_SDK_ID:-wasm32-unknown-wasip1-threads}}" -c release \
     plugin --allow-writing-to-package-directory \
     js --use-cdn --output ./Bundle
diff --git a/Examples/OffscrenCanvas/build.sh b/Examples/OffscrenCanvas/build.sh
index c82a10c32..62b31144c 100755
--- a/Examples/OffscrenCanvas/build.sh
+++ b/Examples/OffscrenCanvas/build.sh
@@ -1,3 +1,5 @@
-swift package --swift-sdk "${SWIFT_SDK_ID:-wasm32-unknown-wasip1-threads}" -c release \
+#!/bin/bash
+set -euxo pipefail
+swift package --swift-sdk "${SWIFT_SDK_ID_wasm32_unknown_wasip1_threads:-${SWIFT_SDK_ID:-wasm32-unknown-wasip1-threads}}" -c release \
     plugin --allow-writing-to-package-directory \
     js --use-cdn --output ./Bundle
diff --git a/Examples/PlayBridgeJS/Package.swift b/Examples/PlayBridgeJS/Package.swift
new file mode 100644
index 000000000..258518b4e
--- /dev/null
+++ b/Examples/PlayBridgeJS/Package.swift
@@ -0,0 +1,45 @@
+// swift-tools-version:6.0
+
+import PackageDescription
+
+let package = Package(
+    name: "PlayBridgeJS",
+    platforms: [
+        .macOS(.v14)
+    ],
+    dependencies: [
+        .package(name: "JavaScriptKit", path: "../../"),
+        .package(url: "https://github.com/swiftlang/swift-syntax", from: "600.0.1"),
+    ],
+    targets: [
+        .executableTarget(
+            name: "PlayBridgeJS",
+            dependencies: [
+                "JavaScriptKit",
+                .product(name: "JavaScriptEventLoop", package: "JavaScriptKit"),
+                .product(name: "SwiftParser", package: "swift-syntax"),
+                .product(name: "SwiftSyntax", package: "swift-syntax"),
+                .product(name: "SwiftBasicFormat", package: "swift-syntax"),
+                .product(name: "SwiftSyntaxBuilder", package: "swift-syntax"),
+            ],
+            exclude: [
+                "bridge-js.d.ts",
+                "bridge-js.config.json",
+                "Generated/JavaScript",
+            ],
+            swiftSettings: [
+                .enableExperimentalFeature("Extern")
+            ],
+            linkerSettings: [
+                .unsafeFlags(
+                    [
+                        "-Xlinker", "--stack-first",
+                        "-Xlinker", "--global-base=524288",
+                        "-Xlinker", "-z", "-Xlinker", "stack-size=524288",
+                    ],
+                    .when(platforms: [.wasi])
+                )
+            ]
+        )
+    ]
+)
diff --git a/Examples/PlayBridgeJS/README.md b/Examples/PlayBridgeJS/README.md
new file mode 100644
index 000000000..930f07c98
--- /dev/null
+++ b/Examples/PlayBridgeJS/README.md
@@ -0,0 +1,9 @@
+# Playground for BridgeJS example
+
+Install Development Snapshot toolchain `DEVELOPMENT-SNAPSHOT-2024-07-08-a` from [swift.org/install](https://www.swift.org/install/) and run the following commands:
+
+```sh
+$ swift sdk install https://github.com/swiftwasm/swift/releases/download/swift-wasm-DEVELOPMENT-SNAPSHOT-2024-07-09-a/swift-wasm-DEVELOPMENT-SNAPSHOT-2024-07-09-a-wasm32-unknown-wasi.artifactbundle.zip
+$ ./build.sh
+$ npx serve
+```
diff --git a/Examples/PlayBridgeJS/Sources/JavaScript/app.js b/Examples/PlayBridgeJS/Sources/JavaScript/app.js
new file mode 100644
index 000000000..b14db79bf
--- /dev/null
+++ b/Examples/PlayBridgeJS/Sources/JavaScript/app.js
@@ -0,0 +1,165 @@
+// BridgeJS Playground Main Application
+import { EditorSystem } from './editor.js';
+import ts from 'typescript';
+import { TypeProcessor } from './processor.js';
+
+export class BridgeJSPlayground {
+    constructor() {
+        this.editorSystem = new EditorSystem();
+        this.playBridgeJS = null;
+        this.generateTimeout = null;
+        this.isInitialized = false;
+
+        // DOM Elements
+        this.errorDisplay = document.getElementById('errorDisplay');
+        this.errorMessage = document.getElementById('errorMessage');
+    }
+
+    // Initialize the application
+    async initialize() {
+        if (this.isInitialized) {
+            return;
+        }
+
+        try {
+            // Initialize editor system
+            await this.editorSystem.init();
+
+            // Initialize BridgeJS
+            await this.initializeBridgeJS();
+
+            // Set up event listeners
+            this.setupEventListeners();
+
+            // Load sample code
+            this.editorSystem.loadSampleCode();
+
+            this.isInitialized = true;
+            console.log('BridgeJS Playground initialized successfully');
+        } catch (error) {
+            console.error('Failed to initialize BridgeJS Playground:', error);
+            this.showError('Failed to initialize application: ' + error.message);
+        }
+    }
+
+    // Initialize BridgeJS
+    async initializeBridgeJS() {
+        try {
+            // Import the BridgeJS module
+            const { init } = await import("../../.build/plugins/PackageToJS/outputs/Package/index.js");
+            const { exports } = await init({
+                imports: {
+                    createTS2Skeleton: this.createTS2Skeleton
+                }
+            });
+            this.playBridgeJS = new exports.PlayBridgeJS();
+            console.log('BridgeJS initialized successfully');
+        } catch (error) {
+            console.error('Failed to initialize BridgeJS:', error);
+            throw new Error('BridgeJS initialization failed: ' + error.message);
+        }
+    }
+
+    // Set up event listeners
+    setupEventListeners() {
+        // Add change listeners for real-time generation
+        this.editorSystem.addChangeListeners(() => {
+            // Debounce generation to avoid excessive calls
+            if (this.generateTimeout) {
+                clearTimeout(this.generateTimeout);
+            }
+            this.generateTimeout = setTimeout(() => this.generateCode(), 300);
+        });
+    }
+
+    createTS2Skeleton() {
+        return {
+            convert: (dtsCode) => {
+                const virtualFilePath = "bridge-js.d.ts"
+                const virtualHost = {
+                    fileExists: fileName => fileName === virtualFilePath,
+                    readFile: fileName => dtsCode,
+                    getSourceFile: (fileName, languageVersion) => {
+                        const sourceText = dtsCode;
+                        if (sourceText === undefined) return undefined;
+                        return ts.createSourceFile(fileName, sourceText, languageVersion);
+                    },
+                    getDefaultLibFileName: options => "lib.d.ts",
+                    writeFile: (fileName, data) => {
+                        console.log(`[emit] ${fileName}:\n${data}`);
+                    },
+                    getCurrentDirectory: () => "",
+                    getDirectories: () => [],
+                    getCanonicalFileName: fileName => fileName,
+                    getNewLine: () => "\n",
+                    useCaseSensitiveFileNames: () => true
+                }
+                // Create TypeScript program from d.ts content
+                const tsProgram = ts.createProgram({
+                    rootNames: [virtualFilePath],
+                    host: virtualHost,
+                    options: {
+                        noEmit: true,
+                        declaration: true,
+                    }
+                })
+
+                // Create diagnostic engine for error reporting
+                const diagnosticEngine = {
+                    print: (level, message, node) => {
+                        console.log(`[${level}] ${message}`);
+                        if (level === 'error') {
+                            this.showError(`TypeScript Error: ${message}`);
+                        }
+                    }
+                };
+
+                // Process the TypeScript definitions to generate skeleton
+                const processor = new TypeProcessor(tsProgram.getTypeChecker(), diagnosticEngine);
+
+                const skeleton = processor.processTypeDeclarations(tsProgram, virtualFilePath);
+
+                return JSON.stringify(skeleton);
+            }
+        }
+    }
+
+    // Generate code through BridgeJS
+    async generateCode() {
+        if (!this.playBridgeJS) {
+            this.showError('BridgeJS is not initialized');
+            return;
+        }
+
+        try {
+            this.hideError();
+
+            const inputs = this.editorSystem.getInputs();
+            const swiftCode = inputs.swift;
+            const dtsCode = inputs.dts;
+
+            // Process the code and get PlayBridgeJSOutput
+            const result = this.playBridgeJS.update(swiftCode, dtsCode);
+
+            // Update outputs using the PlayBridgeJSOutput object
+            this.editorSystem.updateOutputs(result);
+
+            console.log('Code generated successfully');
+
+        } catch (error) {
+            console.error('Error generating code:', error);
+            this.showError('Error generating code: ' + error.message);
+        }
+    }
+
+    // Show error message
+    showError(message) {
+        this.errorMessage.textContent = message;
+        this.errorDisplay.classList.add('show');
+    }
+
+    // Hide error message
+    hideError() {
+        this.errorDisplay.classList.remove('show');
+    }
+}
\ No newline at end of file
diff --git a/Examples/PlayBridgeJS/Sources/JavaScript/editor.js b/Examples/PlayBridgeJS/Sources/JavaScript/editor.js
new file mode 100644
index 000000000..88a07c431
--- /dev/null
+++ b/Examples/PlayBridgeJS/Sources/JavaScript/editor.js
@@ -0,0 +1,250 @@
+export class EditorSystem {
+    constructor() {
+        this.editors = new Map();
+        this.config = {
+            input: [
+                {
+                    key: 'swift',
+                    id: 'swiftEditor',
+                    language: 'swift',
+                    placeholder: '',
+                    readOnly: false,
+                    modelUri: 'Playground.swift'
+                },
+                {
+                    key: 'dts',
+                    id: 'dtsEditor',
+                    language: 'typescript',
+                    placeholder: '',
+                    readOnly: false,
+                    modelUri: 'bridge-js.d.ts'
+                }
+            ],
+            output: [
+                {
+                    key: 'dts-generated',
+                    id: 'dtsOutput',
+                    language: 'typescript',
+                    placeholder: '// Generated TypeScript will appear here...',
+                    readOnly: true,
+                    modelUri: 'Playground.d.ts'
+                },
+                {
+                    key: 'import-glue',
+                    id: 'importGlueOutput',
+                    language: 'swift',
+                    placeholder: '// Import Swift Glue will appear here...',
+                    readOnly: true,
+                    modelUri: 'ImportTS.swift'
+                },
+                {
+                    key: 'export-glue',
+                    id: 'exportGlueOutput',
+                    language: 'swift',
+                    placeholder: '// Export Swift Glue will appear here...',
+                    readOnly: true,
+                    modelUri: 'ExportTS.swift'
+                },
+                {
+                    key: 'js-generated',
+                    id: 'jsOutput',
+                    language: 'javascript',
+                    placeholder: '// Generated JavaScript will appear here...',
+                    readOnly: true,
+                    modelUri: 'bridge-js.js'
+                }
+            ]
+        };
+        this.activeTabs = {
+            input: this.config.input[0]?.key,
+            output: this.config.output[0]?.key
+        };
+    }
+
+    async init() {
+        await this.loadMonaco();
+        this.createEditors();
+        this.setupTabSystem();
+        this.setupResizeHandling();
+    }
+
+    async loadMonaco() {
+        return new Promise((resolve) => {
+            require.config({ paths: { vs: 'https://unpkg.com/monaco-editor@0.45.0/min/vs' } });
+            require(['vs/editor/editor.main'], resolve);
+        });
+    }
+
+    createEditors() {
+        const commonOptions = {
+            automaticLayout: true,
+            minimap: { enabled: false },
+            scrollBeyondLastLine: false,
+            fontSize: 14,
+            fontFamily: '"SF Mono", Monaco, "Cascadia Code", "Roboto Mono", Consolas, "Courier New", monospace',
+            lineNumbers: 'on',
+            roundedSelection: false,
+            scrollbar: { vertical: 'visible', horizontal: 'visible' },
+            fixedOverflowWidgets: true,
+            renderWhitespace: 'none',
+            wordWrap: 'on'
+        };
+
+        // Create all editors from config
+        [...this.config.input, ...this.config.output].forEach(config => {
+            const element = document.getElementById(config.id);
+            if (!element) {
+                console.warn(`Editor element not found: ${config.id}`);
+                return;
+            }
+
+            const model = monaco.editor.createModel(
+                config.placeholder,
+                config.language,
+                monaco.Uri.parse(config.modelUri)
+            );
+
+            const editor = monaco.editor.create(element, {
+                ...commonOptions,
+                value: config.placeholder,
+                language: config.language,
+                readOnly: config.readOnly,
+                model: model
+            });
+
+            this.editors.set(config.key, editor);
+        });
+    }
+
+    setupTabSystem() {
+        // Setup tab listeners
+        [...this.config.input, ...this.config.output].forEach(config => {
+            const button = document.querySelector(`[data-tab="${config.key}"]`);
+            if (button) {
+                button.addEventListener('click', () => this.switchTab(config.key));
+            }
+        });
+
+        // Initial tab state
+        this.updateTabStates();
+    }
+
+    switchTab(tabKey) {
+        const config = this.getConfigByKey(tabKey);
+        if (!config) return;
+
+        if (this.config.input.some(c => c.key === tabKey)) {
+            this.activeTabs.input = tabKey;
+        } else {
+            this.activeTabs.output = tabKey;
+        }
+
+        this.updateTabStates();
+        this.updateLayout();
+    }
+
+    updateTabStates() {
+        // Update all tab buttons
+        [...this.config.input, ...this.config.output].forEach(config => {
+            const button = document.querySelector(`[data-tab="${config.key}"]`);
+            const content = document.getElementById(`${config.id}Tab`);
+
+            if (button) {
+                const isActive = config.key === this.activeTabs.input || config.key === this.activeTabs.output;
+                button.classList.toggle('active', isActive);
+            }
+
+            if (content) {
+                const isActive = config.key === this.activeTabs.input || config.key === this.activeTabs.output;
+                content.classList.toggle('active', isActive);
+            }
+        });
+    }
+
+    setupResizeHandling() {
+        const layoutEditor = (editor) => {
+            editor.layout({ width: 0, height: 0 });
+            window.requestAnimationFrame(() => {
+                const { width, height } = editor.getContainerDomNode().getBoundingClientRect();
+                editor.layout({ width, height });
+            });
+        };
+
+        window.addEventListener("resize", () => {
+            this.editors.forEach(editor => layoutEditor(editor));
+        });
+    }
+
+    // Data access
+    getInputs() {
+        return {
+            swift: this.editors.get('swift')?.getValue() || '',
+            dts: this.editors.get('dts')?.getValue() || ''
+        };
+    }
+
+    updateOutputs(result) {
+        const outputMap = {
+            'import-glue': () => result.importSwiftGlue(),
+            'export-glue': () => result.exportSwiftGlue(),
+            'js-generated': () => result.outputJs(),
+            'dts-generated': () => result.outputDts()
+        };
+
+        Object.entries(outputMap).forEach(([key, getContent]) => {
+            const editor = this.editors.get(key);
+            if (editor) {
+                const content = getContent();
+                editor.setValue(content || `// No ${key} output generated`);
+            }
+        });
+    }
+
+    loadSampleCode() {
+        const sampleSwift = `import JavaScriptKit
+
+@JS public func calculateTotal(price: Double, quantity: Int) -> Double {
+    return price * Double(quantity)
+}
+
+@JS class ShoppingCart {
+    private var items: [(name: String, price: Double, quantity: Int)] = []
+
+    @JS init() {}
+
+    @JS public func addItem(name: String, price: Double, quantity: Int) {
+        items.append((name, price, quantity))
+    }
+
+    @JS public func getTotal() -> Double {
+        return items.reduce(0) { $0 + $1.price * Double($1.quantity) }
+    }
+}`;
+
+        const sampleDts = `export type Console = {
+    log: (message: string) => void;
+}
+export function console(): Console;`;
+
+        this.editors.get('swift')?.setValue(sampleSwift);
+        this.editors.get('dts')?.setValue(sampleDts);
+    }
+
+    addChangeListeners(callback) {
+        this.config.input.forEach(config => {
+            const editor = this.editors.get(config.key);
+            if (editor) {
+                editor.onDidChangeModelContent(callback);
+            }
+        });
+    }
+
+    // Utility methods
+    getConfigByKey(key) {
+        return [...this.config.input, ...this.config.output].find(c => c.key === key);
+    }
+
+    getActiveTabs() {
+        return this.activeTabs;
+    }
+}
\ No newline at end of file
diff --git a/Examples/PlayBridgeJS/Sources/JavaScript/index.js b/Examples/PlayBridgeJS/Sources/JavaScript/index.js
new file mode 100644
index 000000000..8983c5eb0
--- /dev/null
+++ b/Examples/PlayBridgeJS/Sources/JavaScript/index.js
@@ -0,0 +1,14 @@
+// @ts-check
+import { BridgeJSPlayground } from './app.js';
+
+Error.stackTraceLimit = Infinity;
+
+// Initialize the playground when the page loads
+document.addEventListener('DOMContentLoaded', async () => {
+    try {
+        const playground = new BridgeJSPlayground();
+        await playground.initialize();
+    } catch (error) {
+        console.error('Failed to initialize playground:', error);
+    }
+});
diff --git a/Examples/PlayBridgeJS/Sources/JavaScript/processor.js b/Examples/PlayBridgeJS/Sources/JavaScript/processor.js
new file mode 120000
index 000000000..61c833925
--- /dev/null
+++ b/Examples/PlayBridgeJS/Sources/JavaScript/processor.js
@@ -0,0 +1 @@
+../../../../Plugins/BridgeJS/Sources/TS2Skeleton/JavaScript/src/processor.js
\ No newline at end of file
diff --git a/Examples/PlayBridgeJS/Sources/JavaScript/styles.css b/Examples/PlayBridgeJS/Sources/JavaScript/styles.css
new file mode 100644
index 000000000..a41258c2a
--- /dev/null
+++ b/Examples/PlayBridgeJS/Sources/JavaScript/styles.css
@@ -0,0 +1,269 @@
+:root {
+    --color-fill: rgb(255, 255, 255);
+    --color-fill-secondary: rgb(247, 247, 247);
+    --color-fill-tertiary: rgb(240, 240, 240);
+    --color-fill-blue: rgb(0, 0, 255);
+    --color-fill-gray: rgb(204, 204, 204);
+    --color-fill-gray-secondary: rgb(245, 245, 245);
+    --color-fill-green-secondary: rgb(240, 255, 240);
+    --color-fill-red-secondary: rgb(255, 240, 245);
+
+    --color-figure-blue: rgb(51, 102, 255);
+    --color-figure-gray: rgb(0, 0, 0);
+    --color-figure-gray-secondary: rgb(102, 102, 102);
+    --color-figure-green: rgb(0, 128, 0);
+    --color-figure-red: rgb(255, 0, 0);
+
+    --color-text: var(--color-figure-gray);
+    --color-text-background: var(--color-fill);
+    --color-secondary-label: var(--color-figure-gray-secondary);
+
+    --color-code-background: var(--color-fill-secondary);
+    --color-code-plain: var(--color-figure-gray);
+    --color-code-line-highlight: rgba(51, 102, 255, 0.08);
+    --color-code-line-highlight-border: var(--color-figure-blue);
+
+    --color-button-background: var(--color-fill-blue);
+    --color-button-background-hover: var(--color-figure-blue);
+    --color-button-text: var(--color-fill);
+
+    --color-form-error: var(--color-figure-red);
+    --color-form-error-background: var(--color-fill-red-secondary);
+    --color-form-valid: var(--color-figure-green);
+    --color-form-valid-background: var(--color-fill-green-secondary);
+
+    --color-border: var(--color-fill-gray);
+    --color-border-secondary: var(--color-fill-gray-secondary);
+
+    --color-focus-border-color: var(--color-fill-blue);
+    --color-focus-color: rgba(0, 125, 250, 0.6);
+}
+
+* {
+    box-sizing: border-box;
+}
+
+body {
+    margin: 0;
+    padding: 0;
+    background-color: var(--color-fill);
+    color: var(--color-text);
+    font-family: -apple-system, BlinkMacSystemFont, 'SF Pro Display', 'Segoe UI', Roboto, sans-serif;
+    height: 100vh;
+    overflow: hidden;
+    line-height: 1.5;
+}
+
+.container {
+    height: 100vh;
+    padding: 24px;
+    display: flex;
+    flex-direction: column;
+    max-width: 1400px;
+    margin: 0 auto;
+}
+
+.header {
+    margin-bottom: 32px;
+    text-align: center;
+}
+
+.header h1 {
+    margin: 0 0 8px 0;
+    color: var(--color-text);
+    font-size: 32px;
+    font-weight: 600;
+    letter-spacing: -0.025em;
+}
+
+.header p {
+    margin: 0;
+    color: var(--color-secondary-label);
+    font-size: 16px;
+    font-weight: 400;
+}
+
+.error-display {
+    margin-bottom: 24px;
+    padding: 16px;
+    background-color: var(--color-form-error-background);
+    border: 1px solid var(--color-form-error);
+    border-radius: 8px;
+    display: none;
+    color: var(--color-form-error);
+}
+
+.error-display.show {
+    display: block;
+}
+
+.error-display h3 {
+    margin: 0 0 8px 0;
+    font-size: 16px;
+    font-weight: 600;
+}
+
+.error-display pre {
+    margin: 0;
+    font-family: 'SF Mono', Monaco, 'Cascadia Code', 'Roboto Mono', Consolas, 'Courier New', monospace;
+    font-size: 14px;
+    white-space: pre-wrap;
+    word-break: break-word;
+}
+
+.main-content {
+    flex: 1;
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 24px;
+    min-height: 0;
+}
+
+.section {
+    display: flex;
+    flex-direction: column;
+    background-color: var(--color-fill);
+    border: 1px solid var(--color-border);
+    border-radius: 12px;
+    overflow: hidden;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+}
+
+.section-header {
+    padding: 20px 24px 0 24px;
+    background-color: var(--color-fill-secondary);
+    border-bottom: 1px solid var(--color-border);
+}
+
+.section-header h2 {
+    margin: 0 0 16px 0;
+    font-size: 20px;
+    font-weight: 600;
+    letter-spacing: -0.025em;
+}
+
+.section-header h2.input-title {
+    color: var(--color-text);
+}
+
+.section-header h2.output-title {
+    color: var(--color-text);
+}
+
+.tab-group {
+    display: flex;
+    gap: 0;
+    margin: 0;
+    background-color: var(--color-fill-secondary);
+    border-bottom: 1px solid var(--color-border);
+}
+
+.tab-button {
+    padding: 12px 20px;
+    border: none;
+    background-color: transparent;
+    color: var(--color-secondary-label);
+    cursor: pointer;
+    font-size: 14px;
+    font-weight: 500;
+    transition: all 0.2s ease;
+    position: relative;
+    border-bottom: 2px solid transparent;
+}
+
+.tab-button:hover {
+    background-color: var(--color-fill-tertiary);
+    color: var(--color-text);
+}
+
+.tab-button.active {
+    background-color: var(--color-fill);
+    color: var(--color-text);
+    border-bottom-color: var(--color-figure-blue);
+}
+
+.tab-content {
+    flex: 1;
+    display: none;
+    background-color: var(--color-fill);
+}
+
+.tab-content.active {
+    display: block;
+}
+
+.editor-container {
+    height: 100%;
+    width: 100%;
+    min-height: 400px;
+}
+
+/* Monaco Editor overrides */
+.editor-container .monaco-editor {
+    height: 100%;
+    width: 100%;
+}
+
+.editor-container .monaco-editor .margin {
+    background-color: var(--color-fill-secondary);
+}
+
+.editor-container .monaco-editor .monaco-editor-background {
+    background-color: var(--color-fill);
+}
+
+@media (max-width: 1024px) {
+    .container {
+        padding: 16px;
+    }
+
+    .main-content {
+        gap: 16px;
+    }
+
+    .section-header {
+        padding: 16px 20px 0 20px;
+    }
+
+    .tab-button {
+        padding: 10px 16px;
+        font-size: 13px;
+    }
+}
+
+@media (max-width: 768px) {
+    .main-content {
+        grid-template-columns: 1fr;
+        gap: 16px;
+    }
+
+    .container {
+        padding: 12px;
+    }
+
+    .header h1 {
+        font-size: 24px;
+    }
+
+    .header p {
+        font-size: 14px;
+    }
+
+    .tab-group {
+        flex-wrap: wrap;
+    }
+
+    .tab-button {
+        flex: 1;
+        min-width: 0;
+        text-align: center;
+    }
+
+    .section-header {
+        padding: 12px 16px 0 16px;
+    }
+
+    .section-header h2 {
+        font-size: 18px;
+    }
+}
\ No newline at end of file
diff --git a/Examples/PlayBridgeJS/Sources/PlayBridgeJS/BridgeJSCore b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/BridgeJSCore
new file mode 120000
index 000000000..b99a24254
--- /dev/null
+++ b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/BridgeJSCore
@@ -0,0 +1 @@
+../../../../Plugins/BridgeJS/Sources/BridgeJSCore
\ No newline at end of file
diff --git a/Examples/PlayBridgeJS/Sources/PlayBridgeJS/BridgeJSLink b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/BridgeJSLink
new file mode 120000
index 000000000..89100d66e
--- /dev/null
+++ b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/BridgeJSLink
@@ -0,0 +1 @@
+../../../../Plugins/BridgeJS/Sources/BridgeJSLink
\ No newline at end of file
diff --git a/Examples/PlayBridgeJS/Sources/PlayBridgeJS/BridgeJSSkeleton b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/BridgeJSSkeleton
new file mode 120000
index 000000000..17bd77ac5
--- /dev/null
+++ b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/BridgeJSSkeleton
@@ -0,0 +1 @@
+../../../../Plugins/BridgeJS/Sources/BridgeJSSkeleton
\ No newline at end of file
diff --git a/Examples/PlayBridgeJS/Sources/PlayBridgeJS/Generated/BridgeJS.ExportSwift.swift b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/Generated/BridgeJS.ExportSwift.swift
new file mode 100644
index 000000000..b0656df9d
--- /dev/null
+++ b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/Generated/BridgeJS.ExportSwift.swift
@@ -0,0 +1,115 @@
+// NOTICE: This is auto-generated code by BridgeJS from JavaScriptKit,
+// DO NOT EDIT.
+//
+// To update this file, just rebuild your project or run
+// `swift package bridge-js`.
+
+@_spi(BridgeJS) import JavaScriptKit
+
+@_expose(wasm, "bjs_PlayBridgeJS_init")
+@_cdecl("bjs_PlayBridgeJS_init")
+public func _bjs_PlayBridgeJS_init() -> UnsafeMutableRawPointer {
+    #if arch(wasm32)
+    let ret = PlayBridgeJS()
+    return Unmanaged.passRetained(ret).toOpaque()
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PlayBridgeJS_update")
+@_cdecl("bjs_PlayBridgeJS_update")
+public func _bjs_PlayBridgeJS_update(_self: UnsafeMutableRawPointer, swiftSourceBytes: Int32, swiftSourceLen: Int32, dtsSourceBytes: Int32, dtsSourceLen: Int32) -> UnsafeMutableRawPointer {
+    #if arch(wasm32)
+    do {
+        let swiftSource = String(unsafeUninitializedCapacity: Int(swiftSourceLen)) { b in
+            _swift_js_init_memory(swiftSourceBytes, b.baseAddress.unsafelyUnwrapped)
+            return Int(swiftSourceLen)
+        }
+        let dtsSource = String(unsafeUninitializedCapacity: Int(dtsSourceLen)) { b in
+            _swift_js_init_memory(dtsSourceBytes, b.baseAddress.unsafelyUnwrapped)
+            return Int(dtsSourceLen)
+        }
+        let ret = try Unmanaged<PlayBridgeJS>.fromOpaque(_self).takeUnretainedValue().update(swiftSource: swiftSource, dtsSource: dtsSource)
+        return Unmanaged.passRetained(ret).toOpaque()
+    } catch let error {
+        if let error = error.thrownValue.object {
+            withExtendedLifetime(error) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        } else {
+            let jsError = JSError(message: String(describing: error))
+            withExtendedLifetime(jsError.jsObject) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        }
+        return UnsafeMutableRawPointer(bitPattern: -1).unsafelyUnwrapped
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PlayBridgeJS_deinit")
+@_cdecl("bjs_PlayBridgeJS_deinit")
+public func _bjs_PlayBridgeJS_deinit(pointer: UnsafeMutableRawPointer) {
+    Unmanaged<PlayBridgeJS>.fromOpaque(pointer).release()
+}
+
+@_expose(wasm, "bjs_PlayBridgeJSOutput_outputJs")
+@_cdecl("bjs_PlayBridgeJSOutput_outputJs")
+public func _bjs_PlayBridgeJSOutput_outputJs(_self: UnsafeMutableRawPointer) -> Void {
+    #if arch(wasm32)
+    var ret = Unmanaged<PlayBridgeJSOutput>.fromOpaque(_self).takeUnretainedValue().outputJs()
+    return ret.withUTF8 { ptr in
+        _swift_js_return_string(ptr.baseAddress, Int32(ptr.count))
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PlayBridgeJSOutput_outputDts")
+@_cdecl("bjs_PlayBridgeJSOutput_outputDts")
+public func _bjs_PlayBridgeJSOutput_outputDts(_self: UnsafeMutableRawPointer) -> Void {
+    #if arch(wasm32)
+    var ret = Unmanaged<PlayBridgeJSOutput>.fromOpaque(_self).takeUnretainedValue().outputDts()
+    return ret.withUTF8 { ptr in
+        _swift_js_return_string(ptr.baseAddress, Int32(ptr.count))
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PlayBridgeJSOutput_importSwiftGlue")
+@_cdecl("bjs_PlayBridgeJSOutput_importSwiftGlue")
+public func _bjs_PlayBridgeJSOutput_importSwiftGlue(_self: UnsafeMutableRawPointer) -> Void {
+    #if arch(wasm32)
+    var ret = Unmanaged<PlayBridgeJSOutput>.fromOpaque(_self).takeUnretainedValue().importSwiftGlue()
+    return ret.withUTF8 { ptr in
+        _swift_js_return_string(ptr.baseAddress, Int32(ptr.count))
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PlayBridgeJSOutput_exportSwiftGlue")
+@_cdecl("bjs_PlayBridgeJSOutput_exportSwiftGlue")
+public func _bjs_PlayBridgeJSOutput_exportSwiftGlue(_self: UnsafeMutableRawPointer) -> Void {
+    #if arch(wasm32)
+    var ret = Unmanaged<PlayBridgeJSOutput>.fromOpaque(_self).takeUnretainedValue().exportSwiftGlue()
+    return ret.withUTF8 { ptr in
+        _swift_js_return_string(ptr.baseAddress, Int32(ptr.count))
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_PlayBridgeJSOutput_deinit")
+@_cdecl("bjs_PlayBridgeJSOutput_deinit")
+public func _bjs_PlayBridgeJSOutput_deinit(pointer: UnsafeMutableRawPointer) {
+    Unmanaged<PlayBridgeJSOutput>.fromOpaque(pointer).release()
+}
\ No newline at end of file
diff --git a/Examples/PlayBridgeJS/Sources/PlayBridgeJS/Generated/BridgeJS.ImportTS.swift b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/Generated/BridgeJS.ImportTS.swift
new file mode 100644
index 000000000..5d82db08b
--- /dev/null
+++ b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/Generated/BridgeJS.ImportTS.swift
@@ -0,0 +1,59 @@
+// NOTICE: This is auto-generated code by BridgeJS from JavaScriptKit,
+// DO NOT EDIT.
+//
+// To update this file, just rebuild your project or run
+// `swift package bridge-js`.
+
+@_spi(BridgeJS) import JavaScriptKit
+
+func createTS2Skeleton() throws(JSException) -> TS2Skeleton {
+    #if arch(wasm32)
+    @_extern(wasm, module: "PlayBridgeJS", name: "bjs_createTS2Skeleton")
+    func bjs_createTS2Skeleton() -> Int32
+    #else
+    func bjs_createTS2Skeleton() -> Int32 {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
+    let ret = bjs_createTS2Skeleton()
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
+    return TS2Skeleton(takingThis: ret)
+}
+
+struct TS2Skeleton {
+    let this: JSObject
+
+    init(this: JSObject) {
+        self.this = this
+    }
+
+    init(takingThis this: Int32) {
+        self.this = JSObject(id: UInt32(bitPattern: this))
+    }
+
+    func convert(_ ts: String) throws(JSException) -> String {
+        #if arch(wasm32)
+        @_extern(wasm, module: "PlayBridgeJS", name: "bjs_TS2Skeleton_convert")
+        func bjs_TS2Skeleton_convert(_ self: Int32, _ ts: Int32) -> Int32
+        #else
+        func bjs_TS2Skeleton_convert(_ self: Int32, _ ts: Int32) -> Int32 {
+            fatalError("Only available on WebAssembly")
+        }
+        #endif
+        var ts = ts
+        let tsId = ts.withUTF8 { b in
+            _swift_js_make_js_string(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
+        }
+        let ret = bjs_TS2Skeleton_convert(Int32(bitPattern: self.this.id), tsId)
+        if let error = _swift_js_take_exception() {
+            throw error
+        }
+        return String(unsafeUninitializedCapacity: Int(ret)) { b in
+            _swift_js_init_memory_with_result(b.baseAddress.unsafelyUnwrapped, Int32(ret))
+            return Int(ret)
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/Examples/PlayBridgeJS/Sources/PlayBridgeJS/Generated/JavaScript/BridgeJS.ExportSwift.json b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/Generated/JavaScript/BridgeJS.ExportSwift.json
new file mode 100644
index 000000000..c4d55d27a
--- /dev/null
+++ b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/Generated/JavaScript/BridgeJS.ExportSwift.json
@@ -0,0 +1,124 @@
+{
+  "classes" : [
+    {
+      "constructor" : {
+        "abiName" : "bjs_PlayBridgeJS_init",
+        "effects" : {
+          "isAsync" : false,
+          "isThrows" : false
+        },
+        "parameters" : [
+
+        ]
+      },
+      "methods" : [
+        {
+          "abiName" : "bjs_PlayBridgeJS_update",
+          "effects" : {
+            "isAsync" : false,
+            "isThrows" : true
+          },
+          "name" : "update",
+          "parameters" : [
+            {
+              "label" : "swiftSource",
+              "name" : "swiftSource",
+              "type" : {
+                "string" : {
+
+                }
+              }
+            },
+            {
+              "label" : "dtsSource",
+              "name" : "dtsSource",
+              "type" : {
+                "string" : {
+
+                }
+              }
+            }
+          ],
+          "returnType" : {
+            "swiftHeapObject" : {
+              "_0" : "PlayBridgeJSOutput"
+            }
+          }
+        }
+      ],
+      "name" : "PlayBridgeJS"
+    },
+    {
+      "methods" : [
+        {
+          "abiName" : "bjs_PlayBridgeJSOutput_outputJs",
+          "effects" : {
+            "isAsync" : false,
+            "isThrows" : false
+          },
+          "name" : "outputJs",
+          "parameters" : [
+
+          ],
+          "returnType" : {
+            "string" : {
+
+            }
+          }
+        },
+        {
+          "abiName" : "bjs_PlayBridgeJSOutput_outputDts",
+          "effects" : {
+            "isAsync" : false,
+            "isThrows" : false
+          },
+          "name" : "outputDts",
+          "parameters" : [
+
+          ],
+          "returnType" : {
+            "string" : {
+
+            }
+          }
+        },
+        {
+          "abiName" : "bjs_PlayBridgeJSOutput_importSwiftGlue",
+          "effects" : {
+            "isAsync" : false,
+            "isThrows" : false
+          },
+          "name" : "importSwiftGlue",
+          "parameters" : [
+
+          ],
+          "returnType" : {
+            "string" : {
+
+            }
+          }
+        },
+        {
+          "abiName" : "bjs_PlayBridgeJSOutput_exportSwiftGlue",
+          "effects" : {
+            "isAsync" : false,
+            "isThrows" : false
+          },
+          "name" : "exportSwiftGlue",
+          "parameters" : [
+
+          ],
+          "returnType" : {
+            "string" : {
+
+            }
+          }
+        }
+      ],
+      "name" : "PlayBridgeJSOutput"
+    }
+  ],
+  "functions" : [
+
+  ]
+}
\ No newline at end of file
diff --git a/Examples/PlayBridgeJS/Sources/PlayBridgeJS/Generated/JavaScript/BridgeJS.ImportTS.json b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/Generated/JavaScript/BridgeJS.ImportTS.json
new file mode 100644
index 000000000..f1a567cde
--- /dev/null
+++ b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/Generated/JavaScript/BridgeJS.ImportTS.json
@@ -0,0 +1,48 @@
+{
+  "children" : [
+    {
+      "functions" : [
+        {
+          "name" : "createTS2Skeleton",
+          "parameters" : [
+
+          ],
+          "returnType" : {
+            "jsObject" : {
+              "_0" : "TS2Skeleton"
+            }
+          }
+        }
+      ],
+      "types" : [
+        {
+          "methods" : [
+            {
+              "name" : "convert",
+              "parameters" : [
+                {
+                  "name" : "ts",
+                  "type" : {
+                    "string" : {
+
+                    }
+                  }
+                }
+              ],
+              "returnType" : {
+                "string" : {
+
+                }
+              }
+            }
+          ],
+          "name" : "TS2Skeleton",
+          "properties" : [
+
+          ]
+        }
+      ]
+    }
+  ],
+  "moduleName" : "PlayBridgeJS"
+}
\ No newline at end of file
diff --git a/Examples/PlayBridgeJS/Sources/PlayBridgeJS/bridge-js.config.json b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/bridge-js.config.json
new file mode 100644
index 000000000..e69de29bb
diff --git a/Examples/PlayBridgeJS/Sources/PlayBridgeJS/bridge-js.d.ts b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/bridge-js.d.ts
new file mode 100644
index 000000000..44e79a5cb
--- /dev/null
+++ b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/bridge-js.d.ts
@@ -0,0 +1,5 @@
+export interface TS2Skeleton {
+    convert(ts: string): string;
+}
+
+export function createTS2Skeleton(): TS2Skeleton;
\ No newline at end of file
diff --git a/Examples/PlayBridgeJS/Sources/PlayBridgeJS/main.swift b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/main.swift
new file mode 100644
index 000000000..8f224994c
--- /dev/null
+++ b/Examples/PlayBridgeJS/Sources/PlayBridgeJS/main.swift
@@ -0,0 +1,73 @@
+import JavaScriptEventLoop
+import JavaScriptKit
+import SwiftParser
+import class Foundation.JSONDecoder
+
+@JS class PlayBridgeJS {
+    @JS init() {}
+
+    @JS func update(swiftSource: String, dtsSource: String) throws(JSException) -> PlayBridgeJSOutput {
+        do {
+            return try _update(swiftSource: swiftSource, dtsSource: dtsSource)
+        } catch let error as JSException {
+            throw error
+        } catch {
+            throw JSException(message: String(describing: error))
+        }
+    }
+
+    func _update(swiftSource: String, dtsSource: String) throws -> PlayBridgeJSOutput {
+        let exportSwift = ExportSwift(progress: .silent)
+        let sourceFile = Parser.parse(source: swiftSource)
+        try exportSwift.addSourceFile(sourceFile, "Playground.swift")
+        let exportResult = try exportSwift.finalize()
+        var importTS = ImportTS(progress: .silent, moduleName: "Playground")
+        let ts2skeleton = try createTS2Skeleton()
+        let skeletonJSONString = try ts2skeleton.convert(dtsSource)
+        let decoder = JSONDecoder()
+        let importSkeleton = try decoder.decode(
+            ImportedFileSkeleton.self,
+            from: skeletonJSONString.data(using: .utf8)!
+        )
+        importTS.addSkeleton(importSkeleton)
+        let importSwiftGlue = try importTS.finalize()
+
+        let linker = BridgeJSLink(
+            exportedSkeletons: exportResult.map { [$0.outputSkeleton] } ?? [],
+            importedSkeletons: [
+                ImportedModuleSkeleton(
+                    moduleName: "Playground",
+                    children: [importSkeleton]
+                )
+            ],
+            sharedMemory: false
+        )
+        let linked = try linker.link()
+
+        return PlayBridgeJSOutput(
+            outputJs: linked.outputJs,
+            outputDts: linked.outputDts,
+            importSwiftGlue: importSwiftGlue ?? "",
+            exportSwiftGlue: exportResult?.outputSwift ?? ""
+        )
+    }
+}
+
+@JS class PlayBridgeJSOutput {
+    let _outputJs: String
+    let _outputDts: String
+    let _importSwiftGlue: String
+    let _exportSwiftGlue: String
+
+    init(outputJs: String, outputDts: String, importSwiftGlue: String, exportSwiftGlue: String) {
+        self._outputJs = outputJs
+        self._outputDts = outputDts
+        self._importSwiftGlue = importSwiftGlue
+        self._exportSwiftGlue = exportSwiftGlue
+    }
+
+    @JS func outputJs() -> String { self._outputJs }
+    @JS func outputDts() -> String { self._outputDts }
+    @JS func importSwiftGlue() -> String { self._importSwiftGlue }
+    @JS func exportSwiftGlue() -> String { self._exportSwiftGlue }
+}
diff --git a/Examples/PlayBridgeJS/build.sh b/Examples/PlayBridgeJS/build.sh
new file mode 100755
index 000000000..c4dc8d71f
--- /dev/null
+++ b/Examples/PlayBridgeJS/build.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euxo pipefail
+env JAVASCRIPTKIT_EXPERIMENTAL_BRIDGEJS=1 swift package --swift-sdk "${SWIFT_SDK_ID_wasm32_unknown_wasi:-${SWIFT_SDK_ID:-wasm32-unknown-wasi}}" -c "${1:-debug}" js --use-cdn
diff --git a/Examples/PlayBridgeJS/index.html b/Examples/PlayBridgeJS/index.html
new file mode 100644
index 000000000..21566ee08
--- /dev/null
+++ b/Examples/PlayBridgeJS/index.html
@@ -0,0 +1,90 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>BridgeJS Playground</title>
+
+    <!-- Import Map for TypeScript and processor -->
+    <script type="importmap">
+    {
+        "imports": {
+            "typescript": "https://esm.sh/typescript@5.3.3"
+        }
+    }
+    </script>
+
+    <!-- Monaco Editor CDN -->
+    <script src="https://unpkg.com/monaco-editor@0.45.0/min/vs/loader.js"></script>
+
+    <!-- Custom Styles -->
+    <link rel="stylesheet" href="./Sources/JavaScript/styles.css">
+</head>
+<body>
+    <div class="container">
+        <!-- Header -->
+        <header class="header">
+            <h1>BridgeJS Playground</h1>
+            <p>Interactive playground to preview bridged code generated by BridgeJS</p>
+        </header>
+
+
+
+        <!-- Error Display -->
+        <div id="errorDisplay" class="error-display">
+            <h3>Error</h3>
+            <pre id="errorMessage"></pre>
+        </div>
+
+        <!-- Main Layout -->
+        <div class="main-content">
+            <!-- Input Section -->
+            <div class="section">
+                <div class="section-header">
+                    <h2 class="input-title">Input</h2>
+                </div>
+                <div class="tab-group">
+                    <button class="tab-button active" data-tab="swift">Playground.swift</button>
+                    <button class="tab-button" data-tab="dts">bridge-js.d.ts</button>
+                </div>
+                <div id="swiftEditorTab" class="tab-content active">
+                    <div id="swiftEditor" class="editor-container"></div>
+                </div>
+                <div id="dtsEditorTab" class="tab-content">
+                    <div id="dtsEditor" class="editor-container"></div>
+                </div>
+            </div>
+
+            <!-- Output Section -->
+            <div class="section">
+                <div class="section-header">
+                    <h2 class="output-title">Output</h2>
+                </div>
+                <div class="tab-group">
+                    <button class="tab-button active" data-tab="dts-generated">Playground.d.ts</button>
+                    <button class="tab-button" data-tab="js-generated">Playground.js</button>
+                    <button class="tab-button" data-tab="import-glue">ImportTS.swift</button>
+                    <button class="tab-button" data-tab="export-glue">ExportSwift.swift</button>
+                </div>
+                <div id="importGlueOutputTab" class="tab-content active">
+                    <div id="importGlueOutput" class="editor-container"></div>
+                </div>
+                <div id="exportGlueOutputTab" class="tab-content">
+                    <div id="exportGlueOutput" class="editor-container"></div>
+                </div>
+                <div id="jsOutputTab" class="tab-content">
+                    <div id="jsOutput" class="editor-container"></div>
+                </div>
+                <div id="dtsOutputTab" class="tab-content">
+                    <div id="dtsOutput" class="editor-container"></div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Scripts -->
+    <script type="module" src="./Sources/JavaScript/index.js"></script>
+    <script type="module" src="./Sources/JavaScript/editor.js"></script>
+    <script type="module" src="./Sources/JavaScript/app.js"></script>
+</body>
+</html>
diff --git a/Package.swift b/Package.swift
index 3657bfa99..435ae1a11 100644
--- a/Package.swift
+++ b/Package.swift
@@ -21,6 +21,7 @@ let package = Package(
         .library(name: "JavaScriptKit", targets: ["JavaScriptKit"]),
         .library(name: "JavaScriptEventLoop", targets: ["JavaScriptEventLoop"]),
         .library(name: "JavaScriptBigIntSupport", targets: ["JavaScriptBigIntSupport"]),
+        .library(name: "JavaScriptFoundationCompat", targets: ["JavaScriptFoundationCompat"]),
         .library(name: "JavaScriptEventLoopTestSupport", targets: ["JavaScriptEventLoopTestSupport"]),
         .plugin(name: "PackageToJS", targets: ["PackageToJS"]),
         .plugin(name: "BridgeJS", targets: ["BridgeJS"]),
@@ -39,12 +40,14 @@ let package = Package(
                 ? [
                     .unsafeFlags(["-fdeclspec"])
                 ] : nil,
-            swiftSettings: shouldBuildForEmbedded
-                ? [
-                    .enableExperimentalFeature("Embedded"),
-                    .enableExperimentalFeature("Extern"),
-                    .unsafeFlags(["-Xfrontend", "-emit-empty-object-file"]),
-                ] : nil
+            swiftSettings: [
+                .enableExperimentalFeature("Extern")
+            ]
+                + (shouldBuildForEmbedded
+                    ? [
+                        .enableExperimentalFeature("Embedded"),
+                        .unsafeFlags(["-Xfrontend", "-emit-empty-object-file"]),
+                    ] : [])
         ),
         .target(name: "_CJavaScriptKit"),
         .testTarget(
@@ -106,6 +109,18 @@ let package = Package(
                 "JavaScriptEventLoopTestSupport",
             ]
         ),
+        .target(
+            name: "JavaScriptFoundationCompat",
+            dependencies: [
+                "JavaScriptKit"
+            ]
+        ),
+        .testTarget(
+            name: "JavaScriptFoundationCompatTests",
+            dependencies: [
+                "JavaScriptFoundationCompat"
+            ]
+        ),
         .plugin(
             name: "PackageToJS",
             capability: .command(
@@ -136,12 +151,17 @@ let package = Package(
                 .product(name: "SwiftBasicFormat", package: "swift-syntax"),
                 .product(name: "SwiftSyntaxBuilder", package: "swift-syntax"),
             ],
-            path: "Plugins/BridgeJS/Sources/BridgeJSTool"
+            path: "Plugins/BridgeJS/Sources/BridgeJSTool",
+            exclude: ["TS2Skeleton/JavaScript"]
         ),
         .testTarget(
             name: "BridgeJSRuntimeTests",
             dependencies: ["JavaScriptKit"],
-            exclude: ["Generated/JavaScript"],
+            exclude: [
+                "bridge-js.config.json",
+                "bridge-js.d.ts",
+                "Generated/JavaScript",
+            ],
             swiftSettings: [
                 .enableExperimentalFeature("Extern")
             ]
diff --git a/Plugins/BridgeJS/Package.swift b/Plugins/BridgeJS/Package.swift
index ab8b475cb..f7241d86b 100644
--- a/Plugins/BridgeJS/Package.swift
+++ b/Plugins/BridgeJS/Package.swift
@@ -2,6 +2,13 @@
 
 import PackageDescription
 
+let coreDependencies: [Target.Dependency] = [
+    .product(name: "SwiftParser", package: "swift-syntax"),
+    .product(name: "SwiftSyntax", package: "swift-syntax"),
+    .product(name: "SwiftBasicFormat", package: "swift-syntax"),
+    .product(name: "SwiftSyntaxBuilder", package: "swift-syntax"),
+]
+
 let package = Package(
     name: "BridgeJS",
     platforms: [.macOS(.v13)],
@@ -10,19 +17,13 @@ let package = Package(
     ],
     targets: [
         .target(name: "BridgeJSBuildPlugin"),
-        .target(name: "BridgeJSLink"),
         .executableTarget(
             name: "BridgeJSTool",
-            dependencies: [
-                .product(name: "SwiftParser", package: "swift-syntax"),
-                .product(name: "SwiftSyntax", package: "swift-syntax"),
-                .product(name: "SwiftBasicFormat", package: "swift-syntax"),
-                .product(name: "SwiftSyntaxBuilder", package: "swift-syntax"),
-            ]
+            dependencies: coreDependencies
         ),
         .testTarget(
             name: "BridgeJSToolTests",
-            dependencies: ["BridgeJSTool", "BridgeJSLink"],
+            dependencies: coreDependencies,
             exclude: ["__Snapshots__", "Inputs"]
         ),
     ]
diff --git a/Plugins/BridgeJS/README.md b/Plugins/BridgeJS/README.md
index 9cbd04011..f762c294b 100644
--- a/Plugins/BridgeJS/README.md
+++ b/Plugins/BridgeJS/README.md
@@ -22,7 +22,7 @@ graph LR
         A.swift --> E1[[bridge-js export]]
         B.swift --> E1
         E1 --> G1[ExportSwift.swift]
-        B1[bridge.d.ts]-->I1[[bridge-js import]]
+        B1[bridge-js.d.ts]-->I1[[bridge-js import]]
         I1 --> G2[ImportTS.swift]
     end
     I1 --> G4[ImportTS.json]
@@ -32,7 +32,7 @@ graph LR
         C.swift --> E2[[bridge-js export]]
         D.swift --> E2
         E2 --> G5[ExportSwift.swift]
-        B2[bridge.d.ts]-->I2[[bridge-js import]]
+        B2[bridge-js.d.ts]-->I2[[bridge-js import]]
         I2 --> G6[ImportTS.swift]
     end
     I2 --> G8[ImportTS.json]
@@ -42,8 +42,8 @@ graph LR
     G7 --> L1
     G8 --> L1
 
-    L1 --> F1[bridge.js]
-    L1 --> F2[bridge.d.ts]
+    L1 --> F1[bridge-js.js]
+    L1 --> F2[bridge-js.d.ts]
     ModuleA -----> App[App.wasm]
     ModuleB -----> App
 
@@ -135,3 +135,4 @@ TBD
     declare var Foo: FooConstructor;
     ```
 - [ ] Use `externref` once it's widely available
+- [ ] Test SwiftObject roundtrip
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Sources/BridgeJSBuildPlugin/BridgeJSBuildPlugin.swift b/Plugins/BridgeJS/Sources/BridgeJSBuildPlugin/BridgeJSBuildPlugin.swift
index 4ea725ed5..8353b5c44 100644
--- a/Plugins/BridgeJS/Sources/BridgeJSBuildPlugin/BridgeJSBuildPlugin.swift
+++ b/Plugins/BridgeJS/Sources/BridgeJSBuildPlugin/BridgeJSBuildPlugin.swift
@@ -11,17 +11,32 @@ struct BridgeJSBuildPlugin: BuildToolPlugin {
         guard let swiftSourceModuleTarget = target as? SwiftSourceModuleTarget else {
             return []
         }
-        return try [
-            createExportSwiftCommand(context: context, target: swiftSourceModuleTarget),
-            createImportTSCommand(context: context, target: swiftSourceModuleTarget),
-        ]
+        var commands: [Command] = []
+        commands.append(try createExportSwiftCommand(context: context, target: swiftSourceModuleTarget))
+        if let importCommand = try createImportTSCommand(context: context, target: swiftSourceModuleTarget) {
+            commands.append(importCommand)
+        }
+        return commands
+    }
+
+    private func pathToConfigFile(target: SwiftSourceModuleTarget) -> URL {
+        return target.directoryURL.appending(path: "bridge-js.config.json")
     }
 
     private func createExportSwiftCommand(context: PluginContext, target: SwiftSourceModuleTarget) throws -> Command {
-        let outputSwiftPath = context.pluginWorkDirectoryURL.appending(path: "ExportSwift.swift")
-        let outputSkeletonPath = context.pluginWorkDirectoryURL.appending(path: "ExportSwift.json")
-        let inputFiles = target.sourceFiles.filter { !$0.url.path.hasPrefix(context.pluginWorkDirectoryURL.path + "/") }
-            .map(\.url)
+        let outputSwiftPath = context.pluginWorkDirectoryURL.appending(path: "BridgeJS.ExportSwift.swift")
+        let outputSkeletonPath = context.pluginWorkDirectoryURL.appending(path: "BridgeJS.ExportSwift.json")
+        let inputSwiftFiles = target.sourceFiles.filter {
+            !$0.url.path.hasPrefix(context.pluginWorkDirectoryURL.path + "/")
+        }
+        .map(\.url)
+        let configFile = pathToConfigFile(target: target)
+        let inputFiles: [URL]
+        if FileManager.default.fileExists(atPath: configFile.path) {
+            inputFiles = inputSwiftFiles + [configFile]
+        } else {
+            inputFiles = inputSwiftFiles
+        }
         return .buildCommand(
             displayName: "Export Swift API",
             executable: try context.tool(named: "BridgeJSTool").url,
@@ -31,8 +46,10 @@ struct BridgeJSBuildPlugin: BuildToolPlugin {
                 outputSkeletonPath.path,
                 "--output-swift",
                 outputSwiftPath.path,
+                // Generate the output files even if nothing is exported not to surprise
+                // the build system.
                 "--always-write", "true",
-            ] + inputFiles.map(\.path),
+            ] + inputSwiftFiles.map(\.path),
             inputFiles: inputFiles,
             outputFiles: [
                 outputSwiftPath
@@ -40,12 +57,21 @@ struct BridgeJSBuildPlugin: BuildToolPlugin {
         )
     }
 
-    private func createImportTSCommand(context: PluginContext, target: SwiftSourceModuleTarget) throws -> Command {
-        let outputSwiftPath = context.pluginWorkDirectoryURL.appending(path: "ImportTS.swift")
-        let outputSkeletonPath = context.pluginWorkDirectoryURL.appending(path: "ImportTS.json")
-        let inputFiles = [
-            target.directoryURL.appending(path: "bridge.d.ts")
-        ]
+    private func createImportTSCommand(context: PluginContext, target: SwiftSourceModuleTarget) throws -> Command? {
+        let outputSwiftPath = context.pluginWorkDirectoryURL.appending(path: "BridgeJS.ImportTS.swift")
+        let outputSkeletonPath = context.pluginWorkDirectoryURL.appending(path: "BridgeJS.ImportTS.json")
+        let inputTSFile = target.directoryURL.appending(path: "bridge-js.d.ts")
+        guard FileManager.default.fileExists(atPath: inputTSFile.path) else {
+            return nil
+        }
+
+        let configFile = pathToConfigFile(target: target)
+        let inputFiles: [URL]
+        if FileManager.default.fileExists(atPath: configFile.path) {
+            inputFiles = [inputTSFile, configFile]
+        } else {
+            inputFiles = [inputTSFile]
+        }
         return .buildCommand(
             displayName: "Import TypeScript API",
             executable: try context.tool(named: "BridgeJSTool").url,
@@ -57,10 +83,13 @@ struct BridgeJSBuildPlugin: BuildToolPlugin {
                 outputSwiftPath.path,
                 "--module-name",
                 target.name,
+                // Generate the output files even if nothing is imported not to surprise
+                // the build system.
                 "--always-write", "true",
                 "--project",
                 context.package.directoryURL.appending(path: "tsconfig.json").path,
-            ] + inputFiles.map(\.path),
+                inputTSFile.path,
+            ],
             inputFiles: inputFiles,
             outputFiles: [
                 outputSwiftPath
diff --git a/Plugins/BridgeJS/Sources/BridgeJSCommandPlugin/BridgeJSCommandPlugin.swift b/Plugins/BridgeJS/Sources/BridgeJSCommandPlugin/BridgeJSCommandPlugin.swift
index 286b052d5..88222a0e1 100644
--- a/Plugins/BridgeJS/Sources/BridgeJSCommandPlugin/BridgeJSCommandPlugin.swift
+++ b/Plugins/BridgeJS/Sources/BridgeJSCommandPlugin/BridgeJSCommandPlugin.swift
@@ -12,10 +12,12 @@ struct BridgeJSCommandPlugin: CommandPlugin {
 
     struct Options {
         var targets: [String]
+        var verbose: Bool
 
         static func parse(extractor: inout ArgumentExtractor) -> Options {
             let targets = extractor.extractOption(named: "target")
-            return Options(targets: targets)
+            let verbose = extractor.extractFlag(named: "verbose")
+            return Options(targets: targets, verbose: verbose != 0)
         }
 
         static func help() -> String {
@@ -29,13 +31,13 @@ struct BridgeJSCommandPlugin: CommandPlugin {
                 OPTIONS:
                     --target <target> Specify target(s) to generate bridge code for. If omitted,
                                       generates for all targets with JavaScriptKit dependency.
+                    --verbose Print verbose output.
                 """
         }
     }
 
     func performCommand(context: PluginContext, arguments: [String]) throws {
         // Check for help flags to display usage information
-        // This allows users to run `swift package plugin bridge-js --help` to understand the plugin's functionality
         if arguments.contains(where: { ["-h", "--help"].contains($0) }) {
             printStderr(Options.help())
             return
@@ -45,25 +47,31 @@ struct BridgeJSCommandPlugin: CommandPlugin {
         let options = Options.parse(extractor: &extractor)
         let remainingArguments = extractor.remainingArguments
 
+        let context = Context(options: options, context: context)
+
         if options.targets.isEmpty {
-            try runOnTargets(
-                context: context,
+            try context.runOnTargets(
                 remainingArguments: remainingArguments,
                 where: { target in
                     target.hasDependency(named: Self.JAVASCRIPTKIT_PACKAGE_NAME)
                 }
             )
         } else {
-            try runOnTargets(
-                context: context,
+            try context.runOnTargets(
                 remainingArguments: remainingArguments,
                 where: { options.targets.contains($0.name) }
             )
         }
     }
 
-    private func runOnTargets(
-        context: PluginContext,
+    struct Context {
+        let options: Options
+        let context: PluginContext
+    }
+}
+
+extension BridgeJSCommandPlugin.Context {
+    func runOnTargets(
         remainingArguments: [String],
         where predicate: (SwiftSourceModuleTarget) -> Bool
     ) throws {
@@ -71,57 +79,71 @@ struct BridgeJSCommandPlugin: CommandPlugin {
             guard let target = target as? SwiftSourceModuleTarget else {
                 continue
             }
+            let configFilePath = target.directoryURL.appending(path: "bridge-js.config.json")
+            if !FileManager.default.fileExists(atPath: configFilePath.path) {
+                printVerbose("No bridge-js.config.json found for \(target.name), skipping...")
+                continue
+            }
             guard predicate(target) else {
                 continue
             }
-            try runSingleTarget(context: context, target: target, remainingArguments: remainingArguments)
+            try runSingleTarget(target: target, remainingArguments: remainingArguments)
         }
     }
 
     private func runSingleTarget(
-        context: PluginContext,
         target: SwiftSourceModuleTarget,
         remainingArguments: [String]
     ) throws {
-        Diagnostics.progress("Exporting Swift API for \(target.name)...")
+        printStderr("Generating bridge code for \(target.name)...")
+
+        printVerbose("Exporting Swift API for \(target.name)...")
 
         let generatedDirectory = target.directoryURL.appending(path: "Generated")
         let generatedJavaScriptDirectory = generatedDirectory.appending(path: "JavaScript")
 
         try runBridgeJSTool(
-            context: context,
             arguments: [
                 "export",
                 "--output-skeleton",
-                generatedJavaScriptDirectory.appending(path: "ExportSwift.json").path,
+                generatedJavaScriptDirectory.appending(path: "BridgeJS.ExportSwift.json").path,
                 "--output-swift",
-                generatedDirectory.appending(path: "ExportSwift.swift").path,
+                generatedDirectory.appending(path: "BridgeJS.ExportSwift.swift").path,
+                "--verbose",
+                options.verbose ? "true" : "false",
             ]
                 + target.sourceFiles.filter {
                     !$0.url.path.hasPrefix(generatedDirectory.path + "/")
                 }.map(\.url.path) + remainingArguments
         )
 
-        try runBridgeJSTool(
-            context: context,
-            arguments: [
-                "import",
-                "--output-skeleton",
-                generatedJavaScriptDirectory.appending(path: "ImportTS.json").path,
-                "--output-swift",
-                generatedDirectory.appending(path: "ImportTS.swift").path,
-                "--module-name",
-                target.name,
-                "--project",
-                context.package.directoryURL.appending(path: "tsconfig.json").path,
-                target.directoryURL.appending(path: "bridge.d.ts").path,
-            ] + remainingArguments
-        )
+        printVerbose("Importing TypeScript API for \(target.name)...")
+
+        let bridgeDtsPath = target.directoryURL.appending(path: "bridge-js.d.ts")
+        // Execute import only if bridge-js.d.ts exists
+        if FileManager.default.fileExists(atPath: bridgeDtsPath.path) {
+            try runBridgeJSTool(
+                arguments: [
+                    "import",
+                    "--output-skeleton",
+                    generatedJavaScriptDirectory.appending(path: "BridgeJS.ImportTS.json").path,
+                    "--output-swift",
+                    generatedDirectory.appending(path: "BridgeJS.ImportTS.swift").path,
+                    "--verbose",
+                    options.verbose ? "true" : "false",
+                    "--module-name",
+                    target.name,
+                    "--project",
+                    context.package.directoryURL.appending(path: "tsconfig.json").path,
+                    bridgeDtsPath.path,
+                ] + remainingArguments
+            )
+        }
     }
 
-    private func runBridgeJSTool(context: PluginContext, arguments: [String]) throws {
+    private func runBridgeJSTool(arguments: [String]) throws {
         let tool = try context.tool(named: "BridgeJSTool").url
-        printStderr("$ \(tool.path) \(arguments.joined(separator: " "))")
+        printVerbose("$ \(tool.path) \(arguments.joined(separator: " "))")
         let process = Process()
         process.executableURL = tool
         process.arguments = arguments
@@ -133,6 +155,12 @@ struct BridgeJSCommandPlugin: CommandPlugin {
             exit(process.terminationStatus)
         }
     }
+
+    private func printVerbose(_ message: String) {
+        if options.verbose {
+            printStderr(message)
+        }
+    }
 }
 
 private func printStderr(_ message: String) {
diff --git a/Plugins/BridgeJS/Sources/BridgeJSCore/BridgeJSCoreError.swift b/Plugins/BridgeJS/Sources/BridgeJSCore/BridgeJSCoreError.swift
new file mode 100644
index 000000000..6e3137543
--- /dev/null
+++ b/Plugins/BridgeJS/Sources/BridgeJSCore/BridgeJSCoreError.swift
@@ -0,0 +1,7 @@
+struct BridgeJSCoreError: Swift.Error, CustomStringConvertible {
+    let description: String
+
+    init(_ message: String) {
+        self.description = message
+    }
+}
diff --git a/Plugins/BridgeJS/Sources/BridgeJSTool/DiagnosticError.swift b/Plugins/BridgeJS/Sources/BridgeJSCore/DiagnosticError.swift
similarity index 100%
rename from Plugins/BridgeJS/Sources/BridgeJSTool/DiagnosticError.swift
rename to Plugins/BridgeJS/Sources/BridgeJSCore/DiagnosticError.swift
diff --git a/Plugins/BridgeJS/Sources/BridgeJSTool/ExportSwift.swift b/Plugins/BridgeJS/Sources/BridgeJSCore/ExportSwift.swift
similarity index 72%
rename from Plugins/BridgeJS/Sources/BridgeJSTool/ExportSwift.swift
rename to Plugins/BridgeJS/Sources/BridgeJSCore/ExportSwift.swift
index bef43bbca..fefcf40c2 100644
--- a/Plugins/BridgeJS/Sources/BridgeJSTool/ExportSwift.swift
+++ b/Plugins/BridgeJS/Sources/BridgeJSCore/ExportSwift.swift
@@ -1,7 +1,6 @@
 import SwiftBasicFormat
 import SwiftSyntax
 import SwiftSyntaxBuilder
-import class Foundation.FileManager
 
 /// Exports Swift functions and classes to JavaScript
 ///
@@ -19,7 +18,7 @@ class ExportSwift {
     private var exportedClasses: [ExportedClass] = []
     private var typeDeclResolver: TypeDeclResolver = TypeDeclResolver()
 
-    init(progress: ProgressReporting = ProgressReporting()) {
+    init(progress: ProgressReporting) {
         self.progress = progress
     }
 
@@ -34,7 +33,7 @@ class ExportSwift {
 
         let errors = try parseSingleFile(sourceFile)
         if errors.count > 0 {
-            throw BridgeJSToolError(
+            throw BridgeJSCoreError(
                 errors.map { $0.formattedDescription(fileName: inputFilePath) }
                     .joined(separator: "\n")
             )
@@ -57,7 +56,9 @@ class ExportSwift {
 
     fileprivate final class APICollector: SyntaxAnyVisitor {
         var exportedFunctions: [ExportedFunction] = []
-        var exportedClasses: [String: ExportedClass] = [:]
+        /// The names of the exported classes, in the order they were written in the source file
+        var exportedClassNames: [String] = []
+        var exportedClassByName: [String: ExportedClass] = [:]
         var errors: [DiagnosticError] = []
 
         enum State {
@@ -115,7 +116,7 @@ class ExportSwift {
                 return .skipChildren
             case .classBody(let name):
                 if let exportedFunction = visitFunction(node: node) {
-                    exportedClasses[name]?.methods.append(exportedFunction)
+                    exportedClassByName[name]?.methods.append(exportedFunction)
                 }
                 return .skipChildren
             }
@@ -155,14 +156,43 @@ class ExportSwift {
                 abiName = "bjs_\(className)_\(name)"
             }
 
+            guard let effects = collectEffects(signature: node.signature) else {
+                return nil
+            }
+
             return ExportedFunction(
                 name: name,
                 abiName: abiName,
                 parameters: parameters,
-                returnType: returnType
+                returnType: returnType,
+                effects: effects
             )
         }
 
+        private func collectEffects(signature: FunctionSignatureSyntax) -> Effects? {
+            let isAsync = signature.effectSpecifiers?.asyncSpecifier != nil
+            var isThrows = false
+            if let throwsClause: ThrowsClauseSyntax = signature.effectSpecifiers?.throwsClause {
+                // Limit the thrown type to JSException for now
+                guard let thrownType = throwsClause.type else {
+                    diagnose(
+                        node: throwsClause,
+                        message: "Thrown type is not specified, only JSException is supported for now"
+                    )
+                    return nil
+                }
+                guard thrownType.trimmedDescription == "JSException" else {
+                    diagnose(
+                        node: throwsClause,
+                        message: "Only JSException is supported for thrown type, got \(thrownType.trimmedDescription)"
+                    )
+                    return nil
+                }
+                isThrows = true
+            }
+            return Effects(isAsync: isAsync, isThrows: isThrows)
+        }
+
         override func visit(_ node: InitializerDeclSyntax) -> SyntaxVisitorContinueKind {
             guard node.attributes.hasJSAttribute() else { return .skipChildren }
             guard case .classBody(let name) = state else {
@@ -180,11 +210,16 @@ class ExportSwift {
                 parameters.append(Parameter(label: label, name: name, type: type))
             }
 
+            guard let effects = collectEffects(signature: node.signature) else {
+                return .skipChildren
+            }
+
             let constructor = ExportedConstructor(
                 abiName: "bjs_\(name)_init",
-                parameters: parameters
+                parameters: parameters,
+                effects: effects
             )
-            exportedClasses[name]?.constructor = constructor
+            exportedClassByName[name]?.constructor = constructor
             return .skipChildren
         }
 
@@ -193,11 +228,12 @@ class ExportSwift {
             stateStack.push(state: .classBody(name: name))
 
             guard node.attributes.hasJSAttribute() else { return .skipChildren }
-            exportedClasses[name] = ExportedClass(
+            exportedClassByName[name] = ExportedClass(
                 name: name,
                 constructor: nil,
                 methods: []
             )
+            exportedClassNames.append(name)
             return .visitChildren
         }
         override func visitPost(_ node: ClassDeclSyntax) {
@@ -209,7 +245,11 @@ class ExportSwift {
         let collector = APICollector(parent: self)
         collector.walk(sourceFile)
         exportedFunctions.append(contentsOf: collector.exportedFunctions)
-        exportedClasses.append(contentsOf: collector.exportedClasses.values)
+        exportedClasses.append(
+            contentsOf: collector.exportedClassNames.map {
+                collector.exportedClassByName[$0]!
+            }
+        )
         return collector.errors
     }
 
@@ -221,11 +261,9 @@ class ExportSwift {
             return nil
         }
         guard let typeDecl = typeDeclResolver.lookupType(for: identifier) else {
-            print("Failed to lookup type \(type.trimmedDescription): not found in typeDeclResolver")
             return nil
         }
         guard typeDecl.is(ClassDeclSyntax.self) || typeDecl.is(ActorDeclSyntax.self) else {
-            print("Failed to lookup type \(type.trimmedDescription): is not a class or actor")
             return nil
         }
         return .swiftHeapObject(typeDecl.name.text)
@@ -237,10 +275,8 @@ class ExportSwift {
         //
         // To update this file, just rebuild your project or run
         // `swift package bridge-js`.
-        @_extern(wasm, module: "bjs", name: "return_string")
-        private func _return_string(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-        @_extern(wasm, module: "bjs", name: "init_memory")
-        private func _init_memory(_ sourceId: Int32, _ ptr: UnsafeMutablePointer<UInt8>?)
+
+        @_spi(BridgeJS) import JavaScriptKit
         """
 
     func renderSwiftGlue() -> String? {
@@ -264,6 +300,20 @@ class ExportSwift {
         var abiParameterForwardings: [LabeledExprSyntax] = []
         var abiParameterSignatures: [(name: String, type: WasmCoreType)] = []
         var abiReturnType: WasmCoreType?
+        let effects: Effects
+
+        init(effects: Effects) {
+            self.effects = effects
+        }
+
+        private func append(_ item: CodeBlockItemSyntax) {
+            var item = item
+            // Add a newline for items after the first one
+            if !self.body.isEmpty {
+                item = item.with(\.leadingTrivia, .newline)
+            }
+            self.body.append(item)
+        }
 
         func liftParameter(param: Parameter) {
             switch param.type {
@@ -304,11 +354,11 @@ class ExportSwift {
                 let lengthLabel = "\(param.name)Len"
                 let prepare: CodeBlockItemSyntax = """
                     let \(raw: param.name) = String(unsafeUninitializedCapacity: Int(\(raw: lengthLabel))) { b in
-                        _init_memory(\(raw: bytesLabel), b.baseAddress.unsafelyUnwrapped)
+                        _swift_js_init_memory(\(raw: bytesLabel), b.baseAddress.unsafelyUnwrapped)
                         return Int(\(raw: lengthLabel))
                     }
                     """
-                body.append(prepare)
+                append(prepare)
                 abiParameterForwardings.append(
                     LabeledExprSyntax(
                         label: param.label,
@@ -317,11 +367,19 @@ class ExportSwift {
                 )
                 abiParameterSignatures.append((bytesLabel, .i32))
                 abiParameterSignatures.append((lengthLabel, .i32))
-            case .jsObject:
+            case .jsObject(nil):
                 abiParameterForwardings.append(
                     LabeledExprSyntax(
                         label: param.label,
-                        expression: ExprSyntax("\(raw: param.name)")
+                        expression: ExprSyntax("JSObject(id: UInt32(bitPattern: \(raw: param.name)))")
+                    )
+                )
+                abiParameterSignatures.append((param.name, .i32))
+            case .jsObject(let name):
+                abiParameterForwardings.append(
+                    LabeledExprSyntax(
+                        label: param.label,
+                        expression: ExprSyntax("\(raw: name)(takingThis: UInt32(bitPattern: \(raw: param.name)))")
                     )
                 )
                 abiParameterSignatures.append((param.name, .i32))
@@ -338,82 +396,75 @@ class ExportSwift {
             }
         }
 
-        func call(name: String, returnType: BridgeType) {
+        private func renderCallStatement(callee: ExprSyntax, returnType: BridgeType) -> CodeBlockItemSyntax {
+            var callExpr: ExprSyntax =
+                "\(raw: callee)(\(raw: abiParameterForwardings.map { $0.description }.joined(separator: ", ")))"
+            if effects.isAsync {
+                callExpr = ExprSyntax(AwaitExprSyntax(awaitKeyword: .keyword(.await), expression: callExpr))
+            }
+            if effects.isThrows {
+                callExpr = ExprSyntax(
+                    TryExprSyntax(
+                        tryKeyword: .keyword(.try).with(\.trailingTrivia, .space),
+                        expression: callExpr
+                    )
+                )
+            }
             let retMutability = returnType == .string ? "var" : "let"
-            let callExpr: ExprSyntax =
-                "\(raw: name)(\(raw: abiParameterForwardings.map { $0.description }.joined(separator: ", ")))"
             if returnType == .void {
-                body.append("\(raw: callExpr)")
+                return CodeBlockItemSyntax(item: .init(ExpressionStmtSyntax(expression: callExpr)))
             } else {
-                body.append(
-                    """
-                    \(raw: retMutability) ret = \(raw: callExpr)
-                    """
-                )
+                return CodeBlockItemSyntax(item: .init(DeclSyntax("\(raw: retMutability) ret = \(raw: callExpr)")))
             }
         }
 
+        func call(name: String, returnType: BridgeType) {
+            let item = renderCallStatement(callee: "\(raw: name)", returnType: returnType)
+            append(item)
+        }
+
         func callMethod(klassName: String, methodName: String, returnType: BridgeType) {
             let _selfParam = self.abiParameterForwardings.removeFirst()
-            let retMutability = returnType == .string ? "var" : "let"
-            let callExpr: ExprSyntax =
-                "\(raw: _selfParam).\(raw: methodName)(\(raw: abiParameterForwardings.map { $0.description }.joined(separator: ", ")))"
-            if returnType == .void {
-                body.append("\(raw: callExpr)")
-            } else {
-                body.append(
-                    """
-                    \(raw: retMutability) ret = \(raw: callExpr)
-                    """
-                )
-            }
+            let item = renderCallStatement(
+                callee: "\(raw: _selfParam).\(raw: methodName)",
+                returnType: returnType
+            )
+            append(item)
         }
 
         func lowerReturnValue(returnType: BridgeType) {
-            switch returnType {
-            case .void:
-                abiReturnType = nil
-            case .bool:
-                abiReturnType = .i32
-            case .int:
-                abiReturnType = .i32
-            case .float:
-                abiReturnType = .f32
-            case .double:
-                abiReturnType = .f64
-            case .string:
-                abiReturnType = nil
-            case .jsObject:
-                abiReturnType = .i32
-            case .swiftHeapObject:
-                // UnsafeMutableRawPointer is returned as an i32 pointer
-                abiReturnType = .pointer
-            }
+            abiReturnType = returnType.abiReturnType
 
             switch returnType {
             case .void: break
             case .int, .float, .double:
-                body.append("return \(raw: abiReturnType!.swiftType)(ret)")
+                append("return \(raw: abiReturnType!.swiftType)(ret)")
             case .bool:
-                body.append("return Int32(ret ? 1 : 0)")
+                append("return Int32(ret ? 1 : 0)")
             case .string:
-                body.append(
+                append(
                     """
                     return ret.withUTF8 { ptr in
-                        _return_string(ptr.baseAddress, Int32(ptr.count))
+                        _swift_js_return_string(ptr.baseAddress, Int32(ptr.count))
                     }
                     """
                 )
-            case .jsObject:
-                body.append(
+            case .jsObject(nil):
+                append(
+                    """
+                    return _swift_js_retain(Int32(bitPattern: ret.id))
+                    """
+                )
+            case .jsObject(_?):
+                append(
                     """
-                    return ret.id
+                    return _swift_js_retain(Int32(bitPattern: ret.this.id))
                     """
                 )
             case .swiftHeapObject:
                 // Perform a manual retain on the object, which will be balanced by a
                 // release called via FinalizationRegistry
-                body.append(
+                append(
                     """
                     return Unmanaged.passRetained(ret).toOpaque()
                     """
@@ -422,19 +473,58 @@ class ExportSwift {
         }
 
         func render(abiName: String) -> DeclSyntax {
+            let body: CodeBlockItemListSyntax
+            if effects.isThrows {
+                body = """
+                    do {
+                        \(CodeBlockItemListSyntax(self.body))
+                    } catch let error {
+                        if let error = error.thrownValue.object {
+                            withExtendedLifetime(error) {
+                                _swift_js_throw(Int32(bitPattern: $0.id))
+                            }
+                        } else {
+                            let jsError = JSError(message: String(describing: error))
+                            withExtendedLifetime(jsError.jsObject) {
+                                _swift_js_throw(Int32(bitPattern: $0.id))
+                            }
+                        }
+                        \(raw: returnPlaceholderStmt())
+                    }
+                    """
+            } else {
+                body = CodeBlockItemListSyntax(self.body)
+            }
             return """
                 @_expose(wasm, "\(raw: abiName)")
                 @_cdecl("\(raw: abiName)")
                 public func _\(raw: abiName)(\(raw: parameterSignature())) -> \(raw: returnSignature()) {
-                \(CodeBlockItemListSyntax(body))
+                    #if arch(wasm32)
+                \(body)
+                    #else
+                    fatalError("Only available on WebAssembly")
+                    #endif
                 }
                 """
         }
 
+        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"
+            }
+        }
+
         func parameterSignature() -> String {
-            abiParameterSignatures.map { "\($0.name): \($0.type.swiftType)" }.joined(
-                separator: ", "
-            )
+            var nameAndType: [(name: String, abiType: String)] = []
+            for (name, type) in abiParameterSignatures {
+                nameAndType.append((name, type.swiftType))
+            }
+            return nameAndType.map { "\($0.name): \($0.abiType)" }.joined(separator: ", ")
         }
 
         func returnSignature() -> String {
@@ -443,7 +533,7 @@ class ExportSwift {
     }
 
     func renderSingleExportedFunction(function: ExportedFunction) -> DeclSyntax {
-        let builder = ExportedThunkBuilder()
+        let builder = ExportedThunkBuilder(effects: function.effects)
         for param in function.parameters {
             builder.liftParameter(param: param)
         }
@@ -477,7 +567,7 @@ class ExportSwift {
     /// @_cdecl("bjs_Greeter_init")
     /// public func _bjs_Greeter_init(nameBytes: Int32, nameLen: Int32) -> UnsafeMutableRawPointer {
     ///     let name = String(unsafeUninitializedCapacity: Int(nameLen)) { b in
-    ///         _init_memory(nameBytes, b.baseAddress.unsafelyUnwrapped)
+    ///         _swift_js_init_memory(nameBytes, b.baseAddress.unsafelyUnwrapped)
     ///         return Int(nameLen)
     ///     }
     ///     let ret = Greeter(name: name)
@@ -490,7 +580,7 @@ class ExportSwift {
     ///     let _self = Unmanaged<Greeter>.fromOpaque(pointer).takeUnretainedValue()
     ///     var ret = _self.greet()
     ///     return ret.withUTF8 { ptr in
-    ///         _return_string(ptr.baseAddress, Int32(ptr.count))
+    ///         _swift_js_return_string(ptr.baseAddress, Int32(ptr.count))
     ///     }
     /// }
     /// @_expose(wasm, "bjs_Greeter_deinit")
@@ -502,7 +592,7 @@ class ExportSwift {
     func renderSingleExportedClass(klass: ExportedClass) -> [DeclSyntax] {
         var decls: [DeclSyntax] = []
         if let constructor = klass.constructor {
-            let builder = ExportedThunkBuilder()
+            let builder = ExportedThunkBuilder(effects: constructor.effects)
             for param in constructor.parameters {
                 builder.liftParameter(param: param)
             }
@@ -511,7 +601,7 @@ class ExportSwift {
             decls.append(builder.render(abiName: constructor.abiName))
         }
         for method in klass.methods {
-            let builder = ExportedThunkBuilder()
+            let builder = ExportedThunkBuilder(effects: method.effects)
             builder.liftParameter(
                 param: Parameter(label: nil, name: "_self", type: .swiftHeapObject(klass.name))
             )
@@ -564,6 +654,10 @@ extension BridgeType {
             self = .string
         case "Bool":
             self = .bool
+        case "Void":
+            self = .void
+        case "JSObject":
+            self = .jsObject(nil)
         default:
             return nil
         }
diff --git a/Plugins/BridgeJS/Sources/BridgeJSTool/ImportTS.swift b/Plugins/BridgeJS/Sources/BridgeJSCore/ImportTS.swift
similarity index 76%
rename from Plugins/BridgeJS/Sources/BridgeJSTool/ImportTS.swift
rename to Plugins/BridgeJS/Sources/BridgeJSCore/ImportTS.swift
index a97550bd1..371811141 100644
--- a/Plugins/BridgeJS/Sources/BridgeJSTool/ImportTS.swift
+++ b/Plugins/BridgeJS/Sources/BridgeJSCore/ImportTS.swift
@@ -1,7 +1,6 @@
 import SwiftBasicFormat
 import SwiftSyntax
 import SwiftSyntaxBuilder
-import Foundation
 
 /// Imports TypeScript declarations and generates Swift bridge code
 ///
@@ -28,46 +27,6 @@ struct ImportTS {
         self.skeleton.children.append(skeleton)
     }
 
-    /// Processes a TypeScript definition file and extracts its API information
-    mutating func addSourceFile(_ sourceFile: String, tsconfigPath: String) throws {
-        let nodePath = try which("node")
-        let ts2skeletonPath = URL(fileURLWithPath: #filePath)
-            .deletingLastPathComponent()
-            .deletingLastPathComponent()
-            .appendingPathComponent("JavaScript")
-            .appendingPathComponent("bin")
-            .appendingPathComponent("ts2skeleton.js")
-        let arguments = [ts2skeletonPath.path, sourceFile, "--project", tsconfigPath]
-
-        progress.print("Running ts2skeleton...")
-        progress.print("  \(([nodePath.path] + arguments).joined(separator: " "))")
-
-        let process = Process()
-        let stdoutPipe = Pipe()
-        nonisolated(unsafe) var stdoutData = Data()
-
-        process.executableURL = nodePath
-        process.arguments = arguments
-        process.standardOutput = stdoutPipe
-
-        stdoutPipe.fileHandleForReading.readabilityHandler = { handle in
-            let data = handle.availableData
-            if data.count > 0 {
-                stdoutData.append(data)
-            }
-        }
-        try process.forwardTerminationSignals {
-            try process.run()
-            process.waitUntilExit()
-        }
-
-        if process.terminationStatus != 0 {
-            throw BridgeJSToolError("ts2skeleton returned \(process.terminationStatus)")
-        }
-        let skeleton = try JSONDecoder().decode(ImportedFileSkeleton.self, from: stdoutData)
-        self.addSkeleton(skeleton)
-    }
-
     /// Finalizes the import process and generates Swift code
     func finalize() throws -> String? {
         var decls: [DeclSyntax] = []
@@ -150,7 +109,7 @@ struct ImportTS {
                 body.append(
                     """
                     let \(raw: stringIdName) = \(raw: param.name).withUTF8 { b in
-                        _make_jsstring(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
+                        _swift_js_make_js_string(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
                     }
                     """
                 )
@@ -178,7 +137,7 @@ struct ImportTS {
                 )
                 abiParameterSignatures.append((param.name, .i32))
             case .swiftHeapObject(_):
-                throw BridgeJSToolError("swiftHeapObject is not supported in imported signatures")
+                throw BridgeJSCoreError("swiftHeapObject is not supported in imported signatures")
             case .void:
                 break
             }
@@ -192,6 +151,7 @@ struct ImportTS {
             } else {
                 body.append("let ret = \(raw: call)")
             }
+            body.append("if let error = _swift_js_take_exception() { throw error }")
         }
 
         func liftReturnValue(returnType: BridgeType) throws {
@@ -213,7 +173,7 @@ struct ImportTS {
                 body.append(
                     """
                     return String(unsafeUninitializedCapacity: Int(ret)) { b in
-                        _init_memory_with_result(b.baseAddress.unsafelyUnwrapped, Int32(ret))
+                        _swift_js_init_memory_with_result(b.baseAddress.unsafelyUnwrapped, Int32(ret))
                         return Int(ret)
                     }
                     """
@@ -226,7 +186,7 @@ struct ImportTS {
                     body.append("return JSObject(id: UInt32(bitPattern: ret))")
                 }
             case .swiftHeapObject(_):
-                throw BridgeJSToolError("swiftHeapObject is not supported in imported signatures")
+                throw BridgeJSCoreError("swiftHeapObject is not supported in imported signatures")
             case .void:
                 break
             }
@@ -237,33 +197,46 @@ struct ImportTS {
                 preconditionFailure("assignThis can only be called with a jsObject return type")
             }
             abiReturnType = .i32
-            body.append("self.this = ret")
+            body.append("self.this = JSObject(id: UInt32(bitPattern: ret))")
         }
 
         func renderImportDecl() -> DeclSyntax {
-            return DeclSyntax(
-                FunctionDeclSyntax(
-                    attributes: AttributeListSyntax(itemsBuilder: {
-                        "@_extern(wasm, module: \"\(raw: moduleName)\", name: \"\(raw: abiName)\")"
-                    }).with(\.trailingTrivia, .newline),
-                    name: .identifier(abiName),
-                    signature: FunctionSignatureSyntax(
-                        parameterClause: FunctionParameterClauseSyntax(parametersBuilder: {
-                            for param in abiParameterSignatures {
-                                FunctionParameterSyntax(
-                                    firstName: .wildcardToken(),
-                                    secondName: .identifier(param.name),
-                                    type: IdentifierTypeSyntax(name: .identifier(param.type.swiftType))
-                                )
-                            }
-                        }),
-                        returnClause: ReturnClauseSyntax(
-                            arrow: .arrowToken(),
-                            type: IdentifierTypeSyntax(name: .identifier(abiReturnType.map { $0.swiftType } ?? "Void"))
-                        )
+            let baseDecl = FunctionDeclSyntax(
+                funcKeyword: .keyword(.func).with(\.trailingTrivia, .space),
+                name: .identifier(abiName),
+                signature: FunctionSignatureSyntax(
+                    parameterClause: FunctionParameterClauseSyntax(parametersBuilder: {
+                        for param in abiParameterSignatures {
+                            FunctionParameterSyntax(
+                                firstName: .wildcardToken().with(\.trailingTrivia, .space),
+                                secondName: .identifier(param.name),
+                                type: IdentifierTypeSyntax(name: .identifier(param.type.swiftType))
+                            )
+                        }
+                    }),
+                    returnClause: ReturnClauseSyntax(
+                        arrow: .arrowToken(),
+                        type: IdentifierTypeSyntax(name: .identifier(abiReturnType.map { $0.swiftType } ?? "Void"))
                     )
                 )
             )
+            var externDecl = baseDecl
+            externDecl.attributes = AttributeListSyntax(itemsBuilder: {
+                "@_extern(wasm, module: \"\(raw: moduleName)\", name: \"\(raw: abiName)\")"
+            }).with(\.trailingTrivia, .newline)
+            var stubDecl = baseDecl
+            stubDecl.body = CodeBlockSyntax {
+                """
+                fatalError("Only available on WebAssembly")
+                """
+            }
+            return """
+                #if arch(wasm32)
+                \(externDecl)
+                #else
+                \(stubDecl)
+                #endif
+                """
         }
 
         func renderThunkDecl(name: String, parameters: [Parameter], returnType: BridgeType) -> DeclSyntax {
@@ -281,6 +254,7 @@ struct ImportTS {
                                 )
                             }
                         }),
+                        effectSpecifiers: ImportTS.buildFunctionEffect(throws: true, async: false),
                         returnClause: ReturnClauseSyntax(
                             arrow: .arrowToken(),
                             type: IdentifierTypeSyntax(name: .identifier(returnType.swiftType))
@@ -308,7 +282,8 @@ struct ImportTS {
                                     )
                                 }
                             }
-                        )
+                        ),
+                        effectSpecifiers: ImportTS.buildFunctionEffect(throws: true, async: false)
                     ),
                     bodyBuilder: {
                         self.renderImportDecl()
@@ -326,16 +301,7 @@ struct ImportTS {
         // To update this file, just rebuild your project or run
         // `swift package bridge-js`.
 
-        @_spi(JSObject_id) import JavaScriptKit
-
-        @_extern(wasm, module: "bjs", name: "make_jsstring")
-        private func _make_jsstring(_ ptr: UnsafePointer<UInt8>?, _ len: Int32) -> Int32
-
-        @_extern(wasm, module: "bjs", name: "init_memory_with_result")
-        private func _init_memory_with_result(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-
-        @_extern(wasm, module: "bjs", name: "free_jsobject")
-        private func _free_jsobject(_ ptr: Int32) -> Void
+        @_spi(BridgeJS) import JavaScriptKit
         """
 
     func renderSwiftThunk(
@@ -401,6 +367,7 @@ struct ImportTS {
             try builder.liftReturnValue(returnType: property.type)
             return AccessorDeclSyntax(
                 accessorSpecifier: .keyword(.get),
+                effectSpecifiers: Self.buildAccessorEffect(throws: true, async: false),
                 body: CodeBlockSyntax {
                     builder.renderImportDecl()
                     builder.body
@@ -408,31 +375,25 @@ struct ImportTS {
             )
         }
 
-        func renderSetterDecl(property: ImportedPropertySkeleton) throws -> AccessorDeclSyntax {
+        func renderSetterDecl(property: ImportedPropertySkeleton) throws -> DeclSyntax {
             let builder = ImportedThunkBuilder(
                 moduleName: moduleName,
                 abiName: property.setterAbiName(context: type)
             )
+            let newValue = Parameter(label: nil, name: "newValue", type: property.type)
             try builder.lowerParameter(param: Parameter(label: nil, name: "self", type: .jsObject(name)))
-            try builder.lowerParameter(param: Parameter(label: nil, name: "newValue", type: property.type))
+            try builder.lowerParameter(param: newValue)
             builder.call(returnType: .void)
-            return AccessorDeclSyntax(
-                modifier: DeclModifierSyntax(name: .keyword(.nonmutating)),
-                accessorSpecifier: .keyword(.set),
-                body: CodeBlockSyntax {
-                    builder.renderImportDecl()
-                    builder.body
-                }
+            return builder.renderThunkDecl(
+                name: "set\(property.name.capitalizedFirstLetter())",
+                parameters: [newValue],
+                returnType: .void
             )
         }
 
         func renderPropertyDecl(property: ImportedPropertySkeleton) throws -> [DeclSyntax] {
-            var accessorDecls: [AccessorDeclSyntax] = []
-            accessorDecls.append(try renderGetterDecl(property: property))
-            if !property.isReadonly {
-                accessorDecls.append(try renderSetterDecl(property: property))
-            }
-            return [
+            let accessorDecls: [AccessorDeclSyntax] = [try renderGetterDecl(property: property)]
+            var decls: [DeclSyntax] = [
                 DeclSyntax(
                     VariableDeclSyntax(
                         leadingTrivia: Self.renderDocumentation(documentation: property.documentation),
@@ -455,6 +416,10 @@ struct ImportTS {
                     )
                 )
             ]
+            if !property.isReadonly {
+                decls.append(try renderSetterDecl(property: property))
+            }
+            return decls
         }
         let classDecl = try StructDeclSyntax(
             leadingTrivia: Self.renderDocumentation(documentation: type.documentation),
@@ -506,30 +471,36 @@ struct ImportTS {
         let lines = documentation.split { $0.isNewline }
         return Trivia(pieces: lines.flatMap { [TriviaPiece.docLineComment("/// \($0)"), .newlines(1)] })
     }
-}
 
-extension Foundation.Process {
-    // Monitor termination/interrruption signals to forward them to child process
-    func setSignalForwarding(_ signalNo: Int32) -> DispatchSourceSignal {
-        let signalSource = DispatchSource.makeSignalSource(signal: signalNo)
-        signalSource.setEventHandler { [self] in
-            signalSource.cancel()
-            kill(processIdentifier, signalNo)
-        }
-        signalSource.resume()
-        return signalSource
+    static func buildFunctionEffect(throws: Bool, async: Bool) -> FunctionEffectSpecifiersSyntax {
+        return FunctionEffectSpecifiersSyntax(
+            asyncSpecifier: `async` ? .keyword(.async) : nil,
+            throwsClause: `throws`
+                ? ThrowsClauseSyntax(
+                    throwsSpecifier: .keyword(.throws),
+                    leftParen: .leftParenToken(),
+                    type: IdentifierTypeSyntax(name: .identifier("JSException")),
+                    rightParen: .rightParenToken()
+                ) : nil
+        )
     }
+    static func buildAccessorEffect(throws: Bool, async: Bool) -> AccessorEffectSpecifiersSyntax {
+        return AccessorEffectSpecifiersSyntax(
+            asyncSpecifier: `async` ? .keyword(.async) : nil,
+            throwsClause: `throws`
+                ? ThrowsClauseSyntax(
+                    throwsSpecifier: .keyword(.throws),
+                    leftParen: .leftParenToken(),
+                    type: IdentifierTypeSyntax(name: .identifier("JSException")),
+                    rightParen: .rightParenToken()
+                ) : nil
+        )
+    }
+}
 
-    func forwardTerminationSignals(_ body: () throws -> Void) rethrows {
-        let sources = [
-            setSignalForwarding(SIGINT),
-            setSignalForwarding(SIGTERM),
-        ]
-        defer {
-            for source in sources {
-                source.cancel()
-            }
-        }
-        try body()
+extension String {
+    func capitalizedFirstLetter() -> String {
+        guard !isEmpty else { return self }
+        return prefix(1).uppercased() + dropFirst()
     }
 }
diff --git a/Plugins/BridgeJS/Sources/BridgeJSCore/ProgressReporting.swift b/Plugins/BridgeJS/Sources/BridgeJSCore/ProgressReporting.swift
new file mode 100644
index 000000000..4e92a198b
--- /dev/null
+++ b/Plugins/BridgeJS/Sources/BridgeJSCore/ProgressReporting.swift
@@ -0,0 +1,19 @@
+struct ProgressReporting {
+    let print: (String) -> Void
+
+    init(verbose: Bool) {
+        self.init(print: verbose ? { Swift.print($0) } : { _ in })
+    }
+
+    private init(print: @escaping (String) -> Void) {
+        self.print = print
+    }
+
+    static var silent: ProgressReporting {
+        return ProgressReporting(print: { _ in })
+    }
+
+    func print(_ message: String) {
+        self.print(message)
+    }
+}
diff --git a/Plugins/BridgeJS/Sources/BridgeJSTool/TypeDeclResolver.swift b/Plugins/BridgeJS/Sources/BridgeJSCore/TypeDeclResolver.swift
similarity index 100%
rename from Plugins/BridgeJS/Sources/BridgeJSTool/TypeDeclResolver.swift
rename to Plugins/BridgeJS/Sources/BridgeJSCore/TypeDeclResolver.swift
diff --git a/Plugins/BridgeJS/Sources/BridgeJSLink/BridgeJSLink.swift b/Plugins/BridgeJS/Sources/BridgeJSLink/BridgeJSLink.swift
index e62a9a639..4d9ba5960 100644
--- a/Plugins/BridgeJS/Sources/BridgeJSLink/BridgeJSLink.swift
+++ b/Plugins/BridgeJS/Sources/BridgeJSLink/BridgeJSLink.swift
@@ -1,9 +1,21 @@
-import Foundation
+import class Foundation.JSONDecoder
+import struct Foundation.Data
 
 struct BridgeJSLink {
     /// The exported skeletons
     var exportedSkeletons: [ExportedSkeleton] = []
     var importedSkeletons: [ImportedModuleSkeleton] = []
+    let sharedMemory: Bool
+
+    init(
+        exportedSkeletons: [ExportedSkeleton] = [],
+        importedSkeletons: [ImportedModuleSkeleton] = [],
+        sharedMemory: Bool
+    ) {
+        self.exportedSkeletons = exportedSkeletons
+        self.importedSkeletons = importedSkeletons
+        self.sharedMemory = sharedMemory
+    }
 
     mutating func addExportedSkeletonFile(data: Data) throws {
         let skeleton = try JSONDecoder().decode(ExportedSkeleton.self, from: data)
@@ -47,10 +59,8 @@ struct BridgeJSLink {
 
     func link() throws -> (outputJs: String, outputDts: String) {
         var exportsLines: [String] = []
-        var importedLines: [String] = []
         var classLines: [String] = []
         var dtsExportLines: [String] = []
-        var dtsImportLines: [String] = []
         var dtsClassLines: [String] = []
 
         if exportedSkeletons.contains(where: { $0.classes.count > 0 }) {
@@ -84,57 +94,18 @@ struct BridgeJSLink {
             }
         }
 
+        var importObjectBuilders: [ImportObjectBuilder] = []
         for skeletonSet in importedSkeletons {
-            importedLines.append("const \(skeletonSet.moduleName) = importObject[\"\(skeletonSet.moduleName)\"] = {};")
-            func assignToImportObject(name: String, function: [String]) {
-                var js = function
-                js[0] = "\(skeletonSet.moduleName)[\"\(name)\"] = " + js[0]
-                importedLines.append(contentsOf: js)
-            }
+            let importObjectBuilder = ImportObjectBuilder(moduleName: skeletonSet.moduleName)
             for fileSkeleton in skeletonSet.children {
                 for function in fileSkeleton.functions {
-                    let (js, dts) = try renderImportedFunction(function: function)
-                    assignToImportObject(name: function.abiName(context: nil), function: js)
-                    dtsImportLines.append(contentsOf: dts)
+                    try renderImportedFunction(importObjectBuilder: importObjectBuilder, function: function)
                 }
                 for type in fileSkeleton.types {
-                    for property in type.properties {
-                        let getterAbiName = property.getterAbiName(context: type)
-                        let (js, dts) = try renderImportedProperty(
-                            property: property,
-                            abiName: getterAbiName,
-                            emitCall: { thunkBuilder in
-                                thunkBuilder.callPropertyGetter(name: property.name, returnType: property.type)
-                                return try thunkBuilder.lowerReturnValue(returnType: property.type)
-                            }
-                        )
-                        assignToImportObject(name: getterAbiName, function: js)
-                        dtsImportLines.append(contentsOf: dts)
-
-                        if !property.isReadonly {
-                            let setterAbiName = property.setterAbiName(context: type)
-                            let (js, dts) = try renderImportedProperty(
-                                property: property,
-                                abiName: setterAbiName,
-                                emitCall: { thunkBuilder in
-                                    thunkBuilder.liftParameter(
-                                        param: Parameter(label: nil, name: "newValue", type: property.type)
-                                    )
-                                    thunkBuilder.callPropertySetter(name: property.name, returnType: property.type)
-                                    return nil
-                                }
-                            )
-                            assignToImportObject(name: setterAbiName, function: js)
-                            dtsImportLines.append(contentsOf: dts)
-                        }
-                    }
-                    for method in type.methods {
-                        let (js, dts) = try renderImportedMethod(context: type, method: method)
-                        assignToImportObject(name: method.abiName(context: type), function: js)
-                        dtsImportLines.append(contentsOf: dts)
-                    }
+                    try renderImportedType(importObjectBuilder: importObjectBuilder, type: type)
                 }
             }
+            importObjectBuilders.append(importObjectBuilder)
         }
 
         let outputJs = """
@@ -147,39 +118,53 @@ struct BridgeJSLink {
             export async function createInstantiator(options, swift) {
                 let instance;
                 let memory;
+                let setException;
                 const textDecoder = new TextDecoder("utf-8");
                 const textEncoder = new TextEncoder("utf-8");
 
                 let tmpRetString;
                 let tmpRetBytes;
+                let tmpRetException;
                 return {
                     /** @param {WebAssembly.Imports} importObject */
                     addImports: (importObject) => {
                         const bjs = {};
                         importObject["bjs"] = bjs;
-                        bjs["return_string"] = function(ptr, len) {
-                            const bytes = new Uint8Array(memory.buffer, ptr, len);
+                        bjs["swift_js_return_string"] = function(ptr, len) {
+                            const bytes = new Uint8Array(memory.buffer, ptr, len)\(sharedMemory ? ".slice()" : "");
                             tmpRetString = textDecoder.decode(bytes);
                         }
-                        bjs["init_memory"] = function(sourceId, bytesPtr) {
+                        bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
                             const source = swift.memory.getObject(sourceId);
                             const bytes = new Uint8Array(memory.buffer, bytesPtr);
                             bytes.set(source);
                         }
-                        bjs["make_jsstring"] = function(ptr, len) {
-                            const bytes = new Uint8Array(memory.buffer, ptr, len);
+                        bjs["swift_js_make_js_string"] = function(ptr, len) {
+                            const bytes = new Uint8Array(memory.buffer, ptr, len)\(sharedMemory ? ".slice()" : "");
                             return swift.memory.retain(textDecoder.decode(bytes));
                         }
-                        bjs["init_memory_with_result"] = function(ptr, len) {
+                        bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
                             const target = new Uint8Array(memory.buffer, ptr, len);
                             target.set(tmpRetBytes);
                             tmpRetBytes = undefined;
                         }
-            \(importedLines.map { $0.indent(count: 12) }.joined(separator: "\n"))
+                        bjs["swift_js_throw"] = function(id) {
+                            tmpRetException = swift.memory.retainByRef(id);
+                        }
+                        bjs["swift_js_retain"] = function(id) {
+                            return swift.memory.retainByRef(id);
+                        }
+                        bjs["swift_js_release"] = function(id) {
+                            swift.memory.release(id);
+                        }
+            \(importObjectBuilders.flatMap { $0.importedLines }.map { $0.indent(count: 12) }.joined(separator: "\n"))
                     },
                     setInstance: (i) => {
                         instance = i;
                         memory = instance.exports.memory;
+                        setException = (error) => {
+                            instance.exports._swift_js_exception.value = swift.memory.retain(error)
+                        }
                     },
                     /** @param {WebAssembly.Instance} instance */
                     createExports: (instance) => {
@@ -198,7 +183,7 @@ struct BridgeJSLink {
         dtsLines.append(contentsOf: dtsExportLines.map { $0.indent(count: 4) })
         dtsLines.append("}")
         dtsLines.append("export type Imports = {")
-        dtsLines.append(contentsOf: dtsImportLines.map { $0.indent(count: 4) })
+        dtsLines.append(contentsOf: importObjectBuilders.flatMap { $0.dtsImportLines }.map { $0.indent(count: 4) })
         dtsLines.append("}")
         let outputDts = """
             // NOTICE: This is auto-generated code by BridgeJS from JavaScriptKit,
@@ -223,6 +208,11 @@ struct BridgeJSLink {
         var bodyLines: [String] = []
         var cleanupLines: [String] = []
         var parameterForwardings: [String] = []
+        let effects: Effects
+
+        init(effects: Effects) {
+            self.effects = effects
+        }
 
         func lowerParameter(param: Parameter) {
             switch param.type {
@@ -280,7 +270,24 @@ struct BridgeJSLink {
         }
 
         func callConstructor(abiName: String) -> String {
-            return "instance.exports.\(abiName)(\(parameterForwardings.joined(separator: ", ")))"
+            let call = "instance.exports.\(abiName)(\(parameterForwardings.joined(separator: ", ")))"
+            bodyLines.append("const ret = \(call);")
+            return "ret"
+        }
+
+        func checkExceptionLines() -> [String] {
+            guard effects.isThrows else {
+                return []
+            }
+            return [
+                "if (tmpRetException) {",
+                // TODO: Implement "take" operation
+                "    const error = swift.memory.getObject(tmpRetException);",
+                "    swift.memory.release(tmpRetException);",
+                "    tmpRetException = undefined;",
+                "    throw error;",
+                "}",
+            ]
         }
 
         func renderFunction(
@@ -296,6 +303,7 @@ struct BridgeJSLink {
             )
             funcLines.append(contentsOf: bodyLines.map { $0.indent(count: 4) })
             funcLines.append(contentsOf: cleanupLines.map { $0.indent(count: 4) })
+            funcLines.append(contentsOf: checkExceptionLines().map { $0.indent(count: 4) })
             if let returnExpr = returnExpr {
                 funcLines.append("return \(returnExpr);".indent(count: 4))
             }
@@ -309,7 +317,7 @@ struct BridgeJSLink {
     }
 
     func renderExportedFunction(function: ExportedFunction) -> (js: [String], dts: [String]) {
-        let thunkBuilder = ExportedThunkBuilder()
+        let thunkBuilder = ExportedThunkBuilder(effects: function.effects)
         for param in function.parameters {
             thunkBuilder.lowerParameter(param: param)
         }
@@ -339,16 +347,17 @@ struct BridgeJSLink {
         jsLines.append("class \(klass.name) extends SwiftHeapObject {")
 
         if let constructor: ExportedConstructor = klass.constructor {
-            let thunkBuilder = ExportedThunkBuilder()
+            let thunkBuilder = ExportedThunkBuilder(effects: constructor.effects)
             for param in constructor.parameters {
                 thunkBuilder.lowerParameter(param: param)
             }
-            let returnExpr = thunkBuilder.callConstructor(abiName: constructor.abiName)
             var funcLines: [String] = []
             funcLines.append("constructor(\(constructor.parameters.map { $0.name }.joined(separator: ", "))) {")
+            let returnExpr = thunkBuilder.callConstructor(abiName: constructor.abiName)
             funcLines.append(contentsOf: thunkBuilder.bodyLines.map { $0.indent(count: 4) })
-            funcLines.append("super(\(returnExpr), instance.exports.bjs_\(klass.name)_deinit);".indent(count: 4))
             funcLines.append(contentsOf: thunkBuilder.cleanupLines.map { $0.indent(count: 4) })
+            funcLines.append(contentsOf: thunkBuilder.checkExceptionLines().map { $0.indent(count: 4) })
+            funcLines.append("super(\(returnExpr), instance.exports.bjs_\(klass.name)_deinit);".indent(count: 4))
             funcLines.append("}")
             jsLines.append(contentsOf: funcLines.map { $0.indent(count: 4) })
 
@@ -359,7 +368,7 @@ struct BridgeJSLink {
         }
 
         for method in klass.methods {
-            let thunkBuilder = ExportedThunkBuilder()
+            let thunkBuilder = ExportedThunkBuilder(effects: method.effects)
             thunkBuilder.lowerSelf()
             for param in method.parameters {
                 thunkBuilder.lowerParameter(param: param)
@@ -414,16 +423,24 @@ struct BridgeJSLink {
 
         func renderFunction(
             name: String,
-            returnExpr: String?
+            returnExpr: String?,
+            returnType: BridgeType
         ) -> [String] {
             var funcLines: [String] = []
             funcLines.append(
                 "function \(name)(\(parameterNames.joined(separator: ", "))) {"
             )
-            funcLines.append(contentsOf: bodyLines.map { $0.indent(count: 4) })
+            funcLines.append("try {".indent(count: 4))
+            funcLines.append(contentsOf: bodyLines.map { $0.indent(count: 8) })
             if let returnExpr = returnExpr {
-                funcLines.append("return \(returnExpr);".indent(count: 4))
+                funcLines.append("return \(returnExpr);".indent(count: 8))
+            }
+            funcLines.append("} catch (error) {".indent(count: 4))
+            funcLines.append("setException(error);".indent(count: 8))
+            if let abiReturnType = returnType.abiReturnType {
+                funcLines.append("return \(abiReturnType.placeholderValue)".indent(count: 8))
             }
+            funcLines.append("}".indent(count: 4))
             funcLines.append("}")
             return funcLines
         }
@@ -437,6 +454,11 @@ struct BridgeJSLink {
             }
         }
 
+        func callConstructor(name: String) {
+            let call = "new options.imports.\(name)(\(parameterForwardings.joined(separator: ", ")))"
+            bodyLines.append("let ret = \(call);")
+        }
+
         func callMethod(name: String, returnType: BridgeType) {
             let call = "swift.memory.getObject(self).\(name)(\(parameterForwardings.joined(separator: ", ")))"
             if returnType == .void {
@@ -475,7 +497,31 @@ struct BridgeJSLink {
         }
     }
 
-    func renderImportedFunction(function: ImportedFunctionSkeleton) throws -> (js: [String], dts: [String]) {
+    class ImportObjectBuilder {
+        var moduleName: String
+        var importedLines: [String] = []
+        var dtsImportLines: [String] = []
+
+        init(moduleName: String) {
+            self.moduleName = moduleName
+            importedLines.append("const \(moduleName) = importObject[\"\(moduleName)\"] = {};")
+        }
+
+        func assignToImportObject(name: String, function: [String]) {
+            var js = function
+            js[0] = "\(moduleName)[\"\(name)\"] = " + js[0]
+            importedLines.append(contentsOf: js)
+        }
+
+        func appendDts(_ lines: [String]) {
+            dtsImportLines.append(contentsOf: lines)
+        }
+    }
+
+    func renderImportedFunction(
+        importObjectBuilder: ImportObjectBuilder,
+        function: ImportedFunctionSkeleton
+    ) throws {
         let thunkBuilder = ImportedThunkBuilder()
         for param in function.parameters {
             thunkBuilder.liftParameter(param: param)
@@ -484,13 +530,89 @@ struct BridgeJSLink {
         let returnExpr = try thunkBuilder.lowerReturnValue(returnType: function.returnType)
         let funcLines = thunkBuilder.renderFunction(
             name: function.abiName(context: nil),
-            returnExpr: returnExpr
+            returnExpr: returnExpr,
+            returnType: function.returnType
         )
-        var dtsLines: [String] = []
-        dtsLines.append(
-            "\(function.name)\(renderTSSignature(parameters: function.parameters, returnType: function.returnType));"
+        importObjectBuilder.appendDts(
+            [
+                "\(function.name)\(renderTSSignature(parameters: function.parameters, returnType: function.returnType));"
+            ]
         )
-        return (funcLines, dtsLines)
+        importObjectBuilder.assignToImportObject(name: function.abiName(context: nil), function: funcLines)
+    }
+
+    func renderImportedType(
+        importObjectBuilder: ImportObjectBuilder,
+        type: ImportedTypeSkeleton
+    ) throws {
+        if let constructor = type.constructor {
+            try renderImportedConstructor(
+                importObjectBuilder: importObjectBuilder,
+                type: type,
+                constructor: constructor
+            )
+        }
+        for property in type.properties {
+            let getterAbiName = property.getterAbiName(context: type)
+            let (js, dts) = try renderImportedProperty(
+                property: property,
+                abiName: getterAbiName,
+                emitCall: { thunkBuilder in
+                    thunkBuilder.callPropertyGetter(name: property.name, returnType: property.type)
+                    return try thunkBuilder.lowerReturnValue(returnType: property.type)
+                }
+            )
+            importObjectBuilder.assignToImportObject(name: getterAbiName, function: js)
+            importObjectBuilder.appendDts(dts)
+
+            if !property.isReadonly {
+                let setterAbiName = property.setterAbiName(context: type)
+                let (js, dts) = try renderImportedProperty(
+                    property: property,
+                    abiName: setterAbiName,
+                    emitCall: { thunkBuilder in
+                        thunkBuilder.liftParameter(
+                            param: Parameter(label: nil, name: "newValue", type: property.type)
+                        )
+                        thunkBuilder.callPropertySetter(name: property.name, returnType: property.type)
+                        return nil
+                    }
+                )
+                importObjectBuilder.assignToImportObject(name: setterAbiName, function: js)
+                importObjectBuilder.appendDts(dts)
+            }
+        }
+        for method in type.methods {
+            let (js, dts) = try renderImportedMethod(context: type, method: method)
+            importObjectBuilder.assignToImportObject(name: method.abiName(context: type), function: js)
+            importObjectBuilder.appendDts(dts)
+        }
+    }
+
+    func renderImportedConstructor(
+        importObjectBuilder: ImportObjectBuilder,
+        type: ImportedTypeSkeleton,
+        constructor: ImportedConstructorSkeleton
+    ) throws {
+        let thunkBuilder = ImportedThunkBuilder()
+        for param in constructor.parameters {
+            thunkBuilder.liftParameter(param: param)
+        }
+        let returnType = BridgeType.jsObject(type.name)
+        thunkBuilder.callConstructor(name: type.name)
+        let returnExpr = try thunkBuilder.lowerReturnValue(returnType: returnType)
+        let abiName = constructor.abiName(context: type)
+        let funcLines = thunkBuilder.renderFunction(
+            name: abiName,
+            returnExpr: returnExpr,
+            returnType: returnType
+        )
+        importObjectBuilder.assignToImportObject(name: abiName, function: funcLines)
+        importObjectBuilder.appendDts([
+            "\(type.name): {",
+            "new\(renderTSSignature(parameters: constructor.parameters, returnType: returnType));".indent(count: 4),
+            "}",
+        ])
     }
 
     func renderImportedProperty(
@@ -503,7 +625,8 @@ struct BridgeJSLink {
         let returnExpr = try emitCall(thunkBuilder)
         let funcLines = thunkBuilder.renderFunction(
             name: abiName,
-            returnExpr: returnExpr
+            returnExpr: returnExpr,
+            returnType: property.type
         )
         return (funcLines, [])
     }
@@ -521,7 +644,8 @@ struct BridgeJSLink {
         let returnExpr = try thunkBuilder.lowerReturnValue(returnType: method.returnType)
         let funcLines = thunkBuilder.renderFunction(
             name: method.abiName(context: context),
-            returnExpr: returnExpr
+            returnExpr: returnExpr,
+            returnType: method.returnType
         )
         return (funcLines, [])
     }
@@ -552,10 +676,18 @@ extension BridgeType {
             return "number"
         case .bool:
             return "boolean"
-        case .jsObject:
-            return "any"
+        case .jsObject(let name):
+            return name ?? "any"
         case .swiftHeapObject(let name):
             return name
         }
     }
 }
+
+extension WasmCoreType {
+    fileprivate var placeholderValue: String {
+        switch self {
+        case .i32, .i64, .f32, .f64, .pointer: return "0"
+        }
+    }
+}
diff --git a/Plugins/BridgeJS/Sources/BridgeJSLink/BridgeJSSkeleton b/Plugins/BridgeJS/Sources/BridgeJSLink/BridgeJSSkeleton
deleted file mode 120000
index a2c26678f..000000000
--- a/Plugins/BridgeJS/Sources/BridgeJSLink/BridgeJSSkeleton
+++ /dev/null
@@ -1 +0,0 @@
-../BridgeJSSkeleton
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Sources/BridgeJSSkeleton/BridgeJSSkeleton.swift b/Plugins/BridgeJS/Sources/BridgeJSSkeleton/BridgeJSSkeleton.swift
index 34492682f..5bfcc4147 100644
--- a/Plugins/BridgeJS/Sources/BridgeJSSkeleton/BridgeJSSkeleton.swift
+++ b/Plugins/BridgeJS/Sources/BridgeJSSkeleton/BridgeJSSkeleton.swift
@@ -16,6 +16,11 @@ struct Parameter: Codable {
     let type: BridgeType
 }
 
+struct Effects: Codable {
+    var isAsync: Bool
+    var isThrows: Bool
+}
+
 // MARK: - Exported Skeleton
 
 struct ExportedFunction: Codable {
@@ -23,6 +28,7 @@ struct ExportedFunction: Codable {
     var abiName: String
     var parameters: [Parameter]
     var returnType: BridgeType
+    var effects: Effects
 }
 
 struct ExportedClass: Codable {
@@ -34,6 +40,7 @@ struct ExportedClass: Codable {
 struct ExportedConstructor: Codable {
     var abiName: String
     var parameters: [Parameter]
+    var effects: Effects
 }
 
 struct ExportedSkeleton: Codable {
@@ -94,3 +101,20 @@ struct ImportedModuleSkeleton: Codable {
     let moduleName: String
     var children: [ImportedFileSkeleton]
 }
+
+extension BridgeType {
+    var abiReturnType: WasmCoreType? {
+        switch self {
+        case .void: return nil
+        case .bool: return .i32
+        case .int: return .i32
+        case .float: return .f32
+        case .double: return .f64
+        case .string: return nil
+        case .jsObject: return .i32
+        case .swiftHeapObject:
+            // UnsafeMutableRawPointer is returned as an i32 pointer
+            return .pointer
+        }
+    }
+}
diff --git a/Plugins/BridgeJS/Sources/BridgeJSTool/BridgeJSCore b/Plugins/BridgeJS/Sources/BridgeJSTool/BridgeJSCore
new file mode 120000
index 000000000..c869f69c3
--- /dev/null
+++ b/Plugins/BridgeJS/Sources/BridgeJSTool/BridgeJSCore
@@ -0,0 +1 @@
+../BridgeJSCore
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Sources/BridgeJSTool/BridgeJSTool.swift b/Plugins/BridgeJS/Sources/BridgeJSTool/BridgeJSTool.swift
index a6bd5ff52..6096e2b39 100644
--- a/Plugins/BridgeJS/Sources/BridgeJSTool/BridgeJSTool.swift
+++ b/Plugins/BridgeJS/Sources/BridgeJSTool/BridgeJSTool.swift
@@ -6,7 +6,6 @@
 @preconcurrency import class Foundation.JSONEncoder
 @preconcurrency import class Foundation.FileManager
 @preconcurrency import class Foundation.JSONDecoder
-@preconcurrency import class Foundation.ProcessInfo
 import SwiftParser
 
 /// BridgeJS Tool
@@ -57,7 +56,6 @@ import SwiftParser
                 """
             )
         }
-        let progress = ProgressReporting()
         switch subcommand {
         case "import":
             let parser = ArgumentParser(
@@ -71,6 +69,10 @@ import SwiftParser
                         help: "Always write the output files even if no APIs are imported",
                         required: false
                     ),
+                    "verbose": OptionRule(
+                        help: "Print verbose output",
+                        required: false
+                    ),
                     "output-swift": OptionRule(help: "The output file path for the Swift source code", required: true),
                     "output-skeleton": OptionRule(
                         help: "The output file path for the skeleton of the imported TypeScript APIs",
@@ -85,6 +87,7 @@ import SwiftParser
             let (positionalArguments, _, doubleDashOptions) = try parser.parse(
                 arguments: Array(arguments.dropFirst())
             )
+            let progress = ProgressReporting(verbose: doubleDashOptions["verbose"] == "true")
             var importer = ImportTS(progress: progress, moduleName: doubleDashOptions["module-name"]!)
             for inputFile in positionalArguments {
                 if inputFile.hasSuffix(".json") {
@@ -145,13 +148,18 @@ import SwiftParser
                         help: "Always write the output files even if no APIs are exported",
                         required: false
                     ),
+                    "verbose": OptionRule(
+                        help: "Print verbose output",
+                        required: false
+                    ),
                 ]
             )
             let (positionalArguments, _, doubleDashOptions) = try parser.parse(
                 arguments: Array(arguments.dropFirst())
             )
+            let progress = ProgressReporting(verbose: doubleDashOptions["verbose"] == "true")
             let exporter = ExportSwift(progress: progress)
-            for inputFile in positionalArguments {
+            for inputFile in positionalArguments.sorted() {
                 let sourceURL = URL(fileURLWithPath: inputFile)
                 guard sourceURL.pathExtension == "swift" else { continue }
                 let sourceContent = try String(contentsOf: sourceURL, encoding: .utf8)
@@ -211,33 +219,6 @@ import SwiftParser
     }
 }
 
-internal func which(_ executable: String) throws -> URL {
-    do {
-        // Check overriding environment variable
-        let envVariable = executable.uppercased().replacingOccurrences(of: "-", with: "_") + "_PATH"
-        if let path = ProcessInfo.processInfo.environment[envVariable] {
-            let url = URL(fileURLWithPath: path).appendingPathComponent(executable)
-            if FileManager.default.isExecutableFile(atPath: url.path) {
-                return url
-            }
-        }
-    }
-    let pathSeparator: Character
-    #if os(Windows)
-    pathSeparator = ";"
-    #else
-    pathSeparator = ":"
-    #endif
-    let paths = ProcessInfo.processInfo.environment["PATH"]!.split(separator: pathSeparator)
-    for path in paths {
-        let url = URL(fileURLWithPath: String(path)).appendingPathComponent(executable)
-        if FileManager.default.isExecutableFile(atPath: url.path) {
-            return url
-        }
-    }
-    throw BridgeJSToolError("Executable \(executable) not found in PATH")
-}
-
 struct BridgeJSToolError: Swift.Error, CustomStringConvertible {
     let description: String
 
@@ -250,22 +231,6 @@ private func printStderr(_ message: String) {
     fputs(message + "\n", stderr)
 }
 
-struct ProgressReporting {
-    let print: (String) -> Void
-
-    init(print: @escaping (String) -> Void = { Swift.print($0) }) {
-        self.print = print
-    }
-
-    static var silent: ProgressReporting {
-        return ProgressReporting(print: { _ in })
-    }
-
-    func print(_ message: String) {
-        self.print(message)
-    }
-}
-
 // MARK: - Minimal Argument Parsing
 
 struct OptionRule {
diff --git a/Plugins/BridgeJS/Sources/BridgeJSTool/TS2Skeleton b/Plugins/BridgeJS/Sources/BridgeJSTool/TS2Skeleton
new file mode 120000
index 000000000..f9ba2f579
--- /dev/null
+++ b/Plugins/BridgeJS/Sources/BridgeJSTool/TS2Skeleton
@@ -0,0 +1 @@
+../TS2Skeleton
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Sources/JavaScript/README.md b/Plugins/BridgeJS/Sources/TS2Skeleton/JavaScript/README.md
similarity index 100%
rename from Plugins/BridgeJS/Sources/JavaScript/README.md
rename to Plugins/BridgeJS/Sources/TS2Skeleton/JavaScript/README.md
diff --git a/Plugins/BridgeJS/Sources/JavaScript/bin/ts2skeleton.js b/Plugins/BridgeJS/Sources/TS2Skeleton/JavaScript/bin/ts2skeleton.js
similarity index 100%
rename from Plugins/BridgeJS/Sources/JavaScript/bin/ts2skeleton.js
rename to Plugins/BridgeJS/Sources/TS2Skeleton/JavaScript/bin/ts2skeleton.js
diff --git a/Plugins/BridgeJS/Sources/JavaScript/package.json b/Plugins/BridgeJS/Sources/TS2Skeleton/JavaScript/package.json
similarity index 100%
rename from Plugins/BridgeJS/Sources/JavaScript/package.json
rename to Plugins/BridgeJS/Sources/TS2Skeleton/JavaScript/package.json
diff --git a/Plugins/BridgeJS/Sources/JavaScript/src/cli.js b/Plugins/BridgeJS/Sources/TS2Skeleton/JavaScript/src/cli.js
similarity index 74%
rename from Plugins/BridgeJS/Sources/JavaScript/src/cli.js
rename to Plugins/BridgeJS/Sources/TS2Skeleton/JavaScript/src/cli.js
index 6d2a1ed84..f708082c6 100644
--- a/Plugins/BridgeJS/Sources/JavaScript/src/cli.js
+++ b/Plugins/BridgeJS/Sources/TS2Skeleton/JavaScript/src/cli.js
@@ -6,7 +6,15 @@ import ts from 'typescript';
 import path from 'path';
 
 class DiagnosticEngine {
-    constructor() {
+    /**
+     * @param {string} level
+     */
+    constructor(level) {
+        const levelInfo = DiagnosticEngine.LEVELS[level];
+        if (!levelInfo) {
+            throw new Error(`Invalid log level: ${level}`);
+        }
+        this.minLevel = levelInfo.level;
         /** @type {ts.FormatDiagnosticsHost} */
         this.formattHost = {
             getCanonicalFileName: (fileName) => fileName,
@@ -23,36 +31,36 @@ class DiagnosticEngine {
         console.log(message);
     }
 
-    /**
-     * @param {string} message
-     * @param {ts.Node | undefined} node
-     */
-    info(message, node = undefined) {
-        this.printLog("info", '\x1b[32m', message, node);
-    }
-
-    /**
-     * @param {string} message
-     * @param {ts.Node | undefined} node
-     */
-    warn(message, node = undefined) {
-        this.printLog("warning", '\x1b[33m', message, node);
-    }
-
-    /**
-     * @param {string} message
-     */
-    error(message) {
-        this.printLog("error", '\x1b[31m', message);
+    static LEVELS = {
+        "verbose": {
+            color: '\x1b[34m',
+            level: 0,
+        },
+        "info": {
+            color: '\x1b[32m',
+            level: 1,
+        },
+        "warning": {
+            color: '\x1b[33m',
+            level: 2,
+        },
+        "error": {
+            color: '\x1b[31m',
+            level: 3,
+        },
     }
 
     /**
-     * @param {string} level
-     * @param {string} color
+     * @param {keyof typeof DiagnosticEngine.LEVELS} level
      * @param {string} message
      * @param {ts.Node | undefined} node
      */
-    printLog(level, color, message, node = undefined) {
+    print(level, message, node = undefined) {
+        const levelInfo = DiagnosticEngine.LEVELS[level];
+        if (levelInfo.level < this.minLevel) {
+            return;
+        }
+        const color = levelInfo.color;
         if (node) {
             const sourceFile = node.getSourceFile();
             const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
@@ -85,7 +93,11 @@ export function main(args) {
             project: {
                 type: 'string',
                 short: 'p',
-            }
+            },
+            "log-level": {
+                type: 'string',
+                default: 'info',
+            },
         },
         allowPositionals: true
     })
@@ -102,9 +114,9 @@ export function main(args) {
     }
 
     const filePath = options.positionals[0];
-    const diagnosticEngine = new DiagnosticEngine();
+    const diagnosticEngine = new DiagnosticEngine(options.values["log-level"] || "info");
 
-    diagnosticEngine.info(`Processing ${filePath}...`);
+    diagnosticEngine.print("verbose", `Processing ${filePath}...`);
 
     // Create TypeScript program and process declarations
     const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
diff --git a/Plugins/BridgeJS/Sources/JavaScript/src/index.d.ts b/Plugins/BridgeJS/Sources/TS2Skeleton/JavaScript/src/index.d.ts
similarity index 100%
rename from Plugins/BridgeJS/Sources/JavaScript/src/index.d.ts
rename to Plugins/BridgeJS/Sources/TS2Skeleton/JavaScript/src/index.d.ts
diff --git a/Plugins/BridgeJS/Sources/JavaScript/src/processor.js b/Plugins/BridgeJS/Sources/TS2Skeleton/JavaScript/src/processor.js
similarity index 97%
rename from Plugins/BridgeJS/Sources/JavaScript/src/processor.js
rename to Plugins/BridgeJS/Sources/TS2Skeleton/JavaScript/src/processor.js
index e3887b3c1..0f97ea14a 100644
--- a/Plugins/BridgeJS/Sources/JavaScript/src/processor.js
+++ b/Plugins/BridgeJS/Sources/TS2Skeleton/JavaScript/src/processor.js
@@ -16,8 +16,7 @@ import ts from 'typescript';
 
 /**
  * @typedef {{
- *   warn: (message: string, node?: ts.Node) => void,
- *   error: (message: string, node?: ts.Node) => void,
+ *   print: (level: "warning" | "error", message: string, node?: ts.Node) => void,
  * }} DiagnosticEngine
  */
 
@@ -97,7 +96,7 @@ export class TypeProcessor {
                     }
                 });
             } catch (error) {
-                this.diagnosticEngine.error(`Error processing ${sourceFile.fileName}: ${error.message}`);
+                this.diagnosticEngine.print("error", `Error processing ${sourceFile.fileName}: ${error.message}`);
             }
         }
 
@@ -239,7 +238,8 @@ export class TypeProcessor {
 
         for (const member of node.members) {
             if (ts.isPropertyDeclaration(member)) {
-                // TODO
+                const property = this.visitPropertyDecl(member);
+                if (property) properties.push(property);
             } else if (ts.isMethodDeclaration(member)) {
                 const decl = this.visitFunctionLikeDecl(member);
                 if (decl) methods.push(decl);
@@ -383,7 +383,7 @@ export class TypeProcessor {
 
             const typeName = this.deriveTypeName(type);
             if (!typeName) {
-                this.diagnosticEngine.warn(`Unknown non-nominal type: ${typeString}`, node);
+                this.diagnosticEngine.print("warning", `Unknown non-nominal type: ${typeString}`, node);
                 return { "jsObject": {} };
             }
             this.seenTypes.set(type, node);
diff --git a/Plugins/BridgeJS/Sources/TS2Skeleton/TS2Skeleton.swift b/Plugins/BridgeJS/Sources/TS2Skeleton/TS2Skeleton.swift
new file mode 100644
index 000000000..46b58e011
--- /dev/null
+++ b/Plugins/BridgeJS/Sources/TS2Skeleton/TS2Skeleton.swift
@@ -0,0 +1,106 @@
+@preconcurrency import class Foundation.JSONDecoder
+@preconcurrency import class Foundation.Process
+@preconcurrency import class Foundation.Pipe
+@preconcurrency import class Foundation.ProcessInfo
+@preconcurrency import class Foundation.FileManager
+@preconcurrency import struct Foundation.URL
+@preconcurrency import struct Foundation.Data
+@preconcurrency import func Foundation.kill
+@preconcurrency import var Foundation.SIGINT
+@preconcurrency import var Foundation.SIGTERM
+import protocol Dispatch.DispatchSourceSignal
+import class Dispatch.DispatchSource
+
+internal func which(_ executable: String) throws -> URL {
+    do {
+        // Check overriding environment variable
+        let envVariable = executable.uppercased().replacingOccurrences(of: "-", with: "_") + "_PATH"
+        if let path = ProcessInfo.processInfo.environment[envVariable] {
+            let url = URL(fileURLWithPath: path).appendingPathComponent(executable)
+            if FileManager.default.isExecutableFile(atPath: url.path) {
+                return url
+            }
+        }
+    }
+    let pathSeparator: Character
+    #if os(Windows)
+    pathSeparator = ";"
+    #else
+    pathSeparator = ":"
+    #endif
+    let paths = ProcessInfo.processInfo.environment["PATH"]!.split(separator: pathSeparator)
+    for path in paths {
+        let url = URL(fileURLWithPath: String(path)).appendingPathComponent(executable)
+        if FileManager.default.isExecutableFile(atPath: url.path) {
+            return url
+        }
+    }
+    throw BridgeJSCoreError("Executable \(executable) not found in PATH")
+}
+
+extension ImportTS {
+    /// Processes a TypeScript definition file and extracts its API information
+    mutating func addSourceFile(_ sourceFile: String, tsconfigPath: String) throws {
+        let nodePath = try which("node")
+        let ts2skeletonPath = URL(fileURLWithPath: #filePath)
+            .deletingLastPathComponent()
+            .appendingPathComponent("JavaScript")
+            .appendingPathComponent("bin")
+            .appendingPathComponent("ts2skeleton.js")
+        let arguments = [ts2skeletonPath.path, sourceFile, "--project", tsconfigPath]
+
+        progress.print("Running ts2skeleton...")
+        progress.print("  \(([nodePath.path] + arguments).joined(separator: " "))")
+
+        let process = Process()
+        let stdoutPipe = Pipe()
+        nonisolated(unsafe) var stdoutData = Data()
+
+        process.executableURL = nodePath
+        process.arguments = arguments
+        process.standardOutput = stdoutPipe
+
+        stdoutPipe.fileHandleForReading.readabilityHandler = { handle in
+            let data = handle.availableData
+            if data.count > 0 {
+                stdoutData.append(data)
+            }
+        }
+        try process.forwardTerminationSignals {
+            try process.run()
+            process.waitUntilExit()
+        }
+
+        if process.terminationStatus != 0 {
+            throw BridgeJSCoreError("ts2skeleton returned \(process.terminationStatus)")
+        }
+        let skeleton = try JSONDecoder().decode(ImportedFileSkeleton.self, from: stdoutData)
+        self.addSkeleton(skeleton)
+    }
+}
+
+extension Foundation.Process {
+    // Monitor termination/interrruption signals to forward them to child process
+    func setSignalForwarding(_ signalNo: Int32) -> DispatchSourceSignal {
+        let signalSource = DispatchSource.makeSignalSource(signal: signalNo)
+        signalSource.setEventHandler { [self] in
+            signalSource.cancel()
+            kill(processIdentifier, signalNo)
+        }
+        signalSource.resume()
+        return signalSource
+    }
+
+    func forwardTerminationSignals(_ body: () throws -> Void) rethrows {
+        let sources = [
+            setSignalForwarding(SIGINT),
+            setSignalForwarding(SIGTERM),
+        ]
+        defer {
+            for source in sources {
+                source.cancel()
+            }
+        }
+        try body()
+    }
+}
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/BridgeJSCore b/Plugins/BridgeJS/Tests/BridgeJSToolTests/BridgeJSCore
new file mode 120000
index 000000000..852d5b95c
--- /dev/null
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/BridgeJSCore
@@ -0,0 +1 @@
+../../Sources/BridgeJSCore
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/BridgeJSLink b/Plugins/BridgeJS/Tests/BridgeJSToolTests/BridgeJSLink
new file mode 120000
index 000000000..94a1e954a
--- /dev/null
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/BridgeJSLink
@@ -0,0 +1 @@
+../../Sources/BridgeJSLink
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/BridgeJSLinkTests.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/BridgeJSLinkTests.swift
index e052ed427..3432551bb 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/BridgeJSLinkTests.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/BridgeJSLinkTests.swift
@@ -3,9 +3,6 @@ import SwiftSyntax
 import SwiftParser
 import Testing
 
-@testable import BridgeJSLink
-@testable import BridgeJSTool
-
 @Suite struct BridgeJSLinkTests {
     private func snapshot(
         bridgeJSLink: BridgeJSLink,
@@ -55,7 +52,7 @@ import Testing
         let encoder = JSONEncoder()
         encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
         let outputSkeletonData = try encoder.encode(outputSkeleton)
-        var bridgeJSLink = BridgeJSLink()
+        var bridgeJSLink = BridgeJSLink(sharedMemory: false)
         try bridgeJSLink.addExportedSkeletonFile(data: outputSkeletonData)
         try snapshot(bridgeJSLink: bridgeJSLink, name: name + ".Export")
     }
@@ -73,7 +70,7 @@ import Testing
         encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
         let outputSkeletonData = try encoder.encode(importTS.skeleton)
 
-        var bridgeJSLink = BridgeJSLink()
+        var bridgeJSLink = BridgeJSLink(sharedMemory: false)
         try bridgeJSLink.addImportedSkeletonFile(data: outputSkeletonData)
         try snapshot(bridgeJSLink: bridgeJSLink, name: name + ".Import")
     }
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/BridgeJSSkeleton b/Plugins/BridgeJS/Tests/BridgeJSToolTests/BridgeJSSkeleton
new file mode 120000
index 000000000..c2cf28641
--- /dev/null
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/BridgeJSSkeleton
@@ -0,0 +1 @@
+../../Sources/BridgeJSSkeleton
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/ExportSwiftTests.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/ExportSwiftTests.swift
index 6064bb28a..626248a7d 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/ExportSwiftTests.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/ExportSwiftTests.swift
@@ -3,8 +3,6 @@ import SwiftSyntax
 import SwiftParser
 import Testing
 
-@testable import BridgeJSTool
-
 @Suite struct ExportSwiftTests {
     private func snapshot(
         swiftAPI: ExportSwift,
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/ImportTSTests.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/ImportTSTests.swift
index 71b0e005f..071c3d1dd 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/ImportTSTests.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/ImportTSTests.swift
@@ -1,6 +1,5 @@
 import Testing
 import Foundation
-@testable import BridgeJSTool
 
 @Suite struct ImportTSTests {
     static let inputsDirectory = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent(
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/Inputs/Throws.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/Inputs/Throws.swift
new file mode 100644
index 000000000..ce8c30fe1
--- /dev/null
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/Inputs/Throws.swift
@@ -0,0 +1,3 @@
+@JS func throwsSomething() throws(JSException) {
+    throw JSException(JSError(message: "TestError").jsValue)
+}
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/Inputs/TypeScriptClass.d.ts b/Plugins/BridgeJS/Tests/BridgeJSToolTests/Inputs/TypeScriptClass.d.ts
index d10c0138b..074772f24 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/Inputs/TypeScriptClass.d.ts
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/Inputs/TypeScriptClass.d.ts
@@ -1,4 +1,6 @@
 export class Greeter {
+    name: string;
+    readonly age: number;
     constructor(name: string);
     greet(): string;
     changeName(name: string): void;
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/SnapshotTesting.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/SnapshotTesting.swift
index 28b34bf69..ce7066a6d 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/SnapshotTesting.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/SnapshotTesting.swift
@@ -24,14 +24,15 @@ func assertSnapshot(
         let existingSnapshot = try String(contentsOf: snapshotPath, encoding: .utf8)
         let ok = existingSnapshot == String(data: input, encoding: .utf8)!
         let actualFilePath = snapshotPath.path + ".actual"
+        let updateSnapshots = ProcessInfo.processInfo.environment["UPDATE_SNAPSHOTS"] != nil
         func buildComment() -> Comment {
             "Snapshot mismatch: \(actualFilePath) \(snapshotPath.path)"
         }
-        if !ok {
-            try input.write(to: URL(fileURLWithPath: actualFilePath))
-        }
-        if ProcessInfo.processInfo.environment["UPDATE_SNAPSHOTS"] == nil {
+        if !updateSnapshots {
             #expect(ok, buildComment(), sourceLocation: sourceLocation)
+            if !ok {
+                try input.write(to: URL(fileURLWithPath: actualFilePath))
+            }
         } else {
             try input.write(to: snapshotPath)
         }
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/TS2Skeleton b/Plugins/BridgeJS/Tests/BridgeJSToolTests/TS2Skeleton
new file mode 120000
index 000000000..feba84705
--- /dev/null
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/TS2Skeleton
@@ -0,0 +1 @@
+../../Sources/TS2Skeleton
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/ArrayParameter.Import.js b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/ArrayParameter.Import.js
index caad458db..c90b3919d 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/ArrayParameter.Import.js
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/ArrayParameter.Import.js
@@ -7,48 +7,74 @@
 export async function createInstantiator(options, swift) {
     let instance;
     let memory;
+    let setException;
     const textDecoder = new TextDecoder("utf-8");
     const textEncoder = new TextEncoder("utf-8");
 
     let tmpRetString;
     let tmpRetBytes;
+    let tmpRetException;
     return {
         /** @param {WebAssembly.Imports} importObject */
         addImports: (importObject) => {
             const bjs = {};
             importObject["bjs"] = bjs;
-            bjs["return_string"] = function(ptr, len) {
+            bjs["swift_js_return_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 tmpRetString = textDecoder.decode(bytes);
             }
-            bjs["init_memory"] = function(sourceId, bytesPtr) {
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
                 const source = swift.memory.getObject(sourceId);
                 const bytes = new Uint8Array(memory.buffer, bytesPtr);
                 bytes.set(source);
             }
-            bjs["make_jsstring"] = function(ptr, len) {
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 return swift.memory.retain(textDecoder.decode(bytes));
             }
-            bjs["init_memory_with_result"] = function(ptr, len) {
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
                 const target = new Uint8Array(memory.buffer, ptr, len);
                 target.set(tmpRetBytes);
                 tmpRetBytes = undefined;
             }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
             const TestModule = importObject["TestModule"] = {};
             TestModule["bjs_checkArray"] = function bjs_checkArray(a) {
-                options.imports.checkArray(swift.memory.getObject(a));
+                try {
+                    options.imports.checkArray(swift.memory.getObject(a));
+                } catch (error) {
+                    setException(error);
+                }
             }
             TestModule["bjs_checkArrayWithLength"] = function bjs_checkArrayWithLength(a, b) {
-                options.imports.checkArrayWithLength(swift.memory.getObject(a), b);
+                try {
+                    options.imports.checkArrayWithLength(swift.memory.getObject(a), b);
+                } catch (error) {
+                    setException(error);
+                }
             }
             TestModule["bjs_checkArray"] = function bjs_checkArray(a) {
-                options.imports.checkArray(swift.memory.getObject(a));
+                try {
+                    options.imports.checkArray(swift.memory.getObject(a));
+                } catch (error) {
+                    setException(error);
+                }
             }
         },
         setInstance: (i) => {
             instance = i;
             memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
         },
         /** @param {WebAssembly.Instance} instance */
         createExports: (instance) => {
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Interface.Import.d.ts b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Interface.Import.d.ts
index 1e7ca6ab1..ffcbcd14f 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Interface.Import.d.ts
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Interface.Import.d.ts
@@ -7,7 +7,7 @@
 export type Exports = {
 }
 export type Imports = {
-    returnAnimatable(): any;
+    returnAnimatable(): Animatable;
 }
 export function createInstantiator(options: {
     imports: Imports;
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Interface.Import.js b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Interface.Import.js
index 4b3811859..4d88bcdb9 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Interface.Import.js
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Interface.Import.js
@@ -7,51 +7,80 @@
 export async function createInstantiator(options, swift) {
     let instance;
     let memory;
+    let setException;
     const textDecoder = new TextDecoder("utf-8");
     const textEncoder = new TextEncoder("utf-8");
 
     let tmpRetString;
     let tmpRetBytes;
+    let tmpRetException;
     return {
         /** @param {WebAssembly.Imports} importObject */
         addImports: (importObject) => {
             const bjs = {};
             importObject["bjs"] = bjs;
-            bjs["return_string"] = function(ptr, len) {
+            bjs["swift_js_return_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 tmpRetString = textDecoder.decode(bytes);
             }
-            bjs["init_memory"] = function(sourceId, bytesPtr) {
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
                 const source = swift.memory.getObject(sourceId);
                 const bytes = new Uint8Array(memory.buffer, bytesPtr);
                 bytes.set(source);
             }
-            bjs["make_jsstring"] = function(ptr, len) {
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 return swift.memory.retain(textDecoder.decode(bytes));
             }
-            bjs["init_memory_with_result"] = function(ptr, len) {
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
                 const target = new Uint8Array(memory.buffer, ptr, len);
                 target.set(tmpRetBytes);
                 tmpRetBytes = undefined;
             }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
             const TestModule = importObject["TestModule"] = {};
             TestModule["bjs_returnAnimatable"] = function bjs_returnAnimatable() {
-                let ret = options.imports.returnAnimatable();
-                return swift.memory.retain(ret);
+                try {
+                    let ret = options.imports.returnAnimatable();
+                    return swift.memory.retain(ret);
+                } catch (error) {
+                    setException(error);
+                    return 0
+                }
             }
             TestModule["bjs_Animatable_animate"] = function bjs_Animatable_animate(self, keyframes, options) {
-                let ret = swift.memory.getObject(self).animate(swift.memory.getObject(keyframes), swift.memory.getObject(options));
-                return swift.memory.retain(ret);
+                try {
+                    let ret = swift.memory.getObject(self).animate(swift.memory.getObject(keyframes), swift.memory.getObject(options));
+                    return swift.memory.retain(ret);
+                } catch (error) {
+                    setException(error);
+                    return 0
+                }
             }
             TestModule["bjs_Animatable_getAnimations"] = function bjs_Animatable_getAnimations(self, options) {
-                let ret = swift.memory.getObject(self).getAnimations(swift.memory.getObject(options));
-                return swift.memory.retain(ret);
+                try {
+                    let ret = swift.memory.getObject(self).getAnimations(swift.memory.getObject(options));
+                    return swift.memory.retain(ret);
+                } catch (error) {
+                    setException(error);
+                    return 0
+                }
             }
         },
         setInstance: (i) => {
             instance = i;
             memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
         },
         /** @param {WebAssembly.Instance} instance */
         createExports: (instance) => {
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PrimitiveParameters.Export.js b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PrimitiveParameters.Export.js
index 2d9ee4b10..1f4d6cbcf 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PrimitiveParameters.Export.js
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PrimitiveParameters.Export.js
@@ -7,39 +7,53 @@
 export async function createInstantiator(options, swift) {
     let instance;
     let memory;
+    let setException;
     const textDecoder = new TextDecoder("utf-8");
     const textEncoder = new TextEncoder("utf-8");
 
     let tmpRetString;
     let tmpRetBytes;
+    let tmpRetException;
     return {
         /** @param {WebAssembly.Imports} importObject */
         addImports: (importObject) => {
             const bjs = {};
             importObject["bjs"] = bjs;
-            bjs["return_string"] = function(ptr, len) {
+            bjs["swift_js_return_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 tmpRetString = textDecoder.decode(bytes);
             }
-            bjs["init_memory"] = function(sourceId, bytesPtr) {
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
                 const source = swift.memory.getObject(sourceId);
                 const bytes = new Uint8Array(memory.buffer, bytesPtr);
                 bytes.set(source);
             }
-            bjs["make_jsstring"] = function(ptr, len) {
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 return swift.memory.retain(textDecoder.decode(bytes));
             }
-            bjs["init_memory_with_result"] = function(ptr, len) {
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
                 const target = new Uint8Array(memory.buffer, ptr, len);
                 target.set(tmpRetBytes);
                 tmpRetBytes = undefined;
             }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
 
         },
         setInstance: (i) => {
             instance = i;
             memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
         },
         /** @param {WebAssembly.Instance} instance */
         createExports: (instance) => {
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PrimitiveParameters.Import.js b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PrimitiveParameters.Import.js
index 0d871bbb1..c6413b6b3 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PrimitiveParameters.Import.js
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PrimitiveParameters.Import.js
@@ -7,42 +7,60 @@
 export async function createInstantiator(options, swift) {
     let instance;
     let memory;
+    let setException;
     const textDecoder = new TextDecoder("utf-8");
     const textEncoder = new TextEncoder("utf-8");
 
     let tmpRetString;
     let tmpRetBytes;
+    let tmpRetException;
     return {
         /** @param {WebAssembly.Imports} importObject */
         addImports: (importObject) => {
             const bjs = {};
             importObject["bjs"] = bjs;
-            bjs["return_string"] = function(ptr, len) {
+            bjs["swift_js_return_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 tmpRetString = textDecoder.decode(bytes);
             }
-            bjs["init_memory"] = function(sourceId, bytesPtr) {
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
                 const source = swift.memory.getObject(sourceId);
                 const bytes = new Uint8Array(memory.buffer, bytesPtr);
                 bytes.set(source);
             }
-            bjs["make_jsstring"] = function(ptr, len) {
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 return swift.memory.retain(textDecoder.decode(bytes));
             }
-            bjs["init_memory_with_result"] = function(ptr, len) {
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
                 const target = new Uint8Array(memory.buffer, ptr, len);
                 target.set(tmpRetBytes);
                 tmpRetBytes = undefined;
             }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
             const TestModule = importObject["TestModule"] = {};
             TestModule["bjs_check"] = function bjs_check(a, b) {
-                options.imports.check(a, b);
+                try {
+                    options.imports.check(a, b);
+                } catch (error) {
+                    setException(error);
+                }
             }
         },
         setInstance: (i) => {
             instance = i;
             memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
         },
         /** @param {WebAssembly.Instance} instance */
         createExports: (instance) => {
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PrimitiveReturn.Export.js b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PrimitiveReturn.Export.js
index 8a66f0412..01dbcb743 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PrimitiveReturn.Export.js
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PrimitiveReturn.Export.js
@@ -7,39 +7,53 @@
 export async function createInstantiator(options, swift) {
     let instance;
     let memory;
+    let setException;
     const textDecoder = new TextDecoder("utf-8");
     const textEncoder = new TextEncoder("utf-8");
 
     let tmpRetString;
     let tmpRetBytes;
+    let tmpRetException;
     return {
         /** @param {WebAssembly.Imports} importObject */
         addImports: (importObject) => {
             const bjs = {};
             importObject["bjs"] = bjs;
-            bjs["return_string"] = function(ptr, len) {
+            bjs["swift_js_return_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 tmpRetString = textDecoder.decode(bytes);
             }
-            bjs["init_memory"] = function(sourceId, bytesPtr) {
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
                 const source = swift.memory.getObject(sourceId);
                 const bytes = new Uint8Array(memory.buffer, bytesPtr);
                 bytes.set(source);
             }
-            bjs["make_jsstring"] = function(ptr, len) {
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 return swift.memory.retain(textDecoder.decode(bytes));
             }
-            bjs["init_memory_with_result"] = function(ptr, len) {
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
                 const target = new Uint8Array(memory.buffer, ptr, len);
                 target.set(tmpRetBytes);
                 tmpRetBytes = undefined;
             }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
 
         },
         setInstance: (i) => {
             instance = i;
             memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
         },
         /** @param {WebAssembly.Instance} instance */
         createExports: (instance) => {
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PrimitiveReturn.Import.js b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PrimitiveReturn.Import.js
index a638f8642..2a3292bc7 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PrimitiveReturn.Import.js
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/PrimitiveReturn.Import.js
@@ -7,47 +7,71 @@
 export async function createInstantiator(options, swift) {
     let instance;
     let memory;
+    let setException;
     const textDecoder = new TextDecoder("utf-8");
     const textEncoder = new TextEncoder("utf-8");
 
     let tmpRetString;
     let tmpRetBytes;
+    let tmpRetException;
     return {
         /** @param {WebAssembly.Imports} importObject */
         addImports: (importObject) => {
             const bjs = {};
             importObject["bjs"] = bjs;
-            bjs["return_string"] = function(ptr, len) {
+            bjs["swift_js_return_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 tmpRetString = textDecoder.decode(bytes);
             }
-            bjs["init_memory"] = function(sourceId, bytesPtr) {
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
                 const source = swift.memory.getObject(sourceId);
                 const bytes = new Uint8Array(memory.buffer, bytesPtr);
                 bytes.set(source);
             }
-            bjs["make_jsstring"] = function(ptr, len) {
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 return swift.memory.retain(textDecoder.decode(bytes));
             }
-            bjs["init_memory_with_result"] = function(ptr, len) {
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
                 const target = new Uint8Array(memory.buffer, ptr, len);
                 target.set(tmpRetBytes);
                 tmpRetBytes = undefined;
             }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
             const TestModule = importObject["TestModule"] = {};
             TestModule["bjs_checkNumber"] = function bjs_checkNumber() {
-                let ret = options.imports.checkNumber();
-                return ret;
+                try {
+                    let ret = options.imports.checkNumber();
+                    return ret;
+                } catch (error) {
+                    setException(error);
+                    return 0
+                }
             }
             TestModule["bjs_checkBoolean"] = function bjs_checkBoolean() {
-                let ret = options.imports.checkBoolean();
-                return ret !== 0;
+                try {
+                    let ret = options.imports.checkBoolean();
+                    return ret !== 0;
+                } catch (error) {
+                    setException(error);
+                    return 0
+                }
             }
         },
         setInstance: (i) => {
             instance = i;
             memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
         },
         /** @param {WebAssembly.Instance} instance */
         createExports: (instance) => {
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/StringParameter.Export.js b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/StringParameter.Export.js
index c13cd3585..7c2e883db 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/StringParameter.Export.js
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/StringParameter.Export.js
@@ -7,39 +7,53 @@
 export async function createInstantiator(options, swift) {
     let instance;
     let memory;
+    let setException;
     const textDecoder = new TextDecoder("utf-8");
     const textEncoder = new TextEncoder("utf-8");
 
     let tmpRetString;
     let tmpRetBytes;
+    let tmpRetException;
     return {
         /** @param {WebAssembly.Imports} importObject */
         addImports: (importObject) => {
             const bjs = {};
             importObject["bjs"] = bjs;
-            bjs["return_string"] = function(ptr, len) {
+            bjs["swift_js_return_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 tmpRetString = textDecoder.decode(bytes);
             }
-            bjs["init_memory"] = function(sourceId, bytesPtr) {
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
                 const source = swift.memory.getObject(sourceId);
                 const bytes = new Uint8Array(memory.buffer, bytesPtr);
                 bytes.set(source);
             }
-            bjs["make_jsstring"] = function(ptr, len) {
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 return swift.memory.retain(textDecoder.decode(bytes));
             }
-            bjs["init_memory_with_result"] = function(ptr, len) {
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
                 const target = new Uint8Array(memory.buffer, ptr, len);
                 target.set(tmpRetBytes);
                 tmpRetBytes = undefined;
             }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
 
         },
         setInstance: (i) => {
             instance = i;
             memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
         },
         /** @param {WebAssembly.Instance} instance */
         createExports: (instance) => {
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/StringParameter.Import.js b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/StringParameter.Import.js
index 6e5d4bdce..c12e6c1e1 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/StringParameter.Import.js
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/StringParameter.Import.js
@@ -7,49 +7,71 @@
 export async function createInstantiator(options, swift) {
     let instance;
     let memory;
+    let setException;
     const textDecoder = new TextDecoder("utf-8");
     const textEncoder = new TextEncoder("utf-8");
 
     let tmpRetString;
     let tmpRetBytes;
+    let tmpRetException;
     return {
         /** @param {WebAssembly.Imports} importObject */
         addImports: (importObject) => {
             const bjs = {};
             importObject["bjs"] = bjs;
-            bjs["return_string"] = function(ptr, len) {
+            bjs["swift_js_return_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 tmpRetString = textDecoder.decode(bytes);
             }
-            bjs["init_memory"] = function(sourceId, bytesPtr) {
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
                 const source = swift.memory.getObject(sourceId);
                 const bytes = new Uint8Array(memory.buffer, bytesPtr);
                 bytes.set(source);
             }
-            bjs["make_jsstring"] = function(ptr, len) {
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 return swift.memory.retain(textDecoder.decode(bytes));
             }
-            bjs["init_memory_with_result"] = function(ptr, len) {
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
                 const target = new Uint8Array(memory.buffer, ptr, len);
                 target.set(tmpRetBytes);
                 tmpRetBytes = undefined;
             }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
             const TestModule = importObject["TestModule"] = {};
             TestModule["bjs_checkString"] = function bjs_checkString(a) {
-                const aObject = swift.memory.getObject(a);
-                swift.memory.release(a);
-                options.imports.checkString(aObject);
+                try {
+                    const aObject = swift.memory.getObject(a);
+                    swift.memory.release(a);
+                    options.imports.checkString(aObject);
+                } catch (error) {
+                    setException(error);
+                }
             }
             TestModule["bjs_checkStringWithLength"] = function bjs_checkStringWithLength(a, b) {
-                const aObject = swift.memory.getObject(a);
-                swift.memory.release(a);
-                options.imports.checkStringWithLength(aObject, b);
+                try {
+                    const aObject = swift.memory.getObject(a);
+                    swift.memory.release(a);
+                    options.imports.checkStringWithLength(aObject, b);
+                } catch (error) {
+                    setException(error);
+                }
             }
         },
         setInstance: (i) => {
             instance = i;
             memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
         },
         /** @param {WebAssembly.Instance} instance */
         createExports: (instance) => {
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/StringReturn.Export.js b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/StringReturn.Export.js
index 0208d8cea..0362f3c42 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/StringReturn.Export.js
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/StringReturn.Export.js
@@ -7,39 +7,53 @@
 export async function createInstantiator(options, swift) {
     let instance;
     let memory;
+    let setException;
     const textDecoder = new TextDecoder("utf-8");
     const textEncoder = new TextEncoder("utf-8");
 
     let tmpRetString;
     let tmpRetBytes;
+    let tmpRetException;
     return {
         /** @param {WebAssembly.Imports} importObject */
         addImports: (importObject) => {
             const bjs = {};
             importObject["bjs"] = bjs;
-            bjs["return_string"] = function(ptr, len) {
+            bjs["swift_js_return_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 tmpRetString = textDecoder.decode(bytes);
             }
-            bjs["init_memory"] = function(sourceId, bytesPtr) {
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
                 const source = swift.memory.getObject(sourceId);
                 const bytes = new Uint8Array(memory.buffer, bytesPtr);
                 bytes.set(source);
             }
-            bjs["make_jsstring"] = function(ptr, len) {
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 return swift.memory.retain(textDecoder.decode(bytes));
             }
-            bjs["init_memory_with_result"] = function(ptr, len) {
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
                 const target = new Uint8Array(memory.buffer, ptr, len);
                 target.set(tmpRetBytes);
                 tmpRetBytes = undefined;
             }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
 
         },
         setInstance: (i) => {
             instance = i;
             memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
         },
         /** @param {WebAssembly.Instance} instance */
         createExports: (instance) => {
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/StringReturn.Import.js b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/StringReturn.Import.js
index 26e57959a..bb78c255a 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/StringReturn.Import.js
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/StringReturn.Import.js
@@ -7,44 +7,62 @@
 export async function createInstantiator(options, swift) {
     let instance;
     let memory;
+    let setException;
     const textDecoder = new TextDecoder("utf-8");
     const textEncoder = new TextEncoder("utf-8");
 
     let tmpRetString;
     let tmpRetBytes;
+    let tmpRetException;
     return {
         /** @param {WebAssembly.Imports} importObject */
         addImports: (importObject) => {
             const bjs = {};
             importObject["bjs"] = bjs;
-            bjs["return_string"] = function(ptr, len) {
+            bjs["swift_js_return_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 tmpRetString = textDecoder.decode(bytes);
             }
-            bjs["init_memory"] = function(sourceId, bytesPtr) {
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
                 const source = swift.memory.getObject(sourceId);
                 const bytes = new Uint8Array(memory.buffer, bytesPtr);
                 bytes.set(source);
             }
-            bjs["make_jsstring"] = function(ptr, len) {
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 return swift.memory.retain(textDecoder.decode(bytes));
             }
-            bjs["init_memory_with_result"] = function(ptr, len) {
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
                 const target = new Uint8Array(memory.buffer, ptr, len);
                 target.set(tmpRetBytes);
                 tmpRetBytes = undefined;
             }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
             const TestModule = importObject["TestModule"] = {};
             TestModule["bjs_checkString"] = function bjs_checkString() {
-                let ret = options.imports.checkString();
-                tmpRetBytes = textEncoder.encode(ret);
-                return tmpRetBytes.length;
+                try {
+                    let ret = options.imports.checkString();
+                    tmpRetBytes = textEncoder.encode(ret);
+                    return tmpRetBytes.length;
+                } catch (error) {
+                    setException(error);
+                }
             }
         },
         setInstance: (i) => {
             instance = i;
             memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
         },
         /** @param {WebAssembly.Instance} instance */
         createExports: (instance) => {
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/SwiftClass.Export.js b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/SwiftClass.Export.js
index 971b9d69d..7a5938a11 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/SwiftClass.Export.js
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/SwiftClass.Export.js
@@ -7,39 +7,53 @@
 export async function createInstantiator(options, swift) {
     let instance;
     let memory;
+    let setException;
     const textDecoder = new TextDecoder("utf-8");
     const textEncoder = new TextEncoder("utf-8");
 
     let tmpRetString;
     let tmpRetBytes;
+    let tmpRetException;
     return {
         /** @param {WebAssembly.Imports} importObject */
         addImports: (importObject) => {
             const bjs = {};
             importObject["bjs"] = bjs;
-            bjs["return_string"] = function(ptr, len) {
+            bjs["swift_js_return_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 tmpRetString = textDecoder.decode(bytes);
             }
-            bjs["init_memory"] = function(sourceId, bytesPtr) {
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
                 const source = swift.memory.getObject(sourceId);
                 const bytes = new Uint8Array(memory.buffer, bytesPtr);
                 bytes.set(source);
             }
-            bjs["make_jsstring"] = function(ptr, len) {
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 return swift.memory.retain(textDecoder.decode(bytes));
             }
-            bjs["init_memory_with_result"] = function(ptr, len) {
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
                 const target = new Uint8Array(memory.buffer, ptr, len);
                 target.set(tmpRetBytes);
                 tmpRetBytes = undefined;
             }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
 
         },
         setInstance: (i) => {
             instance = i;
             memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
         },
         /** @param {WebAssembly.Instance} instance */
         createExports: (instance) => {
@@ -65,8 +79,9 @@ export async function createInstantiator(options, swift) {
                 constructor(name) {
                     const nameBytes = textEncoder.encode(name);
                     const nameId = swift.memory.retain(nameBytes);
-                    super(instance.exports.bjs_Greeter_init(nameId, nameBytes.length), instance.exports.bjs_Greeter_deinit);
+                    const ret = instance.exports.bjs_Greeter_init(nameId, nameBytes.length);
                     swift.memory.release(nameId);
+                    super(ret, instance.exports.bjs_Greeter_deinit);
                 }
                 greet() {
                     instance.exports.bjs_Greeter_greet(this.pointer);
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Throws.Export.d.ts b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Throws.Export.d.ts
new file mode 100644
index 000000000..9199ad1ae
--- /dev/null
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Throws.Export.d.ts
@@ -0,0 +1,18 @@
+// NOTICE: This is auto-generated code by BridgeJS from JavaScriptKit,
+// DO NOT EDIT.
+//
+// To update this file, just rebuild your project or run
+// `swift package bridge-js`.
+
+export type Exports = {
+    throwsSomething(): void;
+}
+export type Imports = {
+}
+export function createInstantiator(options: {
+    imports: Imports;
+}, swift: any): Promise<{
+    addImports: (importObject: WebAssembly.Imports) => void;
+    setInstance: (instance: WebAssembly.Instance) => void;
+    createExports: (instance: WebAssembly.Instance) => Exports;
+}>;
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Throws.Export.js b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Throws.Export.js
new file mode 100644
index 000000000..d0f9b6236
--- /dev/null
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/Throws.Export.js
@@ -0,0 +1,75 @@
+// NOTICE: This is auto-generated code by BridgeJS from JavaScriptKit,
+// DO NOT EDIT.
+//
+// To update this file, just rebuild your project or run
+// `swift package bridge-js`.
+
+export async function createInstantiator(options, swift) {
+    let instance;
+    let memory;
+    let setException;
+    const textDecoder = new TextDecoder("utf-8");
+    const textEncoder = new TextEncoder("utf-8");
+
+    let tmpRetString;
+    let tmpRetBytes;
+    let tmpRetException;
+    return {
+        /** @param {WebAssembly.Imports} importObject */
+        addImports: (importObject) => {
+            const bjs = {};
+            importObject["bjs"] = bjs;
+            bjs["swift_js_return_string"] = function(ptr, len) {
+                const bytes = new Uint8Array(memory.buffer, ptr, len);
+                tmpRetString = textDecoder.decode(bytes);
+            }
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
+                const source = swift.memory.getObject(sourceId);
+                const bytes = new Uint8Array(memory.buffer, bytesPtr);
+                bytes.set(source);
+            }
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
+                const bytes = new Uint8Array(memory.buffer, ptr, len);
+                return swift.memory.retain(textDecoder.decode(bytes));
+            }
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
+                const target = new Uint8Array(memory.buffer, ptr, len);
+                target.set(tmpRetBytes);
+                tmpRetBytes = undefined;
+            }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
+
+        },
+        setInstance: (i) => {
+            instance = i;
+            memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
+        },
+        /** @param {WebAssembly.Instance} instance */
+        createExports: (instance) => {
+            const js = swift.memory.heap;
+
+            return {
+                throwsSomething: function bjs_throwsSomething() {
+                    instance.exports.bjs_throwsSomething();
+                    if (tmpRetException) {
+                        const error = swift.memory.getObject(tmpRetException);
+                        swift.memory.release(tmpRetException);
+                        tmpRetException = undefined;
+                        throw error;
+                    }
+                },
+            };
+        },
+    }
+}
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/TypeAlias.Import.js b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/TypeAlias.Import.js
index e5909f6cb..30639b4ac 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/TypeAlias.Import.js
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/TypeAlias.Import.js
@@ -7,42 +7,60 @@
 export async function createInstantiator(options, swift) {
     let instance;
     let memory;
+    let setException;
     const textDecoder = new TextDecoder("utf-8");
     const textEncoder = new TextEncoder("utf-8");
 
     let tmpRetString;
     let tmpRetBytes;
+    let tmpRetException;
     return {
         /** @param {WebAssembly.Imports} importObject */
         addImports: (importObject) => {
             const bjs = {};
             importObject["bjs"] = bjs;
-            bjs["return_string"] = function(ptr, len) {
+            bjs["swift_js_return_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 tmpRetString = textDecoder.decode(bytes);
             }
-            bjs["init_memory"] = function(sourceId, bytesPtr) {
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
                 const source = swift.memory.getObject(sourceId);
                 const bytes = new Uint8Array(memory.buffer, bytesPtr);
                 bytes.set(source);
             }
-            bjs["make_jsstring"] = function(ptr, len) {
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 return swift.memory.retain(textDecoder.decode(bytes));
             }
-            bjs["init_memory_with_result"] = function(ptr, len) {
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
                 const target = new Uint8Array(memory.buffer, ptr, len);
                 target.set(tmpRetBytes);
                 tmpRetBytes = undefined;
             }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
             const TestModule = importObject["TestModule"] = {};
             TestModule["bjs_checkSimple"] = function bjs_checkSimple(a) {
-                options.imports.checkSimple(a);
+                try {
+                    options.imports.checkSimple(a);
+                } catch (error) {
+                    setException(error);
+                }
             }
         },
         setInstance: (i) => {
             instance = i;
             memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
         },
         /** @param {WebAssembly.Instance} instance */
         createExports: (instance) => {
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/TypeScriptClass.Import.d.ts b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/TypeScriptClass.Import.d.ts
index 818d57a9d..bcbcf06f8 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/TypeScriptClass.Import.d.ts
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/TypeScriptClass.Import.d.ts
@@ -7,6 +7,9 @@
 export type Exports = {
 }
 export type Imports = {
+    Greeter: {
+        new(name: string): Greeter;
+    }
 }
 export function createInstantiator(options: {
     imports: Imports;
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/TypeScriptClass.Import.js b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/TypeScriptClass.Import.js
index c7ae6a228..f5cdc9ef3 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/TypeScriptClass.Import.js
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/TypeScriptClass.Import.js
@@ -7,49 +7,109 @@
 export async function createInstantiator(options, swift) {
     let instance;
     let memory;
+    let setException;
     const textDecoder = new TextDecoder("utf-8");
     const textEncoder = new TextEncoder("utf-8");
 
     let tmpRetString;
     let tmpRetBytes;
+    let tmpRetException;
     return {
         /** @param {WebAssembly.Imports} importObject */
         addImports: (importObject) => {
             const bjs = {};
             importObject["bjs"] = bjs;
-            bjs["return_string"] = function(ptr, len) {
+            bjs["swift_js_return_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 tmpRetString = textDecoder.decode(bytes);
             }
-            bjs["init_memory"] = function(sourceId, bytesPtr) {
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
                 const source = swift.memory.getObject(sourceId);
                 const bytes = new Uint8Array(memory.buffer, bytesPtr);
                 bytes.set(source);
             }
-            bjs["make_jsstring"] = function(ptr, len) {
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 return swift.memory.retain(textDecoder.decode(bytes));
             }
-            bjs["init_memory_with_result"] = function(ptr, len) {
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
                 const target = new Uint8Array(memory.buffer, ptr, len);
                 target.set(tmpRetBytes);
                 tmpRetBytes = undefined;
             }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
             const TestModule = importObject["TestModule"] = {};
+            TestModule["bjs_Greeter_init"] = function bjs_Greeter_init(name) {
+                try {
+                    const nameObject = swift.memory.getObject(name);
+                    swift.memory.release(name);
+                    let ret = new options.imports.Greeter(nameObject);
+                    return swift.memory.retain(ret);
+                } catch (error) {
+                    setException(error);
+                    return 0
+                }
+            }
+            TestModule["bjs_Greeter_name_get"] = function bjs_Greeter_name_get(self) {
+                try {
+                    let ret = swift.memory.getObject(self).name;
+                    tmpRetBytes = textEncoder.encode(ret);
+                    return tmpRetBytes.length;
+                } catch (error) {
+                    setException(error);
+                }
+            }
+            TestModule["bjs_Greeter_name_set"] = function bjs_Greeter_name_set(self, newValue) {
+                try {
+                    const newValueObject = swift.memory.getObject(newValue);
+                    swift.memory.release(newValue);
+                    swift.memory.getObject(self).name = newValueObject;
+                } catch (error) {
+                    setException(error);
+                }
+            }
+            TestModule["bjs_Greeter_age_get"] = function bjs_Greeter_age_get(self) {
+                try {
+                    let ret = swift.memory.getObject(self).age;
+                    return ret;
+                } catch (error) {
+                    setException(error);
+                    return 0
+                }
+            }
             TestModule["bjs_Greeter_greet"] = function bjs_Greeter_greet(self) {
-                let ret = swift.memory.getObject(self).greet();
-                tmpRetBytes = textEncoder.encode(ret);
-                return tmpRetBytes.length;
+                try {
+                    let ret = swift.memory.getObject(self).greet();
+                    tmpRetBytes = textEncoder.encode(ret);
+                    return tmpRetBytes.length;
+                } catch (error) {
+                    setException(error);
+                }
             }
             TestModule["bjs_Greeter_changeName"] = function bjs_Greeter_changeName(self, name) {
-                const nameObject = swift.memory.getObject(name);
-                swift.memory.release(name);
-                swift.memory.getObject(self).changeName(nameObject);
+                try {
+                    const nameObject = swift.memory.getObject(name);
+                    swift.memory.release(name);
+                    swift.memory.getObject(self).changeName(nameObject);
+                } catch (error) {
+                    setException(error);
+                }
             }
         },
         setInstance: (i) => {
             instance = i;
             memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
         },
         /** @param {WebAssembly.Instance} instance */
         createExports: (instance) => {
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/VoidParameterVoidReturn.Export.js b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/VoidParameterVoidReturn.Export.js
index a3dae190f..c7086edad 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/VoidParameterVoidReturn.Export.js
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/VoidParameterVoidReturn.Export.js
@@ -7,39 +7,53 @@
 export async function createInstantiator(options, swift) {
     let instance;
     let memory;
+    let setException;
     const textDecoder = new TextDecoder("utf-8");
     const textEncoder = new TextEncoder("utf-8");
 
     let tmpRetString;
     let tmpRetBytes;
+    let tmpRetException;
     return {
         /** @param {WebAssembly.Imports} importObject */
         addImports: (importObject) => {
             const bjs = {};
             importObject["bjs"] = bjs;
-            bjs["return_string"] = function(ptr, len) {
+            bjs["swift_js_return_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 tmpRetString = textDecoder.decode(bytes);
             }
-            bjs["init_memory"] = function(sourceId, bytesPtr) {
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
                 const source = swift.memory.getObject(sourceId);
                 const bytes = new Uint8Array(memory.buffer, bytesPtr);
                 bytes.set(source);
             }
-            bjs["make_jsstring"] = function(ptr, len) {
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 return swift.memory.retain(textDecoder.decode(bytes));
             }
-            bjs["init_memory_with_result"] = function(ptr, len) {
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
                 const target = new Uint8Array(memory.buffer, ptr, len);
                 target.set(tmpRetBytes);
                 tmpRetBytes = undefined;
             }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
 
         },
         setInstance: (i) => {
             instance = i;
             memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
         },
         /** @param {WebAssembly.Instance} instance */
         createExports: (instance) => {
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/VoidParameterVoidReturn.Import.js b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/VoidParameterVoidReturn.Import.js
index db9312aa6..2482082c1 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/VoidParameterVoidReturn.Import.js
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/VoidParameterVoidReturn.Import.js
@@ -7,42 +7,60 @@
 export async function createInstantiator(options, swift) {
     let instance;
     let memory;
+    let setException;
     const textDecoder = new TextDecoder("utf-8");
     const textEncoder = new TextEncoder("utf-8");
 
     let tmpRetString;
     let tmpRetBytes;
+    let tmpRetException;
     return {
         /** @param {WebAssembly.Imports} importObject */
         addImports: (importObject) => {
             const bjs = {};
             importObject["bjs"] = bjs;
-            bjs["return_string"] = function(ptr, len) {
+            bjs["swift_js_return_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 tmpRetString = textDecoder.decode(bytes);
             }
-            bjs["init_memory"] = function(sourceId, bytesPtr) {
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
                 const source = swift.memory.getObject(sourceId);
                 const bytes = new Uint8Array(memory.buffer, bytesPtr);
                 bytes.set(source);
             }
-            bjs["make_jsstring"] = function(ptr, len) {
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
                 const bytes = new Uint8Array(memory.buffer, ptr, len);
                 return swift.memory.retain(textDecoder.decode(bytes));
             }
-            bjs["init_memory_with_result"] = function(ptr, len) {
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
                 const target = new Uint8Array(memory.buffer, ptr, len);
                 target.set(tmpRetBytes);
                 tmpRetBytes = undefined;
             }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
             const TestModule = importObject["TestModule"] = {};
             TestModule["bjs_check"] = function bjs_check() {
-                options.imports.check();
+                try {
+                    options.imports.check();
+                } catch (error) {
+                    setException(error);
+                }
             }
         },
         setInstance: (i) => {
             instance = i;
             memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
         },
         /** @param {WebAssembly.Instance} instance */
         createExports: (instance) => {
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PrimitiveParameters.json b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PrimitiveParameters.json
index 4b2dafa1b..23fdeab83 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PrimitiveParameters.json
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PrimitiveParameters.json
@@ -5,6 +5,10 @@
   "functions" : [
     {
       "abiName" : "bjs_check",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
       "name" : "check",
       "parameters" : [
         {
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PrimitiveParameters.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PrimitiveParameters.swift
index 6df14156d..c686c4267 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PrimitiveParameters.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PrimitiveParameters.swift
@@ -3,13 +3,15 @@
 //
 // To update this file, just rebuild your project or run
 // `swift package bridge-js`.
-@_extern(wasm, module: "bjs", name: "return_string")
-private func _return_string(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-@_extern(wasm, module: "bjs", name: "init_memory")
-private func _init_memory(_ sourceId: Int32, _ ptr: UnsafeMutablePointer<UInt8>?)
+
+@_spi(BridgeJS) import JavaScriptKit
 
 @_expose(wasm, "bjs_check")
 @_cdecl("bjs_check")
 public func _bjs_check(a: Int32, b: Float32, c: Float64, d: Int32) -> Void {
+    #if arch(wasm32)
     check(a: Int(a), b: b, c: c, d: d == 1)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
 }
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PrimitiveReturn.json b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PrimitiveReturn.json
index ae672cb5e..f517c68a5 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PrimitiveReturn.json
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PrimitiveReturn.json
@@ -5,6 +5,10 @@
   "functions" : [
     {
       "abiName" : "bjs_checkInt",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
       "name" : "checkInt",
       "parameters" : [
 
@@ -17,6 +21,10 @@
     },
     {
       "abiName" : "bjs_checkFloat",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
       "name" : "checkFloat",
       "parameters" : [
 
@@ -29,6 +37,10 @@
     },
     {
       "abiName" : "bjs_checkDouble",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
       "name" : "checkDouble",
       "parameters" : [
 
@@ -41,6 +53,10 @@
     },
     {
       "abiName" : "bjs_checkBool",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
       "name" : "checkBool",
       "parameters" : [
 
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PrimitiveReturn.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PrimitiveReturn.swift
index a24b2b312..7356f2c85 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PrimitiveReturn.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/PrimitiveReturn.swift
@@ -3,35 +3,49 @@
 //
 // To update this file, just rebuild your project or run
 // `swift package bridge-js`.
-@_extern(wasm, module: "bjs", name: "return_string")
-private func _return_string(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-@_extern(wasm, module: "bjs", name: "init_memory")
-private func _init_memory(_ sourceId: Int32, _ ptr: UnsafeMutablePointer<UInt8>?)
+
+@_spi(BridgeJS) import JavaScriptKit
 
 @_expose(wasm, "bjs_checkInt")
 @_cdecl("bjs_checkInt")
 public func _bjs_checkInt() -> Int32 {
+    #if arch(wasm32)
     let ret = checkInt()
     return Int32(ret)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
 }
 
 @_expose(wasm, "bjs_checkFloat")
 @_cdecl("bjs_checkFloat")
 public func _bjs_checkFloat() -> Float32 {
+    #if arch(wasm32)
     let ret = checkFloat()
     return Float32(ret)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
 }
 
 @_expose(wasm, "bjs_checkDouble")
 @_cdecl("bjs_checkDouble")
 public func _bjs_checkDouble() -> Float64 {
+    #if arch(wasm32)
     let ret = checkDouble()
     return Float64(ret)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
 }
 
 @_expose(wasm, "bjs_checkBool")
 @_cdecl("bjs_checkBool")
 public func _bjs_checkBool() -> Int32 {
+    #if arch(wasm32)
     let ret = checkBool()
     return Int32(ret ? 1 : 0)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
 }
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/StringParameter.json b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/StringParameter.json
index 0fea9735c..a86fb67ef 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/StringParameter.json
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/StringParameter.json
@@ -5,6 +5,10 @@
   "functions" : [
     {
       "abiName" : "bjs_checkString",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
       "name" : "checkString",
       "parameters" : [
         {
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/StringParameter.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/StringParameter.swift
index 080f028ef..69bd66b5c 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/StringParameter.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/StringParameter.swift
@@ -3,17 +3,19 @@
 //
 // To update this file, just rebuild your project or run
 // `swift package bridge-js`.
-@_extern(wasm, module: "bjs", name: "return_string")
-private func _return_string(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-@_extern(wasm, module: "bjs", name: "init_memory")
-private func _init_memory(_ sourceId: Int32, _ ptr: UnsafeMutablePointer<UInt8>?)
+
+@_spi(BridgeJS) import JavaScriptKit
 
 @_expose(wasm, "bjs_checkString")
 @_cdecl("bjs_checkString")
 public func _bjs_checkString(aBytes: Int32, aLen: Int32) -> Void {
+    #if arch(wasm32)
     let a = String(unsafeUninitializedCapacity: Int(aLen)) { b in
-        _init_memory(aBytes, b.baseAddress.unsafelyUnwrapped)
+        _swift_js_init_memory(aBytes, b.baseAddress.unsafelyUnwrapped)
         return Int(aLen)
     }
     checkString(a: a)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
 }
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/StringReturn.json b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/StringReturn.json
index c773d0d28..b55365724 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/StringReturn.json
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/StringReturn.json
@@ -5,6 +5,10 @@
   "functions" : [
     {
       "abiName" : "bjs_checkString",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
       "name" : "checkString",
       "parameters" : [
 
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/StringReturn.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/StringReturn.swift
index bf0be042c..536f06230 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/StringReturn.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/StringReturn.swift
@@ -3,16 +3,18 @@
 //
 // To update this file, just rebuild your project or run
 // `swift package bridge-js`.
-@_extern(wasm, module: "bjs", name: "return_string")
-private func _return_string(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-@_extern(wasm, module: "bjs", name: "init_memory")
-private func _init_memory(_ sourceId: Int32, _ ptr: UnsafeMutablePointer<UInt8>?)
+
+@_spi(BridgeJS) import JavaScriptKit
 
 @_expose(wasm, "bjs_checkString")
 @_cdecl("bjs_checkString")
 public func _bjs_checkString() -> Void {
+    #if arch(wasm32)
     var ret = checkString()
     return ret.withUTF8 { ptr in
-        _return_string(ptr.baseAddress, Int32(ptr.count))
+        _swift_js_return_string(ptr.baseAddress, Int32(ptr.count))
     }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
 }
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/SwiftClass.json b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/SwiftClass.json
index 2aff4c931..d37a9254e 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/SwiftClass.json
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/SwiftClass.json
@@ -3,6 +3,10 @@
     {
       "constructor" : {
         "abiName" : "bjs_Greeter_init",
+        "effects" : {
+          "isAsync" : false,
+          "isThrows" : false
+        },
         "parameters" : [
           {
             "label" : "name",
@@ -18,6 +22,10 @@
       "methods" : [
         {
           "abiName" : "bjs_Greeter_greet",
+          "effects" : {
+            "isAsync" : false,
+            "isThrows" : false
+          },
           "name" : "greet",
           "parameters" : [
 
@@ -30,6 +38,10 @@
         },
         {
           "abiName" : "bjs_Greeter_changeName",
+          "effects" : {
+            "isAsync" : false,
+            "isThrows" : false
+          },
           "name" : "changeName",
           "parameters" : [
             {
@@ -55,6 +67,10 @@
   "functions" : [
     {
       "abiName" : "bjs_takeGreeter",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
       "name" : "takeGreeter",
       "parameters" : [
         {
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/SwiftClass.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/SwiftClass.swift
index 20fd9c94f..d8ca05f2a 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/SwiftClass.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/SwiftClass.swift
@@ -3,45 +3,59 @@
 //
 // To update this file, just rebuild your project or run
 // `swift package bridge-js`.
-@_extern(wasm, module: "bjs", name: "return_string")
-private func _return_string(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-@_extern(wasm, module: "bjs", name: "init_memory")
-private func _init_memory(_ sourceId: Int32, _ ptr: UnsafeMutablePointer<UInt8>?)
+
+@_spi(BridgeJS) import JavaScriptKit
 
 @_expose(wasm, "bjs_takeGreeter")
 @_cdecl("bjs_takeGreeter")
 public func _bjs_takeGreeter(greeter: UnsafeMutableRawPointer) -> Void {
+    #if arch(wasm32)
     takeGreeter(greeter: Unmanaged<Greeter>.fromOpaque(greeter).takeUnretainedValue())
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
 }
 
 @_expose(wasm, "bjs_Greeter_init")
 @_cdecl("bjs_Greeter_init")
 public func _bjs_Greeter_init(nameBytes: Int32, nameLen: Int32) -> UnsafeMutableRawPointer {
+    #if arch(wasm32)
     let name = String(unsafeUninitializedCapacity: Int(nameLen)) { b in
-        _init_memory(nameBytes, b.baseAddress.unsafelyUnwrapped)
+        _swift_js_init_memory(nameBytes, b.baseAddress.unsafelyUnwrapped)
         return Int(nameLen)
     }
     let ret = Greeter(name: name)
     return Unmanaged.passRetained(ret).toOpaque()
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
 }
 
 @_expose(wasm, "bjs_Greeter_greet")
 @_cdecl("bjs_Greeter_greet")
 public func _bjs_Greeter_greet(_self: UnsafeMutableRawPointer) -> Void {
+    #if arch(wasm32)
     var ret = Unmanaged<Greeter>.fromOpaque(_self).takeUnretainedValue().greet()
     return ret.withUTF8 { ptr in
-        _return_string(ptr.baseAddress, Int32(ptr.count))
+        _swift_js_return_string(ptr.baseAddress, Int32(ptr.count))
     }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
 }
 
 @_expose(wasm, "bjs_Greeter_changeName")
 @_cdecl("bjs_Greeter_changeName")
 public func _bjs_Greeter_changeName(_self: UnsafeMutableRawPointer, nameBytes: Int32, nameLen: Int32) -> Void {
+    #if arch(wasm32)
     let name = String(unsafeUninitializedCapacity: Int(nameLen)) { b in
-        _init_memory(nameBytes, b.baseAddress.unsafelyUnwrapped)
+        _swift_js_init_memory(nameBytes, b.baseAddress.unsafelyUnwrapped)
         return Int(nameLen)
     }
     Unmanaged<Greeter>.fromOpaque(_self).takeUnretainedValue().changeName(name: name)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
 }
 
 @_expose(wasm, "bjs_Greeter_deinit")
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/Throws.json b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/Throws.json
new file mode 100644
index 000000000..053632833
--- /dev/null
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/Throws.json
@@ -0,0 +1,23 @@
+{
+  "classes" : [
+
+  ],
+  "functions" : [
+    {
+      "abiName" : "bjs_throwsSomething",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : true
+      },
+      "name" : "throwsSomething",
+      "parameters" : [
+
+      ],
+      "returnType" : {
+        "void" : {
+
+        }
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/Throws.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/Throws.swift
new file mode 100644
index 000000000..8b865b7d7
--- /dev/null
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/Throws.swift
@@ -0,0 +1,31 @@
+// NOTICE: This is auto-generated code by BridgeJS from JavaScriptKit,
+// DO NOT EDIT.
+//
+// To update this file, just rebuild your project or run
+// `swift package bridge-js`.
+
+@_spi(BridgeJS) import JavaScriptKit
+
+@_expose(wasm, "bjs_throwsSomething")
+@_cdecl("bjs_throwsSomething")
+public func _bjs_throwsSomething() -> Void {
+    #if arch(wasm32)
+    do {
+        try throwsSomething()
+    } catch let error {
+        if let error = error.thrownValue.object {
+            withExtendedLifetime(error) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        } else {
+            let jsError = JSError(message: String(describing: error))
+            withExtendedLifetime(jsError.jsObject) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        }
+        return
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/VoidParameterVoidReturn.json b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/VoidParameterVoidReturn.json
index f82cdb829..96f875ab2 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/VoidParameterVoidReturn.json
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/VoidParameterVoidReturn.json
@@ -5,6 +5,10 @@
   "functions" : [
     {
       "abiName" : "bjs_check",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
       "name" : "check",
       "parameters" : [
 
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/VoidParameterVoidReturn.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/VoidParameterVoidReturn.swift
index cf4b76fe9..15e91a0b8 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/VoidParameterVoidReturn.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ExportSwiftTests/VoidParameterVoidReturn.swift
@@ -3,13 +3,15 @@
 //
 // To update this file, just rebuild your project or run
 // `swift package bridge-js`.
-@_extern(wasm, module: "bjs", name: "return_string")
-private func _return_string(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-@_extern(wasm, module: "bjs", name: "init_memory")
-private func _init_memory(_ sourceId: Int32, _ ptr: UnsafeMutablePointer<UInt8>?)
+
+@_spi(BridgeJS) import JavaScriptKit
 
 @_expose(wasm, "bjs_check")
 @_cdecl("bjs_check")
 public func _bjs_check() -> Void {
+    #if arch(wasm32)
     check()
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
 }
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/ArrayParameter.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/ArrayParameter.swift
index 1773223b7..34841ae86 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/ArrayParameter.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/ArrayParameter.swift
@@ -4,31 +4,49 @@
 // To update this file, just rebuild your project or run
 // `swift package bridge-js`.
 
-@_spi(JSObject_id) import JavaScriptKit
+@_spi(BridgeJS) import JavaScriptKit
 
-@_extern(wasm, module: "bjs", name: "make_jsstring")
-private func _make_jsstring(_ ptr: UnsafePointer<UInt8>?, _ len: Int32) -> Int32
-
-@_extern(wasm, module: "bjs", name: "init_memory_with_result")
-private func _init_memory_with_result(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-
-@_extern(wasm, module: "bjs", name: "free_jsobject")
-private func _free_jsobject(_ ptr: Int32) -> Void
-
-func checkArray(_ a: JSObject) -> Void {
+func checkArray(_ a: JSObject) throws(JSException) -> Void {
+    #if arch(wasm32)
     @_extern(wasm, module: "Check", name: "bjs_checkArray")
     func bjs_checkArray(_ a: Int32) -> Void
+    #else
+    func bjs_checkArray(_ a: Int32) -> Void {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
     bjs_checkArray(Int32(bitPattern: a.id))
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
 }
 
-func checkArrayWithLength(_ a: JSObject, _ b: Double) -> Void {
+func checkArrayWithLength(_ a: JSObject, _ b: Double) throws(JSException) -> Void {
+    #if arch(wasm32)
     @_extern(wasm, module: "Check", name: "bjs_checkArrayWithLength")
     func bjs_checkArrayWithLength(_ a: Int32, _ b: Float64) -> Void
+    #else
+    func bjs_checkArrayWithLength(_ a: Int32, _ b: Float64) -> Void {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
     bjs_checkArrayWithLength(Int32(bitPattern: a.id), b)
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
 }
 
-func checkArray(_ a: JSObject) -> Void {
+func checkArray(_ a: JSObject) throws(JSException) -> Void {
+    #if arch(wasm32)
     @_extern(wasm, module: "Check", name: "bjs_checkArray")
     func bjs_checkArray(_ a: Int32) -> Void
+    #else
+    func bjs_checkArray(_ a: Int32) -> Void {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
     bjs_checkArray(Int32(bitPattern: a.id))
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
 }
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/Interface.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/Interface.swift
index c565a2f8a..be9f524ee 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/Interface.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/Interface.swift
@@ -4,21 +4,21 @@
 // To update this file, just rebuild your project or run
 // `swift package bridge-js`.
 
-@_spi(JSObject_id) import JavaScriptKit
+@_spi(BridgeJS) import JavaScriptKit
 
-@_extern(wasm, module: "bjs", name: "make_jsstring")
-private func _make_jsstring(_ ptr: UnsafePointer<UInt8>?, _ len: Int32) -> Int32
-
-@_extern(wasm, module: "bjs", name: "init_memory_with_result")
-private func _init_memory_with_result(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-
-@_extern(wasm, module: "bjs", name: "free_jsobject")
-private func _free_jsobject(_ ptr: Int32) -> Void
-
-func returnAnimatable() -> Animatable {
+func returnAnimatable() throws(JSException) -> Animatable {
+    #if arch(wasm32)
     @_extern(wasm, module: "Check", name: "bjs_returnAnimatable")
     func bjs_returnAnimatable() -> Int32
+    #else
+    func bjs_returnAnimatable() -> Int32 {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
     let ret = bjs_returnAnimatable()
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
     return Animatable(takingThis: ret)
 }
 
@@ -33,17 +33,35 @@ struct Animatable {
         self.this = JSObject(id: UInt32(bitPattern: this))
     }
 
-    func animate(_ keyframes: JSObject, _ options: JSObject) -> JSObject {
+    func animate(_ keyframes: JSObject, _ options: JSObject) throws(JSException) -> JSObject {
+        #if arch(wasm32)
         @_extern(wasm, module: "Check", name: "bjs_Animatable_animate")
         func bjs_Animatable_animate(_ self: Int32, _ keyframes: Int32, _ options: Int32) -> Int32
+        #else
+        func bjs_Animatable_animate(_ self: Int32, _ keyframes: Int32, _ options: Int32) -> Int32 {
+            fatalError("Only available on WebAssembly")
+        }
+        #endif
         let ret = bjs_Animatable_animate(Int32(bitPattern: self.this.id), Int32(bitPattern: keyframes.id), Int32(bitPattern: options.id))
+        if let error = _swift_js_take_exception() {
+            throw error
+        }
         return JSObject(id: UInt32(bitPattern: ret))
     }
 
-    func getAnimations(_ options: JSObject) -> JSObject {
+    func getAnimations(_ options: JSObject) throws(JSException) -> JSObject {
+        #if arch(wasm32)
         @_extern(wasm, module: "Check", name: "bjs_Animatable_getAnimations")
         func bjs_Animatable_getAnimations(_ self: Int32, _ options: Int32) -> Int32
+        #else
+        func bjs_Animatable_getAnimations(_ self: Int32, _ options: Int32) -> Int32 {
+            fatalError("Only available on WebAssembly")
+        }
+        #endif
         let ret = bjs_Animatable_getAnimations(Int32(bitPattern: self.this.id), Int32(bitPattern: options.id))
+        if let error = _swift_js_take_exception() {
+            throw error
+        }
         return JSObject(id: UInt32(bitPattern: ret))
     }
 
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/PrimitiveParameters.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/PrimitiveParameters.swift
index 4ab7f754d..c47f5f40e 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/PrimitiveParameters.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/PrimitiveParameters.swift
@@ -4,19 +4,19 @@
 // To update this file, just rebuild your project or run
 // `swift package bridge-js`.
 
-@_spi(JSObject_id) import JavaScriptKit
+@_spi(BridgeJS) import JavaScriptKit
 
-@_extern(wasm, module: "bjs", name: "make_jsstring")
-private func _make_jsstring(_ ptr: UnsafePointer<UInt8>?, _ len: Int32) -> Int32
-
-@_extern(wasm, module: "bjs", name: "init_memory_with_result")
-private func _init_memory_with_result(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-
-@_extern(wasm, module: "bjs", name: "free_jsobject")
-private func _free_jsobject(_ ptr: Int32) -> Void
-
-func check(_ a: Double, _ b: Bool) -> Void {
+func check(_ a: Double, _ b: Bool) throws(JSException) -> Void {
+    #if arch(wasm32)
     @_extern(wasm, module: "Check", name: "bjs_check")
     func bjs_check(_ a: Float64, _ b: Int32) -> Void
+    #else
+    func bjs_check(_ a: Float64, _ b: Int32) -> Void {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
     bjs_check(a, Int32(b ? 1 : 0))
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
 }
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/PrimitiveReturn.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/PrimitiveReturn.swift
index a60c93239..cf26a52fa 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/PrimitiveReturn.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/PrimitiveReturn.swift
@@ -4,27 +4,36 @@
 // To update this file, just rebuild your project or run
 // `swift package bridge-js`.
 
-@_spi(JSObject_id) import JavaScriptKit
+@_spi(BridgeJS) import JavaScriptKit
 
-@_extern(wasm, module: "bjs", name: "make_jsstring")
-private func _make_jsstring(_ ptr: UnsafePointer<UInt8>?, _ len: Int32) -> Int32
-
-@_extern(wasm, module: "bjs", name: "init_memory_with_result")
-private func _init_memory_with_result(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-
-@_extern(wasm, module: "bjs", name: "free_jsobject")
-private func _free_jsobject(_ ptr: Int32) -> Void
-
-func checkNumber() -> Double {
+func checkNumber() throws(JSException) -> Double {
+    #if arch(wasm32)
     @_extern(wasm, module: "Check", name: "bjs_checkNumber")
     func bjs_checkNumber() -> Float64
+    #else
+    func bjs_checkNumber() -> Float64 {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
     let ret = bjs_checkNumber()
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
     return Double(ret)
 }
 
-func checkBoolean() -> Bool {
+func checkBoolean() throws(JSException) -> Bool {
+    #if arch(wasm32)
     @_extern(wasm, module: "Check", name: "bjs_checkBoolean")
     func bjs_checkBoolean() -> Int32
+    #else
+    func bjs_checkBoolean() -> Int32 {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
     let ret = bjs_checkBoolean()
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
     return ret == 1
 }
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/StringParameter.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/StringParameter.swift
index 491978bc0..aabffacc4 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/StringParameter.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/StringParameter.swift
@@ -4,33 +4,42 @@
 // To update this file, just rebuild your project or run
 // `swift package bridge-js`.
 
-@_spi(JSObject_id) import JavaScriptKit
+@_spi(BridgeJS) import JavaScriptKit
 
-@_extern(wasm, module: "bjs", name: "make_jsstring")
-private func _make_jsstring(_ ptr: UnsafePointer<UInt8>?, _ len: Int32) -> Int32
-
-@_extern(wasm, module: "bjs", name: "init_memory_with_result")
-private func _init_memory_with_result(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-
-@_extern(wasm, module: "bjs", name: "free_jsobject")
-private func _free_jsobject(_ ptr: Int32) -> Void
-
-func checkString(_ a: String) -> Void {
+func checkString(_ a: String) throws(JSException) -> Void {
+    #if arch(wasm32)
     @_extern(wasm, module: "Check", name: "bjs_checkString")
     func bjs_checkString(_ a: Int32) -> Void
+    #else
+    func bjs_checkString(_ a: Int32) -> Void {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
     var a = a
     let aId = a.withUTF8 { b in
-        _make_jsstring(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
+        _swift_js_make_js_string(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
     }
     bjs_checkString(aId)
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
 }
 
-func checkStringWithLength(_ a: String, _ b: Double) -> Void {
+func checkStringWithLength(_ a: String, _ b: Double) throws(JSException) -> Void {
+    #if arch(wasm32)
     @_extern(wasm, module: "Check", name: "bjs_checkStringWithLength")
     func bjs_checkStringWithLength(_ a: Int32, _ b: Float64) -> Void
+    #else
+    func bjs_checkStringWithLength(_ a: Int32, _ b: Float64) -> Void {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
     var a = a
     let aId = a.withUTF8 { b in
-        _make_jsstring(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
+        _swift_js_make_js_string(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
     }
     bjs_checkStringWithLength(aId, b)
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
 }
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/StringReturn.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/StringReturn.swift
index ce32a6433..af7b51623 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/StringReturn.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/StringReturn.swift
@@ -4,23 +4,23 @@
 // To update this file, just rebuild your project or run
 // `swift package bridge-js`.
 
-@_spi(JSObject_id) import JavaScriptKit
+@_spi(BridgeJS) import JavaScriptKit
 
-@_extern(wasm, module: "bjs", name: "make_jsstring")
-private func _make_jsstring(_ ptr: UnsafePointer<UInt8>?, _ len: Int32) -> Int32
-
-@_extern(wasm, module: "bjs", name: "init_memory_with_result")
-private func _init_memory_with_result(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-
-@_extern(wasm, module: "bjs", name: "free_jsobject")
-private func _free_jsobject(_ ptr: Int32) -> Void
-
-func checkString() -> String {
+func checkString() throws(JSException) -> String {
+    #if arch(wasm32)
     @_extern(wasm, module: "Check", name: "bjs_checkString")
     func bjs_checkString() -> Int32
+    #else
+    func bjs_checkString() -> Int32 {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
     let ret = bjs_checkString()
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
     return String(unsafeUninitializedCapacity: Int(ret)) { b in
-        _init_memory_with_result(b.baseAddress.unsafelyUnwrapped, Int32(ret))
+        _swift_js_init_memory_with_result(b.baseAddress.unsafelyUnwrapped, Int32(ret))
         return Int(ret)
     }
 }
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/TypeAlias.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/TypeAlias.swift
index 79f29c925..7523101fd 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/TypeAlias.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/TypeAlias.swift
@@ -4,19 +4,19 @@
 // To update this file, just rebuild your project or run
 // `swift package bridge-js`.
 
-@_spi(JSObject_id) import JavaScriptKit
+@_spi(BridgeJS) import JavaScriptKit
 
-@_extern(wasm, module: "bjs", name: "make_jsstring")
-private func _make_jsstring(_ ptr: UnsafePointer<UInt8>?, _ len: Int32) -> Int32
-
-@_extern(wasm, module: "bjs", name: "init_memory_with_result")
-private func _init_memory_with_result(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-
-@_extern(wasm, module: "bjs", name: "free_jsobject")
-private func _free_jsobject(_ ptr: Int32) -> Void
-
-func checkSimple(_ a: Double) -> Void {
+func checkSimple(_ a: Double) throws(JSException) -> Void {
+    #if arch(wasm32)
     @_extern(wasm, module: "Check", name: "bjs_checkSimple")
     func bjs_checkSimple(_ a: Float64) -> Void
+    #else
+    func bjs_checkSimple(_ a: Float64) -> Void {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
     bjs_checkSimple(a)
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
 }
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/TypeScriptClass.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/TypeScriptClass.swift
index 993a14173..7a1f2a2cd 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/TypeScriptClass.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/TypeScriptClass.swift
@@ -4,16 +4,7 @@
 // To update this file, just rebuild your project or run
 // `swift package bridge-js`.
 
-@_spi(JSObject_id) import JavaScriptKit
-
-@_extern(wasm, module: "bjs", name: "make_jsstring")
-private func _make_jsstring(_ ptr: UnsafePointer<UInt8>?, _ len: Int32) -> Int32
-
-@_extern(wasm, module: "bjs", name: "init_memory_with_result")
-private func _init_memory_with_result(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-
-@_extern(wasm, module: "bjs", name: "free_jsobject")
-private func _free_jsobject(_ ptr: Int32) -> Void
+@_spi(BridgeJS) import JavaScriptKit
 
 struct Greeter {
     let this: JSObject
@@ -26,35 +17,120 @@ struct Greeter {
         self.this = JSObject(id: UInt32(bitPattern: this))
     }
 
-    init(_ name: String) {
+    init(_ name: String) throws(JSException) {
+        #if arch(wasm32)
         @_extern(wasm, module: "Check", name: "bjs_Greeter_init")
         func bjs_Greeter_init(_ name: Int32) -> Int32
+        #else
+        func bjs_Greeter_init(_ name: Int32) -> Int32 {
+            fatalError("Only available on WebAssembly")
+        }
+        #endif
         var name = name
         let nameId = name.withUTF8 { b in
-            _make_jsstring(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
+            _swift_js_make_js_string(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
         }
         let ret = bjs_Greeter_init(nameId)
-        self.this = ret
+        if let error = _swift_js_take_exception() {
+            throw error
+        }
+        self.this = JSObject(id: UInt32(bitPattern: ret))
+    }
+
+    var name: String {
+        get throws(JSException) {
+            #if arch(wasm32)
+            @_extern(wasm, module: "Check", name: "bjs_Greeter_name_get")
+            func bjs_Greeter_name_get(_ self: Int32) -> Int32
+            #else
+            func bjs_Greeter_name_get(_ self: Int32) -> Int32 {
+                fatalError("Only available on WebAssembly")
+            }
+            #endif
+            let ret = bjs_Greeter_name_get(Int32(bitPattern: self.this.id))
+            if let error = _swift_js_take_exception() {
+                throw error
+            }
+            return String(unsafeUninitializedCapacity: Int(ret)) { b in
+                _swift_js_init_memory_with_result(b.baseAddress.unsafelyUnwrapped, Int32(ret))
+                return Int(ret)
+            }
+        }
+    }
+
+    func setName(_ newValue: String) throws(JSException) -> Void {
+        #if arch(wasm32)
+        @_extern(wasm, module: "Check", name: "bjs_Greeter_name_set")
+        func bjs_Greeter_name_set(_ self: Int32, _ newValue: Int32) -> Void
+        #else
+        func bjs_Greeter_name_set(_ self: Int32, _ newValue: Int32) -> Void {
+            fatalError("Only available on WebAssembly")
+        }
+        #endif
+        var newValue = newValue
+        let newValueId = newValue.withUTF8 { b in
+            _swift_js_make_js_string(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
+        }
+        bjs_Greeter_name_set(Int32(bitPattern: self.this.id), newValueId)
+        if let error = _swift_js_take_exception() {
+            throw error
+        }
+    }
+
+    var age: Double {
+        get throws(JSException) {
+            #if arch(wasm32)
+            @_extern(wasm, module: "Check", name: "bjs_Greeter_age_get")
+            func bjs_Greeter_age_get(_ self: Int32) -> Float64
+            #else
+            func bjs_Greeter_age_get(_ self: Int32) -> Float64 {
+                fatalError("Only available on WebAssembly")
+            }
+            #endif
+            let ret = bjs_Greeter_age_get(Int32(bitPattern: self.this.id))
+            if let error = _swift_js_take_exception() {
+                throw error
+            }
+            return Double(ret)
+        }
     }
 
-    func greet() -> String {
+    func greet() throws(JSException) -> String {
+        #if arch(wasm32)
         @_extern(wasm, module: "Check", name: "bjs_Greeter_greet")
         func bjs_Greeter_greet(_ self: Int32) -> Int32
+        #else
+        func bjs_Greeter_greet(_ self: Int32) -> Int32 {
+            fatalError("Only available on WebAssembly")
+        }
+        #endif
         let ret = bjs_Greeter_greet(Int32(bitPattern: self.this.id))
+        if let error = _swift_js_take_exception() {
+            throw error
+        }
         return String(unsafeUninitializedCapacity: Int(ret)) { b in
-            _init_memory_with_result(b.baseAddress.unsafelyUnwrapped, Int32(ret))
+            _swift_js_init_memory_with_result(b.baseAddress.unsafelyUnwrapped, Int32(ret))
             return Int(ret)
         }
     }
 
-    func changeName(_ name: String) -> Void {
+    func changeName(_ name: String) throws(JSException) -> Void {
+        #if arch(wasm32)
         @_extern(wasm, module: "Check", name: "bjs_Greeter_changeName")
         func bjs_Greeter_changeName(_ self: Int32, _ name: Int32) -> Void
+        #else
+        func bjs_Greeter_changeName(_ self: Int32, _ name: Int32) -> Void {
+            fatalError("Only available on WebAssembly")
+        }
+        #endif
         var name = name
         let nameId = name.withUTF8 { b in
-            _make_jsstring(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
+            _swift_js_make_js_string(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
         }
         bjs_Greeter_changeName(Int32(bitPattern: self.this.id), nameId)
+        if let error = _swift_js_take_exception() {
+            throw error
+        }
     }
 
 }
\ No newline at end of file
diff --git a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/VoidParameterVoidReturn.swift b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/VoidParameterVoidReturn.swift
index 3f2ecc78c..ae7ae0e8e 100644
--- a/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/VoidParameterVoidReturn.swift
+++ b/Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/ImportTSTests/VoidParameterVoidReturn.swift
@@ -4,19 +4,19 @@
 // To update this file, just rebuild your project or run
 // `swift package bridge-js`.
 
-@_spi(JSObject_id) import JavaScriptKit
+@_spi(BridgeJS) import JavaScriptKit
 
-@_extern(wasm, module: "bjs", name: "make_jsstring")
-private func _make_jsstring(_ ptr: UnsafePointer<UInt8>?, _ len: Int32) -> Int32
-
-@_extern(wasm, module: "bjs", name: "init_memory_with_result")
-private func _init_memory_with_result(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-
-@_extern(wasm, module: "bjs", name: "free_jsobject")
-private func _free_jsobject(_ ptr: Int32) -> Void
-
-func check() -> Void {
+func check() throws(JSException) -> Void {
+    #if arch(wasm32)
     @_extern(wasm, module: "Check", name: "bjs_check")
     func bjs_check() -> Void
+    #else
+    func bjs_check() -> Void {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
     bjs_check()
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
 }
\ No newline at end of file
diff --git a/Plugins/PackageToJS/Fixtures/ContinuationLeakInTest/SwiftTesting/Package.swift b/Plugins/PackageToJS/Fixtures/ContinuationLeakInTest/SwiftTesting/Package.swift
new file mode 100644
index 000000000..84130401a
--- /dev/null
+++ b/Plugins/PackageToJS/Fixtures/ContinuationLeakInTest/SwiftTesting/Package.swift
@@ -0,0 +1,17 @@
+// swift-tools-version: 6.0
+import PackageDescription
+
+let package = Package(
+    name: "Check",
+    dependencies: [.package(name: "JavaScriptKit", path: "../../../../../")],
+    targets: [
+        .testTarget(
+            name: "CheckTests",
+            dependencies: [
+                "JavaScriptKit",
+                .product(name: "JavaScriptEventLoopTestSupport", package: "JavaScriptKit"),
+            ],
+            path: "Tests"
+        )
+    ]
+)
diff --git a/Plugins/PackageToJS/Fixtures/ContinuationLeakInTest/SwiftTesting/Tests/CheckTests.swift b/Plugins/PackageToJS/Fixtures/ContinuationLeakInTest/SwiftTesting/Tests/CheckTests.swift
new file mode 100644
index 000000000..9ed73b7ce
--- /dev/null
+++ b/Plugins/PackageToJS/Fixtures/ContinuationLeakInTest/SwiftTesting/Tests/CheckTests.swift
@@ -0,0 +1,5 @@
+import Testing
+
+@Test func never() async throws {
+    let _: Void = await withUnsafeContinuation { _ in }
+}
diff --git a/Plugins/PackageToJS/Fixtures/ContinuationLeakInTest/XCTest/Package.swift b/Plugins/PackageToJS/Fixtures/ContinuationLeakInTest/XCTest/Package.swift
new file mode 100644
index 000000000..84130401a
--- /dev/null
+++ b/Plugins/PackageToJS/Fixtures/ContinuationLeakInTest/XCTest/Package.swift
@@ -0,0 +1,17 @@
+// swift-tools-version: 6.0
+import PackageDescription
+
+let package = Package(
+    name: "Check",
+    dependencies: [.package(name: "JavaScriptKit", path: "../../../../../")],
+    targets: [
+        .testTarget(
+            name: "CheckTests",
+            dependencies: [
+                "JavaScriptKit",
+                .product(name: "JavaScriptEventLoopTestSupport", package: "JavaScriptKit"),
+            ],
+            path: "Tests"
+        )
+    ]
+)
diff --git a/Plugins/PackageToJS/Fixtures/ContinuationLeakInTest/XCTest/Tests/CheckTests.swift b/Plugins/PackageToJS/Fixtures/ContinuationLeakInTest/XCTest/Tests/CheckTests.swift
new file mode 100644
index 000000000..324df3701
--- /dev/null
+++ b/Plugins/PackageToJS/Fixtures/ContinuationLeakInTest/XCTest/Tests/CheckTests.swift
@@ -0,0 +1,7 @@
+import XCTest
+
+final class CheckTests: XCTestCase {
+    func testNever() async throws {
+        let _: Void = await withUnsafeContinuation { _ in }
+    }
+}
diff --git a/Plugins/PackageToJS/Sources/BridgeJSSkeleton b/Plugins/PackageToJS/Sources/BridgeJSSkeleton
new file mode 120000
index 000000000..238173e9e
--- /dev/null
+++ b/Plugins/PackageToJS/Sources/BridgeJSSkeleton
@@ -0,0 +1 @@
+../../BridgeJS/Sources/BridgeJSSkeleton
\ No newline at end of file
diff --git a/Plugins/PackageToJS/Sources/PackageToJS.swift b/Plugins/PackageToJS/Sources/PackageToJS.swift
index 2b8b4458a..48f84e54d 100644
--- a/Plugins/PackageToJS/Sources/PackageToJS.swift
+++ b/Plugins/PackageToJS/Sources/PackageToJS.swift
@@ -569,8 +569,8 @@ struct PackagingPlanner {
                     "BridgeJS is still an experimental feature. Set the environment variable JAVASCRIPTKIT_EXPERIMENTAL_BRIDGEJS=1 to enable."
                 )
             }
-            let bridgeJs = outputDir.appending(path: "bridge.js")
-            let bridgeDts = outputDir.appending(path: "bridge.d.ts")
+            let bridgeJs = outputDir.appending(path: "bridge-js.js")
+            let bridgeDts = outputDir.appending(path: "bridge-js.d.ts")
             packageInputs.append(
                 make.addTask(inputFiles: exportedSkeletons + importedSkeletons, output: bridgeJs) { _, scope in
                     let link = try BridgeJSLink(
@@ -583,7 +583,8 @@ struct PackagingPlanner {
                             let decoder = JSONDecoder()
                             let data = try Data(contentsOf: URL(fileURLWithPath: scope.resolve(path: $0).path))
                             return try decoder.decode(ImportedModuleSkeleton.self, from: data)
-                        }
+                        },
+                        sharedMemory: Self.isSharedMemoryEnabled(triple: triple)
                     )
                     let (outputJs, outputDts) = try link.link()
                     try system.writeFile(atPath: scope.resolve(path: bridgeJs).path, content: Data(outputJs.utf8))
@@ -699,7 +700,7 @@ struct PackagingPlanner {
 
         let inputPath = selfPackageDir.appending(path: file)
         let conditions: [String: Bool] = [
-            "USE_SHARED_MEMORY": triple == "wasm32-unknown-wasip1-threads",
+            "USE_SHARED_MEMORY": Self.isSharedMemoryEnabled(triple: triple),
             "IS_WASI": triple.hasPrefix("wasm32-unknown-wasi"),
             "USE_WASI_CDN": options.useCDN,
             "HAS_BRIDGE": exportedSkeletons.count > 0 || importedSkeletons.count > 0,
@@ -742,6 +743,10 @@ struct PackagingPlanner {
             try system.writeFile(atPath: $1.resolve(path: $0.output).path, content: Data(content.utf8))
         }
     }
+
+    private static func isSharedMemoryEnabled(triple: String) -> Bool {
+        return triple == "wasm32-unknown-wasip1-threads"
+    }
 }
 
 // MARK: - Utilities
diff --git a/Plugins/PackageToJS/Sources/PackageToJSPlugin.swift b/Plugins/PackageToJS/Sources/PackageToJSPlugin.swift
index e7f74e974..1f15f267b 100644
--- a/Plugins/PackageToJS/Sources/PackageToJSPlugin.swift
+++ b/Plugins/PackageToJS/Sources/PackageToJSPlugin.swift
@@ -71,6 +71,31 @@ struct PackageToJSPlugin: CommandPlugin {
                         See https://book.swiftwasm.org/getting-started/setup.html for more information.
                         """
                 }),
+            (
+                // In case the SwiftPM target using BridgeJS didn't specify `.enableExperimentalFeature("Extern")`
+                { build, arguments in
+                    let possibleMessages: [String] = [
+                        "@_extern requires '-enable-experimental-feature Extern'",
+                        // Swift 6.2 and later quotes attributes in diagnostics
+                        // https://github.com/swiftlang/swift/pull/80593
+                        "'@_extern' requires '-enable-experimental-feature Extern'",
+                    ]
+                    guard possibleMessages.contains(where: build.logText.contains) else {
+                        return nil
+                    }
+                    return """
+                        The SwiftPM target using BridgeJS didn't specify `.enableExperimentalFeature("Extern")`.
+                        Please add it to the target's `swiftSettings` configuration.
+
+                        For example:
+                        ```swift
+                        dependencies: [...],
+                        swiftSettings: [
+                            .enableExperimentalFeature("Extern"),
+                        ]
+                        ```
+                        """
+                }),
         ]
 
     private func emitHintMessage(_ message: String) {
@@ -646,8 +671,8 @@ class SkeletonCollector {
 
     var exportedSkeletons: [URL] = []
     var importedSkeletons: [URL] = []
-    let exportedSkeletonFile = "ExportSwift.json"
-    let importedSkeletonFile = "ImportTS.json"
+    let exportedSkeletonFile = "BridgeJS.ExportSwift.json"
+    let importedSkeletonFile = "BridgeJS.ImportTS.json"
     let context: PluginContext
 
     init(context: PluginContext) {
@@ -688,7 +713,7 @@ class SkeletonCollector {
             let directories = [
                 target.directoryURL.appending(path: "Generated/JavaScript"),
                 // context.pluginWorkDirectoryURL: ".build/plugins/PackageToJS/outputs/"
-                // .build/plugins/outputs/exportswift/MyApp/destination/BridgeJS/ExportSwift.json
+                // .build/plugins/outputs/exportswift/MyApp/destination/BridgeJS/BridgeJS.ExportSwift.json
                 context.pluginWorkDirectoryURL.deletingLastPathComponent().deletingLastPathComponent()
                     .appending(path: "outputs/\(package.id)/\(target.name)/destination/BridgeJS"),
             ]
diff --git a/Plugins/PackageToJS/Templates/bin/test.js b/Plugins/PackageToJS/Templates/bin/test.js
index 9f6cf13a3..e7444e901 100644
--- a/Plugins/PackageToJS/Templates/bin/test.js
+++ b/Plugins/PackageToJS/Templates/bin/test.js
@@ -42,7 +42,8 @@ const harnesses = {
             let options = await nodePlatform.defaultNodeSetup({
                 args: testFrameworkArgs,
                 onExit: (code) => {
-                    if (code !== 0) {
+                    // swift-testing returns EX_UNAVAILABLE (which is 69 in wasi-libc) for "no tests found"
+                    if (code !== 0 && code !== 69) {
                         const stack = new Error().stack
                         console.error(`Test failed with exit code ${code}`)
                         console.error(stack)
@@ -64,9 +65,22 @@ const harnesses = {
             if (preludeScript) {
                 const prelude = await import(preludeScript)
                 if (prelude.setupOptions) {
-                    options = prelude.setupOptions(options, { isMainThread: true })
+                    options = await prelude.setupOptions(options, { isMainThread: true })
                 }
             }
+            process.on("beforeExit", () => {
+                // NOTE: "beforeExit" is fired when the process exits gracefully without calling `process.exit`
+                // Either XCTest or swift-testing should always call `process.exit` through `proc_exit` even
+                // if the test succeeds. So exiting gracefully means something went wrong (e.g. withUnsafeContinuation is leaked)
+                // Therefore, we exit with code 1 to indicate that the test execution failed.
+                console.error(`
+
+=================================================================================================
+Detected that the test execution ended without a termination signal from the testing framework.
+Hint: This typically means that a continuation leak occurred.
+=================================================================================================`)
+                process.exit(1)
+            })
             await instantiate(options)
         } catch (e) {
             if (e instanceof WebAssembly.CompileError) {
diff --git a/Plugins/PackageToJS/Templates/instantiate.d.ts b/Plugins/PackageToJS/Templates/instantiate.d.ts
index 11837aba8..86ea6e56f 100644
--- a/Plugins/PackageToJS/Templates/instantiate.d.ts
+++ b/Plugins/PackageToJS/Templates/instantiate.d.ts
@@ -1,8 +1,10 @@
-import type { /* #if USE_SHARED_MEMORY */SwiftRuntimeThreadChannel, /* #endif */SwiftRuntime } from "./runtime.js";
+/* #if USE_SHARED_MEMORY */
+import type { SwiftRuntimeThreadChannel } from "./runtime.js";
+/* #endif */
 
 /* #if HAS_BRIDGE */
-// @ts-ignore
-export type { Imports, Exports } from "./bridge.js";
+export type { Imports, Exports } from "./bridge-js.js";
+import type { Imports, Exports } from "./bridge-js.js";
 /* #else */
 export type Imports = {}
 export type Exports = {}
@@ -50,6 +52,12 @@ export interface WASI {
     extractFile?(path: string): Uint8Array | undefined
 }
 
+export type SwiftRuntime = {
+    UnsafeEventLoopYield: { [Symbol.hasInstance]: (value: unknown) => boolean }
+    main(): void;
+    startThread(tid: number, startArg: number): void;
+}
+
 export type ModuleSource = WebAssembly.Module | ArrayBufferView | ArrayBuffer | Response | PromiseLike<Response>
 
 /**
@@ -93,12 +101,30 @@ export type InstantiateOptions = {
     /**
      * Add imports to the WebAssembly import object
      * @param imports - The imports to add
+     * @param context - The context object
      */
     addToCoreImports?: (
         imports: WebAssembly.Imports,
-        getInstance: () => WebAssembly.Instance | null,
-        getExports: () => Exports | null,
+        context: {
+            getInstance: () => WebAssembly.Instance | null,
+            getExports: () => Exports | null,
+            _swift: SwiftRuntime,
+        }
     ) => void
+
+    /**
+     * Instrument the WebAssembly instance
+     *
+     * @param instance - The instance of the WebAssembly module
+     * @param context - The context object
+     * @returns The instrumented instance
+     */
+    instrumentInstance?: (
+        instance: WebAssembly.Instance,
+        context: {
+            _swift: SwiftRuntime
+        }
+    ) => WebAssembly.Instance
 }
 
 /**
diff --git a/Plugins/PackageToJS/Templates/instantiate.js b/Plugins/PackageToJS/Templates/instantiate.js
index 08351e67e..65996d867 100644
--- a/Plugins/PackageToJS/Templates/instantiate.js
+++ b/Plugins/PackageToJS/Templates/instantiate.js
@@ -15,7 +15,7 @@ export const MEMORY_TYPE = {
 
 /* #if HAS_BRIDGE */
 // @ts-ignore
-import { createInstantiator } from "./bridge.js"
+import { createInstantiator } from "./bridge-js.js"
 /* #else */
 /**
  * @param {import('./instantiate.d').InstantiateOptions} options
@@ -94,7 +94,11 @@ async function _instantiate(
 /* #endif */
     };
     instantiator.addImports(importObject);
-    options.addToCoreImports?.(importObject, () => instance, () => exports);
+    options.addToCoreImports?.(importObject, {
+        getInstance: () => instance,
+        getExports: () => exports,
+        _swift: swift,
+    });
 
     let module;
     let instance;
@@ -117,6 +121,7 @@ async function _instantiate(
         module = await _WebAssembly.compile(moduleSource);
         instance = await _WebAssembly.instantiate(module, importObject);
     }
+    instance = options.instrumentInstance?.(instance, { _swift: swift }) ?? instance;
 
     swift.setInstance(instance);
     instantiator.setInstance(instance);
diff --git a/Plugins/PackageToJS/Templates/platforms/node.js b/Plugins/PackageToJS/Templates/platforms/node.js
index c45bdf354..aff708be1 100644
--- a/Plugins/PackageToJS/Templates/platforms/node.js
+++ b/Plugins/PackageToJS/Templates/platforms/node.js
@@ -59,7 +59,7 @@ export function createDefaultWorkerFactory(preludeScript) {
                 if (preludeScript) {
                     const prelude = await import(preludeScript);
                     if (prelude.setupOptions) {
-                        options = prelude.setupOptions(options, { isMainThread: false })
+                        options = await prelude.setupOptions(options, { isMainThread: false })
                     }
                 }
                 await instantiateForThread(tid, startArg, {
diff --git a/Plugins/PackageToJS/Templates/runtime.d.ts b/Plugins/PackageToJS/Templates/runtime.d.ts
index 9613004cc..353db3894 100644
--- a/Plugins/PackageToJS/Templates/runtime.d.ts
+++ b/Plugins/PackageToJS/Templates/runtime.d.ts
@@ -1,24 +1,15 @@
 type ref = number;
 type pointer = number;
 
-declare class Memory {
-    readonly rawMemory: WebAssembly.Memory;
-    private readonly heap;
-    constructor(exports: WebAssembly.Exports);
-    retain: (value: any) => number;
-    getObject: (ref: number) => any;
-    release: (ref: number) => void;
-    bytes: () => Uint8Array<ArrayBuffer>;
-    dataView: () => DataView<ArrayBuffer>;
-    writeBytes: (ptr: pointer, bytes: Uint8Array) => void;
-    readUint32: (ptr: pointer) => number;
-    readUint64: (ptr: pointer) => bigint;
-    readInt64: (ptr: pointer) => bigint;
-    readFloat64: (ptr: pointer) => number;
-    writeUint32: (ptr: pointer, value: number) => void;
-    writeUint64: (ptr: pointer, value: bigint) => void;
-    writeInt64: (ptr: pointer, value: bigint) => void;
-    writeFloat64: (ptr: pointer, value: number) => void;
+declare class JSObjectSpace {
+    private _heapValueById;
+    private _heapEntryByValue;
+    private _heapNextKey;
+    constructor();
+    retain(value: any): number;
+    retainByRef(ref: ref): number;
+    release(ref: ref): void;
+    getObject(ref: ref): any;
 }
 
 /**
@@ -95,7 +86,7 @@ type SwiftRuntimeThreadChannel = {
 };
 declare class ITCInterface {
     private memory;
-    constructor(memory: Memory);
+    constructor(memory: JSObjectSpace);
     send(sendingObject: ref, transferringObjects: ref[], sendingContext: pointer): {
         object: any;
         sendingContext: pointer;
@@ -181,7 +172,7 @@ type SwiftRuntimeOptions = {
 };
 declare class SwiftRuntime {
     private _instance;
-    private _memory;
+    private readonly memory;
     private _closureDeallocator;
     private options;
     private version;
@@ -189,6 +180,9 @@ declare class SwiftRuntime {
     private textEncoder;
     /** The thread ID of the current thread. */
     private tid;
+    private getDataView;
+    private getUint8Array;
+    private wasmMemory;
     UnsafeEventLoopYield: typeof UnsafeEventLoopYield;
     constructor(options?: SwiftRuntimeOptions);
     setInstance(instance: WebAssembly.Instance): void;
@@ -201,7 +195,6 @@ declare class SwiftRuntime {
     startThread(tid: number, startArg: number): void;
     private get instance();
     private get exports();
-    private get memory();
     private get closureDeallocator();
     private callHostFunction;
     /** @deprecated Use `wasmImports` instead */
diff --git a/Plugins/PackageToJS/Templates/runtime.mjs b/Plugins/PackageToJS/Templates/runtime.mjs
index 71f7f9a30..447f20906 100644
--- a/Plugins/PackageToJS/Templates/runtime.mjs
+++ b/Plugins/PackageToJS/Templates/runtime.mjs
@@ -21,7 +21,7 @@ function assertNever(x, message) {
 }
 const MAIN_THREAD_TID = -1;
 
-const decode = (kind, payload1, payload2, memory) => {
+const decode = (kind, payload1, payload2, objectSpace) => {
     switch (kind) {
         case 0 /* Kind.Boolean */:
             switch (payload1) {
@@ -37,7 +37,7 @@ const decode = (kind, payload1, payload2, memory) => {
         case 6 /* Kind.Function */:
         case 7 /* Kind.Symbol */:
         case 8 /* Kind.BigInt */:
-            return memory.getObject(payload1);
+            return objectSpace.getObject(payload1);
         case 4 /* Kind.Null */:
             return null;
         case 5 /* Kind.Undefined */:
@@ -48,21 +48,18 @@ const decode = (kind, payload1, payload2, memory) => {
 };
 // Note:
 // `decodeValues` assumes that the size of RawJSValue is 16.
-const decodeArray = (ptr, length, memory) => {
+const decodeArray = (ptr, length, memory, objectSpace) => {
     // fast path for empty array
     if (length === 0) {
         return [];
     }
     let result = [];
-    // It's safe to hold DataView here because WebAssembly.Memory.buffer won't
-    // change within this function.
-    const view = memory.dataView();
     for (let index = 0; index < length; index++) {
         const base = ptr + 16 * index;
-        const kind = view.getUint32(base, true);
-        const payload1 = view.getUint32(base + 4, true);
-        const payload2 = view.getFloat64(base + 8, true);
-        result.push(decode(kind, payload1, payload2, memory));
+        const kind = memory.getUint32(base, true);
+        const payload1 = memory.getUint32(base + 4, true);
+        const payload2 = memory.getFloat64(base + 8, true);
+        result.push(decode(kind, payload1, payload2, objectSpace));
     }
     return result;
 };
@@ -70,27 +67,27 @@ const decodeArray = (ptr, length, memory) => {
 // Please prefer to use `writeAndReturnKindBits` to avoid unnecessary
 // memory stores.
 // This function should be used only when kind flag is stored in memory.
-const write = (value, kind_ptr, payload1_ptr, payload2_ptr, is_exception, memory) => {
-    const kind = writeAndReturnKindBits(value, payload1_ptr, payload2_ptr, is_exception, memory);
-    memory.writeUint32(kind_ptr, kind);
+const write = (value, kind_ptr, payload1_ptr, payload2_ptr, is_exception, memory, objectSpace) => {
+    const kind = writeAndReturnKindBits(value, payload1_ptr, payload2_ptr, is_exception, memory, objectSpace);
+    memory.setUint32(kind_ptr, kind, true);
 };
-const writeAndReturnKindBits = (value, payload1_ptr, payload2_ptr, is_exception, memory) => {
+const writeAndReturnKindBits = (value, payload1_ptr, payload2_ptr, is_exception, memory, objectSpace) => {
     const exceptionBit = (is_exception ? 1 : 0) << 31;
     if (value === null) {
         return exceptionBit | 4 /* Kind.Null */;
     }
     const writeRef = (kind) => {
-        memory.writeUint32(payload1_ptr, memory.retain(value));
+        memory.setUint32(payload1_ptr, objectSpace.retain(value), true);
         return exceptionBit | kind;
     };
     const type = typeof value;
     switch (type) {
         case "boolean": {
-            memory.writeUint32(payload1_ptr, value ? 1 : 0);
+            memory.setUint32(payload1_ptr, value ? 1 : 0, true);
             return exceptionBit | 0 /* Kind.Boolean */;
         }
         case "number": {
-            memory.writeFloat64(payload2_ptr, value);
+            memory.setFloat64(payload2_ptr, value, true);
             return exceptionBit | 2 /* Kind.Number */;
         }
         case "string": {
@@ -119,84 +116,11 @@ const writeAndReturnKindBits = (value, payload1_ptr, payload2_ptr, is_exception,
 function decodeObjectRefs(ptr, length, memory) {
     const result = new Array(length);
     for (let i = 0; i < length; i++) {
-        result[i] = memory.readUint32(ptr + 4 * i);
+        result[i] = memory.getUint32(ptr + 4 * i, true);
     }
     return result;
 }
 
-let globalVariable;
-if (typeof globalThis !== "undefined") {
-    globalVariable = globalThis;
-}
-else if (typeof window !== "undefined") {
-    globalVariable = window;
-}
-else if (typeof global !== "undefined") {
-    globalVariable = global;
-}
-else if (typeof self !== "undefined") {
-    globalVariable = self;
-}
-
-class SwiftRuntimeHeap {
-    constructor() {
-        this._heapValueById = new Map();
-        this._heapValueById.set(0, globalVariable);
-        this._heapEntryByValue = new Map();
-        this._heapEntryByValue.set(globalVariable, { id: 0, rc: 1 });
-        // Note: 0 is preserved for global
-        this._heapNextKey = 1;
-    }
-    retain(value) {
-        const entry = this._heapEntryByValue.get(value);
-        if (entry) {
-            entry.rc++;
-            return entry.id;
-        }
-        const id = this._heapNextKey++;
-        this._heapValueById.set(id, value);
-        this._heapEntryByValue.set(value, { id: id, rc: 1 });
-        return id;
-    }
-    release(ref) {
-        const value = this._heapValueById.get(ref);
-        const entry = this._heapEntryByValue.get(value);
-        entry.rc--;
-        if (entry.rc != 0)
-            return;
-        this._heapEntryByValue.delete(value);
-        this._heapValueById.delete(ref);
-    }
-    referenceHeap(ref) {
-        const value = this._heapValueById.get(ref);
-        if (value === undefined) {
-            throw new ReferenceError("Attempted to read invalid reference " + ref);
-        }
-        return value;
-    }
-}
-
-class Memory {
-    constructor(exports) {
-        this.heap = new SwiftRuntimeHeap();
-        this.retain = (value) => this.heap.retain(value);
-        this.getObject = (ref) => this.heap.referenceHeap(ref);
-        this.release = (ref) => this.heap.release(ref);
-        this.bytes = () => new Uint8Array(this.rawMemory.buffer);
-        this.dataView = () => new DataView(this.rawMemory.buffer);
-        this.writeBytes = (ptr, bytes) => this.bytes().set(bytes, ptr);
-        this.readUint32 = (ptr) => this.dataView().getUint32(ptr, true);
-        this.readUint64 = (ptr) => this.dataView().getBigUint64(ptr, true);
-        this.readInt64 = (ptr) => this.dataView().getBigInt64(ptr, true);
-        this.readFloat64 = (ptr) => this.dataView().getFloat64(ptr, true);
-        this.writeUint32 = (ptr, value) => this.dataView().setUint32(ptr, value, true);
-        this.writeUint64 = (ptr, value) => this.dataView().setBigUint64(ptr, value, true);
-        this.writeInt64 = (ptr, value) => this.dataView().setBigInt64(ptr, value, true);
-        this.writeFloat64 = (ptr, value) => this.dataView().setFloat64(ptr, value, true);
-        this.rawMemory = exports.memory;
-    }
-}
-
 class ITCInterface {
     constructor(memory) {
         this.memory = memory;
@@ -301,6 +225,61 @@ function deserializeError(error) {
     return error.value;
 }
 
+let globalVariable;
+if (typeof globalThis !== "undefined") {
+    globalVariable = globalThis;
+}
+else if (typeof window !== "undefined") {
+    globalVariable = window;
+}
+else if (typeof global !== "undefined") {
+    globalVariable = global;
+}
+else if (typeof self !== "undefined") {
+    globalVariable = self;
+}
+
+class JSObjectSpace {
+    constructor() {
+        this._heapValueById = new Map();
+        this._heapValueById.set(1, globalVariable);
+        this._heapEntryByValue = new Map();
+        this._heapEntryByValue.set(globalVariable, { id: 1, rc: 1 });
+        // Note: 0 is preserved for invalid references, 1 is preserved for globalThis
+        this._heapNextKey = 2;
+    }
+    retain(value) {
+        const entry = this._heapEntryByValue.get(value);
+        if (entry) {
+            entry.rc++;
+            return entry.id;
+        }
+        const id = this._heapNextKey++;
+        this._heapValueById.set(id, value);
+        this._heapEntryByValue.set(value, { id: id, rc: 1 });
+        return id;
+    }
+    retainByRef(ref) {
+        return this.retain(this.getObject(ref));
+    }
+    release(ref) {
+        const value = this._heapValueById.get(ref);
+        const entry = this._heapEntryByValue.get(value);
+        entry.rc--;
+        if (entry.rc != 0)
+            return;
+        this._heapEntryByValue.delete(value);
+        this._heapValueById.delete(ref);
+    }
+    getObject(ref) {
+        const value = this._heapValueById.get(ref);
+        if (value === undefined) {
+            throw new ReferenceError("Attempted to read invalid reference " + ref);
+        }
+        return value;
+    }
+}
+
 class SwiftRuntime {
     constructor(options) {
         this.version = 708;
@@ -310,13 +289,69 @@ class SwiftRuntime {
         /** @deprecated Use `wasmImports` instead */
         this.importObjects = () => this.wasmImports;
         this._instance = null;
-        this._memory = null;
+        this.memory = new JSObjectSpace();
         this._closureDeallocator = null;
         this.tid = null;
         this.options = options || {};
+        this.getDataView = () => {
+            throw new Error("Please call setInstance() before using any JavaScriptKit APIs from Swift.");
+        };
+        this.getUint8Array = () => {
+            throw new Error("Please call setInstance() before using any JavaScriptKit APIs from Swift.");
+        };
+        this.wasmMemory = null;
     }
     setInstance(instance) {
         this._instance = instance;
+        const wasmMemory = instance.exports.memory;
+        if (wasmMemory instanceof WebAssembly.Memory) {
+            // Cache the DataView as it's not a cheap operation
+            let cachedDataView = new DataView(wasmMemory.buffer);
+            let cachedUint8Array = new Uint8Array(wasmMemory.buffer);
+            // Check the constructor name of the buffer to determine if it's backed by a SharedArrayBuffer.
+            // We can't reference SharedArrayBuffer directly here because:
+            // 1. It may not be available in the global scope if the context is not cross-origin isolated.
+            // 2. The underlying buffer may be still backed by SAB even if the context is not cross-origin
+            //    isolated (e.g. localhost on Chrome on Android).
+            if (Object.getPrototypeOf(wasmMemory.buffer).constructor.name === "SharedArrayBuffer") {
+                // When the wasm memory is backed by a SharedArrayBuffer, growing the memory
+                // doesn't invalidate the data view by setting the byte length to 0. Instead,
+                // the data view points to an old buffer after growing the memory. So we have
+                // to check the buffer identity to determine if the data view is valid.
+                this.getDataView = () => {
+                    if (cachedDataView.buffer !== wasmMemory.buffer) {
+                        cachedDataView = new DataView(wasmMemory.buffer);
+                    }
+                    return cachedDataView;
+                };
+                this.getUint8Array = () => {
+                    if (cachedUint8Array.buffer !== wasmMemory.buffer) {
+                        cachedUint8Array = new Uint8Array(wasmMemory.buffer);
+                    }
+                    return cachedUint8Array;
+                };
+            }
+            else {
+                this.getDataView = () => {
+                    if (cachedDataView.buffer.byteLength === 0) {
+                        // If the wasm memory is grown, the data view is invalidated,
+                        // so we need to create a new data view.
+                        cachedDataView = new DataView(wasmMemory.buffer);
+                    }
+                    return cachedDataView;
+                };
+                this.getUint8Array = () => {
+                    if (cachedUint8Array.byteLength === 0) {
+                        cachedUint8Array = new Uint8Array(wasmMemory.buffer);
+                    }
+                    return cachedUint8Array;
+                };
+            }
+            this.wasmMemory = wasmMemory;
+        }
+        else {
+            throw new Error("instance.exports.memory is not a WebAssembly.Memory!?");
+        }
         if (typeof this.exports._start === "function") {
             throw new Error(`JavaScriptKit supports only WASI reactor ABI.
                 Please make sure you are building with:
@@ -381,12 +416,6 @@ class SwiftRuntime {
     get exports() {
         return this.instance.exports;
     }
-    get memory() {
-        if (!this._memory) {
-            this._memory = new Memory(this.instance.exports);
-        }
-        return this._memory;
-    }
     get closureDeallocator() {
         if (this._closureDeallocator)
             return this._closureDeallocator;
@@ -401,10 +430,11 @@ class SwiftRuntime {
         const argc = args.length;
         const argv = this.exports.swjs_prepare_host_function_call(argc);
         const memory = this.memory;
+        const dataView = this.getDataView();
         for (let index = 0; index < args.length; index++) {
             const argument = args[index];
             const base = argv + 16 * index;
-            write(argument, base, base + 4, base + 8, false, memory);
+            write(argument, base, base + 4, base + 8, false, dataView, memory);
         }
         let output;
         // This ref is released by the swjs_call_host_function implementation
@@ -483,7 +513,7 @@ class SwiftRuntime {
                 const obj = memory.getObject(ref);
                 const key = memory.getObject(name);
                 const result = obj[key];
-                return writeAndReturnKindBits(result, payload1_ptr, payload2_ptr, false, memory);
+                return writeAndReturnKindBits(result, payload1_ptr, payload2_ptr, false, this.getDataView(), this.memory);
             },
             swjs_set_subscript: (ref, index, kind, payload1, payload2) => {
                 const memory = this.memory;
@@ -494,58 +524,53 @@ class SwiftRuntime {
             swjs_get_subscript: (ref, index, payload1_ptr, payload2_ptr) => {
                 const obj = this.memory.getObject(ref);
                 const result = obj[index];
-                return writeAndReturnKindBits(result, payload1_ptr, payload2_ptr, false, this.memory);
+                return writeAndReturnKindBits(result, payload1_ptr, payload2_ptr, false, this.getDataView(), this.memory);
             },
             swjs_encode_string: (ref, bytes_ptr_result) => {
                 const memory = this.memory;
                 const bytes = this.textEncoder.encode(memory.getObject(ref));
                 const bytes_ptr = memory.retain(bytes);
-                memory.writeUint32(bytes_ptr_result, bytes_ptr);
+                this.getDataView().setUint32(bytes_ptr_result, bytes_ptr, true);
                 return bytes.length;
             },
             swjs_decode_string: (
             // NOTE: TextDecoder can't decode typed arrays backed by SharedArrayBuffer
             this.options.sharedMemory == true
                 ? ((bytes_ptr, length) => {
-                    const memory = this.memory;
-                    const bytes = memory
-                        .bytes()
+                    const bytes = this.getUint8Array()
                         .slice(bytes_ptr, bytes_ptr + length);
                     const string = this.textDecoder.decode(bytes);
-                    return memory.retain(string);
+                    return this.memory.retain(string);
                 })
                 : ((bytes_ptr, length) => {
-                    const memory = this.memory;
-                    const bytes = memory
-                        .bytes()
+                    const bytes = this.getUint8Array()
                         .subarray(bytes_ptr, bytes_ptr + length);
                     const string = this.textDecoder.decode(bytes);
-                    return memory.retain(string);
+                    return this.memory.retain(string);
                 })),
             swjs_load_string: (ref, buffer) => {
-                const memory = this.memory;
-                const bytes = memory.getObject(ref);
-                memory.writeBytes(buffer, bytes);
+                const bytes = this.memory.getObject(ref);
+                this.getUint8Array().set(bytes, buffer);
             },
             swjs_call_function: (ref, argv, argc, payload1_ptr, payload2_ptr) => {
                 const memory = this.memory;
                 const func = memory.getObject(ref);
                 let result = undefined;
                 try {
-                    const args = decodeArray(argv, argc, memory);
+                    const args = decodeArray(argv, argc, this.getDataView(), memory);
                     result = func(...args);
                 }
                 catch (error) {
-                    return writeAndReturnKindBits(error, payload1_ptr, payload2_ptr, true, this.memory);
+                    return writeAndReturnKindBits(error, payload1_ptr, payload2_ptr, true, this.getDataView(), this.memory);
                 }
-                return writeAndReturnKindBits(result, payload1_ptr, payload2_ptr, false, this.memory);
+                return writeAndReturnKindBits(result, payload1_ptr, payload2_ptr, false, this.getDataView(), this.memory);
             },
             swjs_call_function_no_catch: (ref, argv, argc, payload1_ptr, payload2_ptr) => {
                 const memory = this.memory;
                 const func = memory.getObject(ref);
-                const args = decodeArray(argv, argc, memory);
+                const args = decodeArray(argv, argc, this.getDataView(), memory);
                 const result = func(...args);
-                return writeAndReturnKindBits(result, payload1_ptr, payload2_ptr, false, this.memory);
+                return writeAndReturnKindBits(result, payload1_ptr, payload2_ptr, false, this.getDataView(), this.memory);
             },
             swjs_call_function_with_this: (obj_ref, func_ref, argv, argc, payload1_ptr, payload2_ptr) => {
                 const memory = this.memory;
@@ -553,27 +578,27 @@ class SwiftRuntime {
                 const func = memory.getObject(func_ref);
                 let result;
                 try {
-                    const args = decodeArray(argv, argc, memory);
+                    const args = decodeArray(argv, argc, this.getDataView(), memory);
                     result = func.apply(obj, args);
                 }
                 catch (error) {
-                    return writeAndReturnKindBits(error, payload1_ptr, payload2_ptr, true, this.memory);
+                    return writeAndReturnKindBits(error, payload1_ptr, payload2_ptr, true, this.getDataView(), this.memory);
                 }
-                return writeAndReturnKindBits(result, payload1_ptr, payload2_ptr, false, this.memory);
+                return writeAndReturnKindBits(result, payload1_ptr, payload2_ptr, false, this.getDataView(), this.memory);
             },
             swjs_call_function_with_this_no_catch: (obj_ref, func_ref, argv, argc, payload1_ptr, payload2_ptr) => {
                 const memory = this.memory;
                 const obj = memory.getObject(obj_ref);
                 const func = memory.getObject(func_ref);
                 let result = undefined;
-                const args = decodeArray(argv, argc, memory);
+                const args = decodeArray(argv, argc, this.getDataView(), memory);
                 result = func.apply(obj, args);
-                return writeAndReturnKindBits(result, payload1_ptr, payload2_ptr, false, this.memory);
+                return writeAndReturnKindBits(result, payload1_ptr, payload2_ptr, false, this.getDataView(), this.memory);
             },
             swjs_call_new: (ref, argv, argc) => {
                 const memory = this.memory;
                 const constructor = memory.getObject(ref);
-                const args = decodeArray(argv, argc, memory);
+                const args = decodeArray(argv, argc, this.getDataView(), memory);
                 const instance = new constructor(...args);
                 return this.memory.retain(instance);
             },
@@ -582,15 +607,15 @@ class SwiftRuntime {
                 const constructor = memory.getObject(ref);
                 let result;
                 try {
-                    const args = decodeArray(argv, argc, memory);
+                    const args = decodeArray(argv, argc, this.getDataView(), memory);
                     result = new constructor(...args);
                 }
                 catch (error) {
-                    write(error, exception_kind_ptr, exception_payload1_ptr, exception_payload2_ptr, true, this.memory);
+                    write(error, exception_kind_ptr, exception_payload1_ptr, exception_payload2_ptr, true, this.getDataView(), this.memory);
                     return -1;
                 }
                 memory = this.memory;
-                write(null, exception_kind_ptr, exception_payload1_ptr, exception_payload2_ptr, false, memory);
+                write(null, exception_kind_ptr, exception_payload1_ptr, exception_payload2_ptr, false, this.getDataView(), memory);
                 return memory.retain(result);
             },
             swjs_instanceof: (obj_ref, constructor_ref) => {
@@ -624,7 +649,7 @@ class SwiftRuntime {
                     // See https://github.com/swiftwasm/swift/issues/5599
                     return this.memory.retain(new ArrayType());
                 }
-                const array = new ArrayType(this.memory.rawMemory.buffer, elementsPtr, length);
+                const array = new ArrayType(this.wasmMemory.buffer, elementsPtr, length);
                 // Call `.slice()` to copy the memory
                 return this.memory.retain(array.slice());
             },
@@ -633,7 +658,7 @@ class SwiftRuntime {
                 const memory = this.memory;
                 const typedArray = memory.getObject(ref);
                 const bytes = new Uint8Array(typedArray.buffer);
-                memory.writeBytes(buffer, bytes);
+                this.getUint8Array().set(bytes, buffer);
             },
             swjs_release: (ref) => {
                 this.memory.release(ref);
@@ -756,8 +781,7 @@ class SwiftRuntime {
                     throw new Error("threadChannel is not set in options given to SwiftRuntime. Please set it to request transferring objects.");
                 }
                 const broker = getMessageBroker(this.options.threadChannel);
-                const memory = this.memory;
-                const transferringObjects = decodeObjectRefs(transferring_objects, transferring_objects_count, memory);
+                const transferringObjects = decodeObjectRefs(transferring_objects, transferring_objects_count, this.getDataView());
                 broker.request({
                     type: "request",
                     data: {
@@ -777,9 +801,9 @@ class SwiftRuntime {
                     throw new Error("threadChannel is not set in options given to SwiftRuntime. Please set it to request transferring objects.");
                 }
                 const broker = getMessageBroker(this.options.threadChannel);
-                const memory = this.memory;
-                const sendingObjects = decodeObjectRefs(sending_objects, sending_objects_count, memory);
-                const transferringObjects = decodeObjectRefs(transferring_objects, transferring_objects_count, memory);
+                const dataView = this.getDataView();
+                const sendingObjects = decodeObjectRefs(sending_objects, sending_objects_count, dataView);
+                const transferringObjects = decodeObjectRefs(transferring_objects, transferring_objects_count, dataView);
                 broker.request({
                     type: "request",
                     data: {
diff --git a/Plugins/PackageToJS/Templates/test.d.ts b/Plugins/PackageToJS/Templates/test.d.ts
index 2968f6dd9..21383997b 100644
--- a/Plugins/PackageToJS/Templates/test.d.ts
+++ b/Plugins/PackageToJS/Templates/test.d.ts
@@ -1,5 +1,12 @@
 import type { InstantiateOptions, instantiate } from "./instantiate";
 
+export type SetupOptionsFn = (
+    options: InstantiateOptions,
+    context: {
+        isMainThread: boolean,
+    }
+) => Promise<InstantiateOptions>
+
 export function testBrowser(
     options: {
         preludeScript?: string,
diff --git a/Plugins/PackageToJS/Templates/test.js b/Plugins/PackageToJS/Templates/test.js
index 8c4432492..518dacf20 100644
--- a/Plugins/PackageToJS/Templates/test.js
+++ b/Plugins/PackageToJS/Templates/test.js
@@ -157,6 +157,7 @@ export async function testBrowserInPage(options, processInfo) {
     });
 
     const { instantiate } = await import("./instantiate.js");
+    /** @type {import('./test.d.ts').SetupOptionsFn} */
     let setupOptions = (options, _) => { return options };
     if (processInfo.preludeScript) {
         const prelude = await import(processInfo.preludeScript);
@@ -171,8 +172,8 @@ export async function testBrowserInPage(options, processInfo) {
         // Instantiate the WebAssembly file
         return await instantiate({
             ...options,
-            addToCoreImports: (imports) => {
-                options.addToCoreImports?.(imports);
+            addToCoreImports: (imports, context) => {
+                options.addToCoreImports?.(imports, context);
                 imports["wasi_snapshot_preview1"]["proc_exit"] = (code) => {
                     exitTest(code);
                     throw new ExitError(code);
diff --git a/Plugins/PackageToJS/Tests/ExampleTests.swift b/Plugins/PackageToJS/Tests/ExampleTests.swift
index ab0d1d798..d860a685f 100644
--- a/Plugins/PackageToJS/Tests/ExampleTests.swift
+++ b/Plugins/PackageToJS/Tests/ExampleTests.swift
@@ -88,7 +88,6 @@ extension Trait where Self == ConditionTrait {
                     atPath: destinationPath.path,
                     withDestinationPath: linkDestination
                 )
-                enumerator.skipDescendants()
                 continue
             }
 
@@ -117,8 +116,11 @@ extension Trait where Self == ConditionTrait {
     typealias RunProcess = (_ executableURL: URL, _ args: [String], _ env: [String: String]) throws -> Void
     typealias RunSwift = (_ args: [String], _ env: [String: String]) throws -> Void
 
-    func withPackage(at path: String, body: (URL, _ runProcess: RunProcess, _ runSwift: RunSwift) throws -> Void) throws
-    {
+    func withPackage(
+        at path: String,
+        assertTerminationStatus: (Int32) -> Bool = { $0 == 0 },
+        body: @escaping (URL, _ runProcess: RunProcess, _ runSwift: RunSwift) throws -> Void
+    ) throws {
         try withTemporaryDirectory { tempDir, retain in
             let destination = tempDir.appending(path: Self.repoPath.lastPathComponent)
             try Self.copyRepository(to: destination)
@@ -139,11 +141,11 @@ extension Trait where Self == ConditionTrait {
 
                 try process.run()
                 process.waitUntilExit()
-                if process.terminationStatus != 0 {
+                if !assertTerminationStatus(process.terminationStatus) {
                     retain = true
                 }
                 try #require(
-                    process.terminationStatus == 0,
+                    assertTerminationStatus(process.terminationStatus),
                     """
                     Swift package should build successfully, check \(destination.appending(path: path).path) for details
                     stdout: \(stdoutPath.path)
@@ -275,4 +277,29 @@ extension Trait where Self == ConditionTrait {
             )
         }
     }
+
+    @Test(.requireSwiftSDK)
+    func continuationLeakInTest_XCTest() throws {
+        let swiftSDKID = try #require(Self.getSwiftSDKID())
+        try withPackage(
+            at: "Plugins/PackageToJS/Fixtures/ContinuationLeakInTest/XCTest",
+            assertTerminationStatus: { $0 != 0 }
+        ) { packageDir, _, runSwift in
+            try runSwift(["package", "--disable-sandbox", "--swift-sdk", swiftSDKID, "js", "test"], [:])
+        }
+    }
+
+    #if compiler(>=6.1)
+    // TODO: Remove triple restriction once swift-testing is shipped in p1-threads SDK
+    @Test(.requireSwiftSDK(triple: "wasm32-unknown-wasi"))
+    func continuationLeakInTest_SwiftTesting() throws {
+        let swiftSDKID = try #require(Self.getSwiftSDKID())
+        try withPackage(
+            at: "Plugins/PackageToJS/Fixtures/ContinuationLeakInTest/SwiftTesting",
+            assertTerminationStatus: { $0 != 0 }
+        ) { packageDir, _, runSwift in
+            try runSwift(["package", "--disable-sandbox", "--swift-sdk", swiftSDKID, "js", "test"], [:])
+        }
+    }
+    #endif
 }
diff --git a/Runtime/src/index.ts b/Runtime/src/index.ts
index a747dec1f..199db33d6 100644
--- a/Runtime/src/index.ts
+++ b/Runtime/src/index.ts
@@ -7,9 +7,9 @@ import {
     MAIN_THREAD_TID,
 } from "./types.js";
 import * as JSValue from "./js-value.js";
-import { Memory } from "./memory.js";
 import { deserializeError, MainToWorkerMessage, MessageBroker, ResponseMessage, ITCInterface, serializeError, SwiftRuntimeThreadChannel, WorkerToMainMessage } from "./itc.js";
 import { decodeObjectRefs } from "./js-value.js";
+import { JSObjectSpace } from "./object-heap.js";
 export { SwiftRuntimeThreadChannel };
 
 export type SwiftRuntimeOptions = {
@@ -27,7 +27,7 @@ export type SwiftRuntimeOptions = {
 
 export class SwiftRuntime {
     private _instance: WebAssembly.Instance | null;
-    private _memory: Memory | null;
+    private readonly memory: JSObjectSpace;
     private _closureDeallocator: SwiftClosureDeallocator | null;
     private options: SwiftRuntimeOptions;
     private version: number = 708;
@@ -36,19 +36,77 @@ export class SwiftRuntime {
     private textEncoder = new TextEncoder(); // Only support utf-8
     /** The thread ID of the current thread. */
     private tid: number | null;
+    private getDataView: (() => DataView);
+    private getUint8Array: (() => Uint8Array);
+    private wasmMemory: WebAssembly.Memory | null;
 
     UnsafeEventLoopYield = UnsafeEventLoopYield;
 
     constructor(options?: SwiftRuntimeOptions) {
         this._instance = null;
-        this._memory = null;
+        this.memory = new JSObjectSpace();
         this._closureDeallocator = null;
         this.tid = null;
         this.options = options || {};
+        this.getDataView = () => {
+            throw new Error("Please call setInstance() before using any JavaScriptKit APIs from Swift.");
+        };
+        this.getUint8Array = () => {
+            throw new Error("Please call setInstance() before using any JavaScriptKit APIs from Swift.");
+        };
+        this.wasmMemory = null;
     }
 
     setInstance(instance: WebAssembly.Instance) {
         this._instance = instance;
+        const wasmMemory = instance.exports.memory;
+        if (wasmMemory instanceof WebAssembly.Memory) {
+            // Cache the DataView as it's not a cheap operation
+            let cachedDataView = new DataView(wasmMemory.buffer);
+            let cachedUint8Array = new Uint8Array(wasmMemory.buffer);
+
+            // Check the constructor name of the buffer to determine if it's backed by a SharedArrayBuffer.
+            // We can't reference SharedArrayBuffer directly here because:
+            // 1. It may not be available in the global scope if the context is not cross-origin isolated.
+            // 2. The underlying buffer may be still backed by SAB even if the context is not cross-origin
+            //    isolated (e.g. localhost on Chrome on Android).
+            if (Object.getPrototypeOf(wasmMemory.buffer).constructor.name === "SharedArrayBuffer") {
+                // When the wasm memory is backed by a SharedArrayBuffer, growing the memory
+                // doesn't invalidate the data view by setting the byte length to 0. Instead,
+                // the data view points to an old buffer after growing the memory. So we have
+                // to check the buffer identity to determine if the data view is valid.
+                this.getDataView = () => {
+                    if (cachedDataView.buffer !== wasmMemory.buffer) {
+                        cachedDataView = new DataView(wasmMemory.buffer);
+                    }
+                    return cachedDataView;
+                };
+                this.getUint8Array = () => {
+                    if (cachedUint8Array.buffer !== wasmMemory.buffer) {
+                        cachedUint8Array = new Uint8Array(wasmMemory.buffer);
+                    }
+                    return cachedUint8Array;
+                };
+            } else {
+                this.getDataView = () => {
+                    if (cachedDataView.buffer.byteLength === 0) {
+                        // If the wasm memory is grown, the data view is invalidated,
+                        // so we need to create a new data view.
+                        cachedDataView = new DataView(wasmMemory.buffer);
+                    }
+                    return cachedDataView;
+                };
+                this.getUint8Array = () => {
+                    if (cachedUint8Array.byteLength === 0) {
+                        cachedUint8Array = new Uint8Array(wasmMemory.buffer);
+                    }
+                    return cachedUint8Array;
+                };
+            }
+            this.wasmMemory = wasmMemory;
+        } else {
+            throw new Error("instance.exports.memory is not a WebAssembly.Memory!?");
+        }
         if (typeof (this.exports as any)._start === "function") {
             throw new Error(
                 `JavaScriptKit supports only WASI reactor ABI.
@@ -124,13 +182,6 @@ export class SwiftRuntime {
         return this.instance.exports as any as ExportedFunctions;
     }
 
-    private get memory() {
-        if (!this._memory) {
-            this._memory = new Memory(this.instance.exports);
-        }
-        return this._memory;
-    }
-
     private get closureDeallocator(): SwiftClosureDeallocator | null {
         if (this._closureDeallocator) return this._closureDeallocator;
 
@@ -154,10 +205,11 @@ export class SwiftRuntime {
         const argc = args.length;
         const argv = this.exports.swjs_prepare_host_function_call(argc);
         const memory = this.memory;
+        const dataView = this.getDataView();
         for (let index = 0; index < args.length; index++) {
             const argument = args[index];
             const base = argv + 16 * index;
-            JSValue.write(argument, base, base + 4, base + 8, false, memory);
+            JSValue.write(argument, base, base + 4, base + 8, false, dataView, memory);
         }
         let output: any;
         // This ref is released by the swjs_call_host_function implementation
@@ -258,7 +310,8 @@ export class SwiftRuntime {
                     payload1_ptr,
                     payload2_ptr,
                     false,
-                    memory
+                    this.getDataView(),
+                    this.memory
                 );
             },
 
@@ -287,6 +340,7 @@ export class SwiftRuntime {
                     payload1_ptr,
                     payload2_ptr,
                     false,
+                    this.getDataView(),
                     this.memory
                 );
             },
@@ -295,33 +349,28 @@ export class SwiftRuntime {
                 const memory = this.memory;
                 const bytes = this.textEncoder.encode(memory.getObject(ref));
                 const bytes_ptr = memory.retain(bytes);
-                memory.writeUint32(bytes_ptr_result, bytes_ptr);
+                this.getDataView().setUint32(bytes_ptr_result, bytes_ptr, true);
                 return bytes.length;
             },
             swjs_decode_string: (
                 // NOTE: TextDecoder can't decode typed arrays backed by SharedArrayBuffer
                 this.options.sharedMemory == true
                 ? ((bytes_ptr: pointer, length: number) => {
-                    const memory = this.memory;
-                    const bytes = memory
-                        .bytes()
+                    const bytes = this.getUint8Array()
                         .slice(bytes_ptr, bytes_ptr + length);
                     const string = this.textDecoder.decode(bytes);
-                    return memory.retain(string);
+                    return this.memory.retain(string);
                 })
                 : ((bytes_ptr: pointer, length: number) => {
-                    const memory = this.memory;
-                    const bytes = memory
-                        .bytes()
+                    const bytes = this.getUint8Array()
                         .subarray(bytes_ptr, bytes_ptr + length);
                     const string = this.textDecoder.decode(bytes);
-                    return memory.retain(string);
+                    return this.memory.retain(string);
                 })
             ),
             swjs_load_string: (ref: ref, buffer: pointer) => {
-                const memory = this.memory;
-                const bytes = memory.getObject(ref);
-                memory.writeBytes(buffer, bytes);
+                const bytes = this.memory.getObject(ref);
+                this.getUint8Array().set(bytes, buffer);
             },
 
             swjs_call_function: (
@@ -335,7 +384,7 @@ export class SwiftRuntime {
                 const func = memory.getObject(ref);
                 let result = undefined;
                 try {
-                    const args = JSValue.decodeArray(argv, argc, memory);
+                    const args = JSValue.decodeArray(argv, argc, this.getDataView(), memory);
                     result = func(...args);
                 } catch (error) {
                     return JSValue.writeAndReturnKindBits(
@@ -343,6 +392,7 @@ export class SwiftRuntime {
                         payload1_ptr,
                         payload2_ptr,
                         true,
+                        this.getDataView(),
                         this.memory
                     );
                 }
@@ -351,6 +401,7 @@ export class SwiftRuntime {
                     payload1_ptr,
                     payload2_ptr,
                     false,
+                    this.getDataView(),
                     this.memory
                 );
             },
@@ -363,13 +414,14 @@ export class SwiftRuntime {
             ) => {
                 const memory = this.memory;
                 const func = memory.getObject(ref);
-                const args = JSValue.decodeArray(argv, argc, memory);
+                const args = JSValue.decodeArray(argv, argc, this.getDataView(), memory);
                 const result = func(...args);
                 return JSValue.writeAndReturnKindBits(
                     result,
                     payload1_ptr,
                     payload2_ptr,
                     false,
+                    this.getDataView(),
                     this.memory
                 );
             },
@@ -387,7 +439,7 @@ export class SwiftRuntime {
                 const func = memory.getObject(func_ref);
                 let result: any;
                 try {
-                    const args = JSValue.decodeArray(argv, argc, memory);
+                    const args = JSValue.decodeArray(argv, argc, this.getDataView(), memory);
                     result = func.apply(obj, args);
                 } catch (error) {
                     return JSValue.writeAndReturnKindBits(
@@ -395,6 +447,7 @@ export class SwiftRuntime {
                         payload1_ptr,
                         payload2_ptr,
                         true,
+                        this.getDataView(),
                         this.memory
                     );
                 }
@@ -403,6 +456,7 @@ export class SwiftRuntime {
                     payload1_ptr,
                     payload2_ptr,
                     false,
+                    this.getDataView(),
                     this.memory
                 );
             },
@@ -418,13 +472,14 @@ export class SwiftRuntime {
                 const obj = memory.getObject(obj_ref);
                 const func = memory.getObject(func_ref);
                 let result = undefined;
-                const args = JSValue.decodeArray(argv, argc, memory);
+                const args = JSValue.decodeArray(argv, argc, this.getDataView(), memory);
                 result = func.apply(obj, args);
                 return JSValue.writeAndReturnKindBits(
                     result,
                     payload1_ptr,
                     payload2_ptr,
                     false,
+                    this.getDataView(),
                     this.memory
                 );
             },
@@ -432,7 +487,7 @@ export class SwiftRuntime {
             swjs_call_new: (ref: ref, argv: pointer, argc: number) => {
                 const memory = this.memory;
                 const constructor = memory.getObject(ref);
-                const args = JSValue.decodeArray(argv, argc, memory);
+                const args = JSValue.decodeArray(argv, argc, this.getDataView(), memory);
                 const instance = new constructor(...args);
                 return this.memory.retain(instance);
             },
@@ -448,7 +503,7 @@ export class SwiftRuntime {
                 const constructor = memory.getObject(ref);
                 let result: any;
                 try {
-                    const args = JSValue.decodeArray(argv, argc, memory);
+                    const args = JSValue.decodeArray(argv, argc, this.getDataView(), memory);
                     result = new constructor(...args);
                 } catch (error) {
                     JSValue.write(
@@ -457,6 +512,7 @@ export class SwiftRuntime {
                         exception_payload1_ptr,
                         exception_payload2_ptr,
                         true,
+                        this.getDataView(),
                         this.memory
                     );
                     return -1;
@@ -468,6 +524,7 @@ export class SwiftRuntime {
                     exception_payload1_ptr,
                     exception_payload2_ptr,
                     false,
+                    this.getDataView(),
                     memory
                 );
                 return memory.retain(result);
@@ -521,7 +578,7 @@ export class SwiftRuntime {
                     return this.memory.retain(new ArrayType());
                 }
                 const array = new ArrayType(
-                    this.memory.rawMemory.buffer,
+                    this.wasmMemory!.buffer,
                     elementsPtr,
                     length
                 );
@@ -535,7 +592,7 @@ export class SwiftRuntime {
                 const memory = this.memory;
                 const typedArray = memory.getObject(ref);
                 const bytes = new Uint8Array(typedArray.buffer);
-                memory.writeBytes(buffer, bytes);
+                this.getUint8Array().set(bytes, buffer);
             },
 
             swjs_release: (ref: ref) => {
@@ -674,8 +731,7 @@ export class SwiftRuntime {
                     throw new Error("threadChannel is not set in options given to SwiftRuntime. Please set it to request transferring objects.");
                 }
                 const broker = getMessageBroker(this.options.threadChannel);
-                const memory = this.memory;
-                const transferringObjects = decodeObjectRefs(transferring_objects, transferring_objects_count, memory);
+                const transferringObjects = decodeObjectRefs(transferring_objects, transferring_objects_count, this.getDataView());
                 broker.request({
                     type: "request",
                     data: {
@@ -701,9 +757,9 @@ export class SwiftRuntime {
                     throw new Error("threadChannel is not set in options given to SwiftRuntime. Please set it to request transferring objects.");
                 }
                 const broker = getMessageBroker(this.options.threadChannel);
-                const memory = this.memory;
-                const sendingObjects = decodeObjectRefs(sending_objects, sending_objects_count, memory);
-                const transferringObjects = decodeObjectRefs(transferring_objects, transferring_objects_count, memory);
+                const dataView = this.getDataView();
+                const sendingObjects = decodeObjectRefs(sending_objects, sending_objects_count, dataView);
+                const transferringObjects = decodeObjectRefs(transferring_objects, transferring_objects_count, dataView);
                 broker.request({
                     type: "request",
                     data: {
diff --git a/Runtime/src/itc.ts b/Runtime/src/itc.ts
index e2c93622a..08b420640 100644
--- a/Runtime/src/itc.ts
+++ b/Runtime/src/itc.ts
@@ -1,6 +1,6 @@
 // This file defines the interface for the inter-thread communication.
 import type { ref, pointer } from "./types.js";
-import { Memory } from "./memory.js";
+import { JSObjectSpace as JSObjectSpace } from "./object-heap.js";
 
 /**
  * A thread channel is a set of functions that are used to communicate between
@@ -83,7 +83,7 @@ export type SwiftRuntimeThreadChannel =
 
 
 export class ITCInterface {
-    constructor(private memory: Memory) {}
+    constructor(private memory: JSObjectSpace) {}
 
     send(sendingObject: ref, transferringObjects: ref[], sendingContext: pointer): { object: any, sendingContext: pointer, transfer: Transferable[] } {
         const object = this.memory.getObject(sendingObject);
diff --git a/Runtime/src/js-value.ts b/Runtime/src/js-value.ts
index dcc378f61..b23f39d87 100644
--- a/Runtime/src/js-value.ts
+++ b/Runtime/src/js-value.ts
@@ -1,4 +1,4 @@
-import { Memory } from "./memory.js";
+import { JSObjectSpace } from "./object-heap.js";
 import { assertNever, JavaScriptValueKindAndFlags, pointer, ref } from "./types.js";
 
 export const enum Kind {
@@ -17,7 +17,7 @@ export const decode = (
     kind: Kind,
     payload1: number,
     payload2: number,
-    memory: Memory
+    objectSpace: JSObjectSpace
 ) => {
     switch (kind) {
         case Kind.Boolean:
@@ -35,7 +35,7 @@ export const decode = (
         case Kind.Function:
         case Kind.Symbol:
         case Kind.BigInt:
-            return memory.getObject(payload1);
+            return objectSpace.getObject(payload1);
 
         case Kind.Null:
             return null;
@@ -50,22 +50,19 @@ export const decode = (
 
 // Note:
 // `decodeValues` assumes that the size of RawJSValue is 16.
-export const decodeArray = (ptr: pointer, length: number, memory: Memory) => {
+export const decodeArray = (ptr: pointer, length: number, memory: DataView, objectSpace: JSObjectSpace) => {
     // fast path for empty array
     if (length === 0) {
         return [];
     }
 
     let result = [];
-    // It's safe to hold DataView here because WebAssembly.Memory.buffer won't
-    // change within this function.
-    const view = memory.dataView();
     for (let index = 0; index < length; index++) {
         const base = ptr + 16 * index;
-        const kind = view.getUint32(base, true);
-        const payload1 = view.getUint32(base + 4, true);
-        const payload2 = view.getFloat64(base + 8, true);
-        result.push(decode(kind, payload1, payload2, memory));
+        const kind = memory.getUint32(base, true);
+        const payload1 = memory.getUint32(base + 4, true);
+        const payload2 = memory.getFloat64(base + 8, true);
+        result.push(decode(kind, payload1, payload2, objectSpace));
     }
     return result;
 };
@@ -80,16 +77,18 @@ export const write = (
     payload1_ptr: pointer,
     payload2_ptr: pointer,
     is_exception: boolean,
-    memory: Memory
+    memory: DataView,
+    objectSpace: JSObjectSpace
 ) => {
     const kind = writeAndReturnKindBits(
         value,
         payload1_ptr,
         payload2_ptr,
         is_exception,
-        memory
+        memory,
+        objectSpace
     );
-    memory.writeUint32(kind_ptr, kind);
+    memory.setUint32(kind_ptr, kind, true);
 };
 
 export const writeAndReturnKindBits = (
@@ -97,7 +96,8 @@ export const writeAndReturnKindBits = (
     payload1_ptr: pointer,
     payload2_ptr: pointer,
     is_exception: boolean,
-    memory: Memory
+    memory: DataView,
+    objectSpace: JSObjectSpace
 ): JavaScriptValueKindAndFlags => {
     const exceptionBit = (is_exception ? 1 : 0) << 31;
     if (value === null) {
@@ -105,18 +105,18 @@ export const writeAndReturnKindBits = (
     }
 
     const writeRef = (kind: Kind) => {
-        memory.writeUint32(payload1_ptr, memory.retain(value));
+        memory.setUint32(payload1_ptr, objectSpace.retain(value), true);
         return exceptionBit | kind;
     };
 
     const type = typeof value;
     switch (type) {
         case "boolean": {
-            memory.writeUint32(payload1_ptr, value ? 1 : 0);
+            memory.setUint32(payload1_ptr, value ? 1 : 0, true);
             return exceptionBit | Kind.Boolean;
         }
         case "number": {
-            memory.writeFloat64(payload2_ptr, value);
+            memory.setFloat64(payload2_ptr, value, true);
             return exceptionBit | Kind.Number;
         }
         case "string": {
@@ -143,10 +143,10 @@ export const writeAndReturnKindBits = (
     throw new Error("Unreachable");
 };
 
-export function decodeObjectRefs(ptr: pointer, length: number, memory: Memory): ref[] {
+export function decodeObjectRefs(ptr: pointer, length: number, memory: DataView): ref[] {
     const result: ref[] = new Array(length);
     for (let i = 0; i < length; i++) {
-        result[i] = memory.readUint32(ptr + 4 * i);
+        result[i] = memory.getUint32(ptr + 4 * i, true);
     }
     return result;
 }
diff --git a/Runtime/src/memory.ts b/Runtime/src/memory.ts
deleted file mode 100644
index d8334516d..000000000
--- a/Runtime/src/memory.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { SwiftRuntimeHeap } from "./object-heap.js";
-import { pointer } from "./types.js";
-
-export class Memory {
-    readonly rawMemory: WebAssembly.Memory;
-
-    private readonly heap = new SwiftRuntimeHeap();
-
-    constructor(exports: WebAssembly.Exports) {
-        this.rawMemory = exports.memory as WebAssembly.Memory;
-    }
-
-    retain = (value: any) => this.heap.retain(value);
-    getObject = (ref: number) => this.heap.referenceHeap(ref);
-    release = (ref: number) => this.heap.release(ref);
-
-    bytes = () => new Uint8Array(this.rawMemory.buffer);
-    dataView = () => new DataView(this.rawMemory.buffer);
-
-    writeBytes = (ptr: pointer, bytes: Uint8Array) =>
-        this.bytes().set(bytes, ptr);
-
-    readUint32 = (ptr: pointer) => this.dataView().getUint32(ptr, true);
-    readUint64 = (ptr: pointer) => this.dataView().getBigUint64(ptr, true);
-    readInt64 = (ptr: pointer) => this.dataView().getBigInt64(ptr, true);
-    readFloat64 = (ptr: pointer) => this.dataView().getFloat64(ptr, true);
-
-    writeUint32 = (ptr: pointer, value: number) =>
-        this.dataView().setUint32(ptr, value, true);
-    writeUint64 = (ptr: pointer, value: bigint) =>
-        this.dataView().setBigUint64(ptr, value, true);
-    writeInt64 = (ptr: pointer, value: bigint) =>
-        this.dataView().setBigInt64(ptr, value, true);
-    writeFloat64 = (ptr: pointer, value: number) =>
-        this.dataView().setFloat64(ptr, value, true);
-}
diff --git a/Runtime/src/object-heap.ts b/Runtime/src/object-heap.ts
index d59f5101e..b90fc4eff 100644
--- a/Runtime/src/object-heap.ts
+++ b/Runtime/src/object-heap.ts
@@ -5,20 +5,20 @@ type SwiftRuntimeHeapEntry = {
     id: number;
     rc: number;
 };
-export class SwiftRuntimeHeap {
+export class JSObjectSpace {
     private _heapValueById: Map<number, any>;
     private _heapEntryByValue: Map<any, SwiftRuntimeHeapEntry>;
     private _heapNextKey: number;
 
     constructor() {
         this._heapValueById = new Map();
-        this._heapValueById.set(0, globalVariable);
+        this._heapValueById.set(1, globalVariable);
 
         this._heapEntryByValue = new Map();
-        this._heapEntryByValue.set(globalVariable, { id: 0, rc: 1 });
+        this._heapEntryByValue.set(globalVariable, { id: 1, rc: 1 });
 
-        // Note: 0 is preserved for global
-        this._heapNextKey = 1;
+        // Note: 0 is preserved for invalid references, 1 is preserved for globalThis
+        this._heapNextKey = 2;
     }
 
     retain(value: any) {
@@ -33,6 +33,10 @@ export class SwiftRuntimeHeap {
         return id;
     }
 
+    retainByRef(ref: ref) {
+        return this.retain(this.getObject(ref));
+    }
+
     release(ref: ref) {
         const value = this._heapValueById.get(ref);
         const entry = this._heapEntryByValue.get(value)!;
@@ -43,7 +47,7 @@ export class SwiftRuntimeHeap {
         this._heapValueById.delete(ref);
     }
 
-    referenceHeap(ref: ref) {
+    getObject(ref: ref) {
         const value = this._heapValueById.get(ref);
         if (value === undefined) {
             throw new ReferenceError(
diff --git a/Sources/JavaScriptEventLoop/WebWorkerTaskExecutor.swift b/Sources/JavaScriptEventLoop/WebWorkerTaskExecutor.swift
index 1078244f9..992b6090a 100644
--- a/Sources/JavaScriptEventLoop/WebWorkerTaskExecutor.swift
+++ b/Sources/JavaScriptEventLoop/WebWorkerTaskExecutor.swift
@@ -628,9 +628,10 @@ func _swjs_wake_worker_thread() {
     WebWorkerTaskExecutor.Worker.currentThread!.wakeUpFromOtherThread()
 }
 
-private func trace(_ message: String) {
+@inline(__always)
+private func trace(_ message: @autoclosure () -> String) {
     #if JAVASCRIPTKIT_TRACE
-    _ = JSObject.global.console.warn("[trace tid=\(swjs_get_worker_thread_id())] \(message)\n")
+    _ = JSObject.global.console.warn("[trace tid=\(swjs_get_worker_thread_id())] \(message())\n")
     #endif
 }
 
diff --git a/Sources/JavaScriptFoundationCompat/Data+JSValue.swift b/Sources/JavaScriptFoundationCompat/Data+JSValue.swift
new file mode 100644
index 000000000..ac8e773b4
--- /dev/null
+++ b/Sources/JavaScriptFoundationCompat/Data+JSValue.swift
@@ -0,0 +1,42 @@
+import Foundation
+import JavaScriptKit
+
+/// Data <-> Uint8Array conversion. The conversion is lossless and copies the bytes at most once per conversion
+extension Data: ConvertibleToJSValue, ConstructibleFromJSValue {
+    /// Convert a Data to a JSTypedArray<UInt8>.
+    ///
+    /// - Returns: A Uint8Array that contains the bytes of the Data.
+    public var jsTypedArray: JSTypedArray<UInt8> {
+        self.withUnsafeBytes { buffer in
+            return JSTypedArray<UInt8>(buffer: buffer.bindMemory(to: UInt8.self))
+        }
+    }
+
+    /// Convert a Data to a JSValue.
+    ///
+    /// - Returns: A JSValue that contains the bytes of the Data as a Uint8Array.
+    public var jsValue: JSValue { jsTypedArray.jsValue }
+
+    /// Construct a Data from a JSTypedArray<UInt8>.
+    public static func construct(from uint8Array: JSTypedArray<UInt8>) -> Data? {
+        // First, allocate the data storage
+        var data = Data(count: uint8Array.lengthInBytes)
+        // Then, copy the byte contents into the Data buffer
+        data.withUnsafeMutableBytes { destinationBuffer in
+            uint8Array.copyMemory(to: destinationBuffer.bindMemory(to: UInt8.self))
+        }
+        return data
+    }
+
+    /// Construct a Data from a JSValue.
+    ///
+    /// - Parameter jsValue: The JSValue to construct a Data from.
+    /// - Returns: A Data, if the JSValue is a Uint8Array.
+    public static func construct(from jsValue: JSValue) -> Data? {
+        guard let uint8Array = JSTypedArray<UInt8>(from: jsValue) else {
+            // If the JSValue is not a Uint8Array, fail.
+            return nil
+        }
+        return construct(from: uint8Array)
+    }
+}
diff --git a/Sources/JavaScriptKit/BridgeJSInstrincics.swift b/Sources/JavaScriptKit/BridgeJSInstrincics.swift
new file mode 100644
index 000000000..1a8bad7f9
--- /dev/null
+++ b/Sources/JavaScriptKit/BridgeJSInstrincics.swift
@@ -0,0 +1,74 @@
+import _CJavaScriptKit
+
+#if !arch(wasm32)
+@usableFromInline func _onlyAvailableOnWasm() -> Never {
+    fatalError("Only available on WebAssembly")
+}
+#endif
+
+#if arch(wasm32)
+@_extern(wasm, module: "bjs", name: "swift_js_return_string")
+@_spi(BridgeJS) public func _swift_js_return_string(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
+#else
+@_spi(BridgeJS) public func _swift_js_return_string(_ ptr: UnsafePointer<UInt8>?, _ len: Int32) {
+    _onlyAvailableOnWasm()
+}
+#endif
+
+#if arch(wasm32)
+@_extern(wasm, module: "bjs", name: "swift_js_init_memory")
+@_spi(BridgeJS) public func _swift_js_init_memory(_ sourceId: Int32, _ ptr: UnsafeMutablePointer<UInt8>?)
+#else
+@_spi(BridgeJS) public func _swift_js_init_memory(_ sourceId: Int32, _ ptr: UnsafeMutablePointer<UInt8>?) {
+    _onlyAvailableOnWasm()
+}
+#endif
+
+#if arch(wasm32)
+@_extern(wasm, module: "bjs", name: "swift_js_retain")
+@_spi(BridgeJS) public func _swift_js_retain(_ ptr: Int32) -> Int32
+#else
+@_spi(BridgeJS) public func _swift_js_retain(_ ptr: Int32) -> Int32 {
+    _onlyAvailableOnWasm()
+}
+#endif
+
+#if arch(wasm32)
+@_extern(wasm, module: "bjs", name: "swift_js_throw")
+@_spi(BridgeJS) public func _swift_js_throw(_ id: Int32)
+#else
+@_spi(BridgeJS) public func _swift_js_throw(_ id: Int32) {
+    _onlyAvailableOnWasm()
+}
+#endif
+
+#if arch(wasm32)
+@_extern(wasm, module: "bjs", name: "swift_js_make_js_string")
+@_spi(BridgeJS) public func _swift_js_make_js_string(_ ptr: UnsafePointer<UInt8>?, _ len: Int32) -> Int32
+#else
+@_spi(BridgeJS) public func _swift_js_make_js_string(_ ptr: UnsafePointer<UInt8>?, _ len: Int32) -> Int32 {
+    _onlyAvailableOnWasm()
+}
+#endif
+
+#if arch(wasm32)
+@_extern(wasm, module: "bjs", name: "swift_js_init_memory_with_result")
+@_spi(BridgeJS) public func _swift_js_init_memory_with_result(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
+#else
+@_spi(BridgeJS) public func _swift_js_init_memory_with_result(_ ptr: UnsafePointer<UInt8>?, _ len: Int32) {
+    _onlyAvailableOnWasm()
+}
+#endif
+
+@_spi(BridgeJS) @_transparent public func _swift_js_take_exception() -> JSException? {
+    #if arch(wasm32)
+    let value = _swift_js_exception_get()
+    if _fastPath(value == 0) {
+        return nil
+    }
+    _swift_js_exception_set(0)
+    return JSException(JSObject(id: UInt32(bitPattern: value)).jsValue)
+    #else
+    _onlyAvailableOnWasm()
+    #endif
+}
diff --git a/Sources/JavaScriptKit/Documentation.docc/Articles/Ahead-of-Time-Code-Generation.md b/Sources/JavaScriptKit/Documentation.docc/Articles/Ahead-of-Time-Code-Generation.md
index 755f68b91..e3f52885c 100644
--- a/Sources/JavaScriptKit/Documentation.docc/Articles/Ahead-of-Time-Code-Generation.md
+++ b/Sources/JavaScriptKit/Documentation.docc/Articles/Ahead-of-Time-Code-Generation.md
@@ -44,7 +44,15 @@ let package = Package(
 )
 ```
 
-### Step 2: Create Your Swift Code with @JS Annotations
+### Step 2: Create BridgeJS Configuration
+
+Create a `bridge-js.config.json` file in your SwiftPM target directory you want to use BridgeJS.
+
+```console
+$ echo "{}" > Sources/MyApp/bridge-js.config.json
+```
+
+### Step 3: Create Your Swift Code with @JS Annotations
 
 Write your Swift code with `@JS` annotations as usual:
 
@@ -70,12 +78,12 @@ import JavaScriptKit
 }
 ```
 
-### Step 3: Create Your TypeScript Definitions
+### Step 4: Create Your TypeScript Definitions
 
-If you're importing JavaScript APIs, create your `bridge.d.ts` file as usual:
+If you're importing JavaScript APIs, create your `bridge-js.d.ts` file as usual:
 
 ```typescript
-// Sources/MyApp/bridge.d.ts
+// Sources/MyApp/bridge-js.d.ts
 export function consoleLog(message: string): void;
 
 export interface Document {
@@ -86,7 +94,7 @@ export interface Document {
 export function getDocument(): Document;
 ```
 
-### Step 4: Generate the Bridge Code
+### Step 5: Generate the Bridge Code
 
 Run the command plugin to generate the bridge code:
 
@@ -108,7 +116,7 @@ Sources/MyApp/Generated/ImportTS.swift     # Generated code for TypeScript impor
 Sources/MyApp/Generated/JavaScript/        # Generated JSON skeletons
 ```
 
-### Step 5: Add Generated Files to Version Control
+### Step 6: Add Generated Files to Version Control
 
 Add these generated files to your version control system:
 
@@ -117,7 +125,7 @@ git add Sources/MyApp/Generated
 git commit -m "Add generated BridgeJS code"
 ```
 
-### Step 6: Build Your Package
+### Step 7: Build Your Package
 
 Now you can build your package as usual:
 
diff --git a/Sources/JavaScriptKit/Documentation.docc/Articles/Importing-TypeScript-into-Swift.md b/Sources/JavaScriptKit/Documentation.docc/Articles/Importing-TypeScript-into-Swift.md
index 5f9bb4a12..98a9c80cb 100644
--- a/Sources/JavaScriptKit/Documentation.docc/Articles/Importing-TypeScript-into-Swift.md
+++ b/Sources/JavaScriptKit/Documentation.docc/Articles/Importing-TypeScript-into-Swift.md
@@ -51,7 +51,7 @@ let package = Package(
 
 ### Step 2: Create TypeScript Definitions
 
-Create a file named `bridge.d.ts` in your target source directory (e.g. `Sources/<target-name>/bridge.d.ts`). This file defines the JavaScript APIs you want to use in Swift:
+Create a file named `bridge-js.d.ts` in your target source directory (e.g. `Sources/<target-name>/bridge-js.d.ts`). This file defines the JavaScript APIs you want to use in Swift:
 
 ```typescript
 // Simple function
diff --git a/Sources/JavaScriptKit/FundamentalObjects/JSClosure.swift b/Sources/JavaScriptKit/FundamentalObjects/JSClosure.swift
index 18a400786..3b67baf7d 100644
--- a/Sources/JavaScriptKit/FundamentalObjects/JSClosure.swift
+++ b/Sources/JavaScriptKit/FundamentalObjects/JSClosure.swift
@@ -18,7 +18,7 @@ public protocol JSClosureProtocol: JSValueCompatible {
 public class JSOneshotClosure: JSObject, JSClosureProtocol {
     private var hostFuncRef: JavaScriptHostFuncRef = 0
 
-    public init(_ body: @escaping (sending [JSValue]) -> JSValue, file: String = #fileID, line: UInt32 = #line) {
+    public init(file: String = #fileID, line: UInt32 = #line, _ body: @escaping (sending [JSValue]) -> JSValue) {
         // 1. Fill `id` as zero at first to access `self` to get `ObjectIdentifier`.
         super.init(id: 0)
 
@@ -44,11 +44,40 @@ public class JSOneshotClosure: JSObject, JSClosureProtocol {
     }
 
     #if compiler(>=5.5) && (!hasFeature(Embedded) || os(WASI))
+    /// Creates a new `JSOneshotClosure` that calls the given Swift function asynchronously.
+    ///
+    /// - Parameters:
+    ///   - priority: The priority of the new unstructured Task created under the hood.
+    ///   - body: The Swift function to call asynchronously.
     @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
     public static func async(
-        _ body: sending @escaping (sending [JSValue]) async throws(JSException) -> JSValue
+        priority: TaskPriority? = nil,
+        file: String = #fileID,
+        line: UInt32 = #line,
+        _ body: @escaping (sending [JSValue]) async throws(JSException) -> JSValue
     ) -> JSOneshotClosure {
-        JSOneshotClosure(makeAsyncClosure(body))
+        JSOneshotClosure(file: file, line: line, makeAsyncClosure(priority: priority, body))
+    }
+
+    /// Creates a new `JSOneshotClosure` that calls the given Swift function asynchronously.
+    ///
+    /// - Parameters:
+    ///   - taskExecutor: The executor preference of the new unstructured Task created under the hood.
+    ///   - priority: The priority of the new unstructured Task created under the hood.
+    ///   - body: The Swift function to call asynchronously.
+    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+    public static func async(
+        executorPreference taskExecutor: (any TaskExecutor)? = nil,
+        priority: TaskPriority? = nil,
+        file: String = #fileID,
+        line: UInt32 = #line,
+        _ body: @escaping (sending [JSValue]) async throws(JSException) -> JSValue
+    ) -> JSOneshotClosure {
+        JSOneshotClosure(
+            file: file,
+            line: line,
+            makeAsyncClosure(executorPreference: taskExecutor, priority: priority, body)
+        )
     }
     #endif
 
@@ -117,7 +146,7 @@ public class JSClosure: JSFunction, JSClosureProtocol {
         })
     }
 
-    public init(_ body: @escaping (sending [JSValue]) -> JSValue, file: String = #fileID, line: UInt32 = #line) {
+    public init(file: String = #fileID, line: UInt32 = #line, _ body: @escaping (sending [JSValue]) -> JSValue) {
         // 1. Fill `id` as zero at first to access `self` to get `ObjectIdentifier`.
         super.init(id: 0)
 
@@ -137,11 +166,36 @@ public class JSClosure: JSFunction, JSClosureProtocol {
     }
 
     #if compiler(>=5.5) && (!hasFeature(Embedded) || os(WASI))
+    /// Creates a new `JSClosure` that calls the given Swift function asynchronously.
+    ///
+    /// - Parameters:
+    ///   - priority: The priority of the new unstructured Task created under the hood.
+    ///   - body: The Swift function to call asynchronously.
     @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
     public static func async(
-        _ body: @Sendable @escaping (sending [JSValue]) async throws(JSException) -> JSValue
+        priority: TaskPriority? = nil,
+        file: String = #fileID,
+        line: UInt32 = #line,
+        _ body: @escaping @isolated(any) (sending [JSValue]) async throws(JSException) -> JSValue
+    ) -> JSClosure {
+        JSClosure(file: file, line: line, makeAsyncClosure(priority: priority, body))
+    }
+
+    /// Creates a new `JSClosure` that calls the given Swift function asynchronously.
+    ///
+    /// - Parameters:
+    ///   - taskExecutor: The executor preference of the new unstructured Task created under the hood.
+    ///   - priority: The priority of the new unstructured Task created under the hood.
+    ///   - body: The Swift function to call asynchronously.
+    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+    public static func async(
+        executorPreference taskExecutor: (any TaskExecutor)? = nil,
+        priority: TaskPriority? = nil,
+        file: String = #fileID,
+        line: UInt32 = #line,
+        _ body: @escaping (sending [JSValue]) async throws(JSException) -> JSValue
     ) -> JSClosure {
-        JSClosure(makeAsyncClosure(body))
+        JSClosure(file: file, line: line, makeAsyncClosure(executorPreference: taskExecutor, priority: priority, body))
     }
     #endif
 
@@ -157,7 +211,37 @@ public class JSClosure: JSFunction, JSClosureProtocol {
 #if compiler(>=5.5) && (!hasFeature(Embedded) || os(WASI))
 @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
 private func makeAsyncClosure(
-    _ body: sending @escaping (sending [JSValue]) async throws(JSException) -> JSValue
+    priority: TaskPriority?,
+    _ body: @escaping @isolated(any) (sending [JSValue]) async throws(JSException) -> JSValue
+) -> ((sending [JSValue]) -> JSValue) {
+    { arguments in
+        JSPromise { resolver in
+            // NOTE: The context is fully transferred to the unstructured task
+            // isolation but the compiler can't prove it yet, so we need to
+            // use `@unchecked Sendable` to make it compile with the Swift 6 mode.
+            struct Context: @unchecked Sendable {
+                let resolver: (JSPromise.Result) -> Void
+                let arguments: [JSValue]
+                let body: (sending [JSValue]) async throws(JSException) -> JSValue
+            }
+            let context = Context(resolver: resolver, arguments: arguments, body: body)
+            Task(priority: priority) {
+                do throws(JSException) {
+                    let result = try await context.body(context.arguments)
+                    context.resolver(.success(result))
+                } catch {
+                    context.resolver(.failure(error.thrownValue))
+                }
+            }
+        }.jsValue()
+    }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+private func makeAsyncClosure(
+    executorPreference taskExecutor: (any TaskExecutor)?,
+    priority: TaskPriority?,
+    _ body: @escaping (sending [JSValue]) async throws(JSException) -> JSValue
 ) -> ((sending [JSValue]) -> JSValue) {
     { arguments in
         JSPromise { resolver in
@@ -170,7 +254,7 @@ private func makeAsyncClosure(
                 let body: (sending [JSValue]) async throws(JSException) -> JSValue
             }
             let context = Context(resolver: resolver, arguments: arguments, body: body)
-            Task {
+            Task(executorPreference: taskExecutor, priority: priority) {
                 do throws(JSException) {
                     let result = try await context.body(context.arguments)
                     context.resolver(.success(result))
diff --git a/Sources/JavaScriptKit/FundamentalObjects/JSObject.swift b/Sources/JavaScriptKit/FundamentalObjects/JSObject.swift
index 12dbf9e02..b9330ae80 100644
--- a/Sources/JavaScriptKit/FundamentalObjects/JSObject.swift
+++ b/Sources/JavaScriptKit/FundamentalObjects/JSObject.swift
@@ -27,10 +27,12 @@ public class JSObject: Equatable, ExpressibleByDictionaryLiteral {
     #endif
 
     @_spi(JSObject_id)
+    @_spi(BridgeJS)
     @inlinable
     public var id: JavaScriptObjectRef { _id }
 
     @_spi(JSObject_id)
+    @_spi(BridgeJS)
     public init(id: JavaScriptObjectRef) {
         self._id = id
         #if compiler(>=6.1) && _runtime(_multithreaded)
@@ -216,7 +218,7 @@ public class JSObject: Equatable, ExpressibleByDictionaryLiteral {
         return swjs_instanceof(id, constructor.id)
     }
 
-    static let _JS_Predef_Value_Global: JavaScriptObjectRef = 0
+    static let _JS_Predef_Value_Global: JavaScriptObjectRef = 1
 
     /// A `JSObject` of the global scope object.
     /// This allows access to the global properties and global names by accessing the `JSObject` returned.
diff --git a/Sources/JavaScriptKit/JSException.swift b/Sources/JavaScriptKit/JSException.swift
index 1b9e311fd..4d95e207d 100644
--- a/Sources/JavaScriptKit/JSException.swift
+++ b/Sources/JavaScriptKit/JSException.swift
@@ -34,6 +34,7 @@ public struct JSException: Error, Equatable, CustomStringConvertible {
     /// Initializes a new JSException instance with a value thrown from JavaScript.
     ///
     /// Only available within the package. This must be called on the thread where the exception object created.
+    @usableFromInline
     package init(_ thrownValue: JSValue) {
         self._thrownValue = thrownValue
         // Capture the stringified representation on the object owner thread
@@ -46,4 +47,12 @@ public struct JSException: Error, Equatable, CustomStringConvertible {
             self.stack = nil
         }
     }
+
+    /// Initializes a new JavaScript `Error` instance with a message and prepare it to be thrown.
+    ///
+    /// - Parameters:
+    ///   - message: The message to throw.
+    public init(message: String) {
+        self.init(JSError(message: message).jsValue)
+    }
 }
diff --git a/Sources/_CJavaScriptKit/_CJavaScriptKit.c b/Sources/_CJavaScriptKit/_CJavaScriptKit.c
index a32881804..9df18b887 100644
--- a/Sources/_CJavaScriptKit/_CJavaScriptKit.c
+++ b/Sources/_CJavaScriptKit/_CJavaScriptKit.c
@@ -1,4 +1,6 @@
+#include <stdint.h>
 #include "_CJavaScriptKit.h"
+#include "WasmGlobalMacros.h"
 #if __wasm32__
 # ifndef __wasi__
 # if __has_include("malloc.h")
@@ -60,6 +62,9 @@ int swjs_library_features(void) {
     return _library_features();
 }
 # endif
+
+WASM_GLOBAL_DEFINE_STORAGE(_swift_js_exception, i32)
+WASM_EXPORT_NAME(_swift_js_exception, _swift_js_exception)
 #endif
 
 int swjs_get_worker_thread_id_cached(void) {
diff --git a/Sources/_CJavaScriptKit/include/BridgeJSInstrincics.h b/Sources/_CJavaScriptKit/include/BridgeJSInstrincics.h
new file mode 100644
index 000000000..4f5ba93cb
--- /dev/null
+++ b/Sources/_CJavaScriptKit/include/BridgeJSInstrincics.h
@@ -0,0 +1,11 @@
+#ifndef _CJavaScriptKit_BridgeJSInstrincics_h
+#define _CJavaScriptKit_BridgeJSInstrincics_h
+
+#include <stdint.h>
+#include "WasmGlobalMacros.h"
+
+#if __wasm__
+WASM_GLOBAL_DEFINE_INLINE_ACCESSORS(_swift_js_exception, i32, int32_t)
+#endif
+
+#endif
diff --git a/Sources/_CJavaScriptKit/include/WasmGlobalMacros.h b/Sources/_CJavaScriptKit/include/WasmGlobalMacros.h
new file mode 100644
index 000000000..5e7aeb972
--- /dev/null
+++ b/Sources/_CJavaScriptKit/include/WasmGlobalMacros.h
@@ -0,0 +1,45 @@
+#ifndef _CJavaScriptKit_WasmGlobalMacros_h
+#define _CJavaScriptKit_WasmGlobalMacros_h
+
+// Define an inline getter for a Wasm global
+#define WASM_GLOBAL_DEFINE_INLINE_GETTER(name, core_type, c_type) \
+    static inline c_type name##_get(void) { \
+        c_type val; \
+        __asm__( \
+            ".globaltype " #name ", " #core_type "\n" \
+            "global.get " #name "\n" \
+            "local.set %0\n" \
+            : "=r"(val)); \
+        return val; \
+    }
+
+// Define an inline setter for a Wasm global
+#define WASM_GLOBAL_DEFINE_INLINE_SETTER(name, core_type, c_type) \
+    static inline void name##_set(c_type val) { \
+        __asm__( \
+            ".globaltype " #name ", " #core_type "\n" \
+            "local.get %0\n" \
+            "global.set " #name "\n" \
+            : : "r"(val)); \
+    }
+
+// Define an inline getter and setter for a Wasm global
+#define WASM_GLOBAL_DEFINE_INLINE_ACCESSORS(name, core_type, c_type) \
+    WASM_GLOBAL_DEFINE_INLINE_GETTER(name, core_type, c_type) \
+    WASM_GLOBAL_DEFINE_INLINE_SETTER(name, core_type, c_type)
+
+// Define a Wasm global storage
+#define WASM_GLOBAL_DEFINE_STORAGE(name, core_type) \
+    __asm__( \
+        ".globaltype " #name ", " #core_type "\n" \
+        ".global " #name "\n" \
+        #name ":\n" \
+    );
+
+// Define an export name for a Wasm value
+#define WASM_EXPORT_NAME(name, export_name) \
+    __asm__( \
+        ".export_name " #name ", " #export_name "\n" \
+    );
+
+#endif
diff --git a/Sources/_CJavaScriptKit/include/module.modulemap b/Sources/_CJavaScriptKit/include/module.modulemap
index 8f4b69262..3afe12831 100644
--- a/Sources/_CJavaScriptKit/include/module.modulemap
+++ b/Sources/_CJavaScriptKit/include/module.modulemap
@@ -1,4 +1,5 @@
 module _CJavaScriptKit {
     header "_CJavaScriptKit.h"
+    header "BridgeJSInstrincics.h"
     export *
 }
diff --git a/Tests/BridgeJSRuntimeTests/ExportAPITests.swift b/Tests/BridgeJSRuntimeTests/ExportAPITests.swift
index 1473594e5..2b78b96b5 100644
--- a/Tests/BridgeJSRuntimeTests/ExportAPITests.swift
+++ b/Tests/BridgeJSRuntimeTests/ExportAPITests.swift
@@ -5,6 +5,10 @@ import JavaScriptKit
 @_extern(c)
 func runJsWorks() -> Void
 
+@JS func roundTripVoid() -> Void {
+    return
+}
+
 @JS func roundTripInt(v: Int) -> Int {
     return v
 }
@@ -24,6 +28,27 @@ func runJsWorks() -> Void
     return v
 }
 
+@JS func roundTripJSObject(v: JSObject) -> JSObject {
+    return v
+}
+
+struct TestError: Error {
+    let message: String
+}
+
+@JS func throwsSwiftError(shouldThrow: Bool) throws(JSException) -> Void {
+    if shouldThrow {
+        throw JSException(JSError(message: "TestError").jsValue)
+    }
+}
+@JS func throwsWithIntResult() throws(JSException) -> Int { return 1 }
+@JS func throwsWithStringResult() throws(JSException) -> String { return "Ok" }
+@JS func throwsWithBoolResult() throws(JSException) -> Bool { return true }
+@JS func throwsWithFloatResult() throws(JSException) -> Float { return 1.0 }
+@JS func throwsWithDoubleResult() throws(JSException) -> Double { return 1.0 }
+@JS func throwsWithSwiftHeapObjectResult() throws(JSException) -> Greeter { return Greeter(name: "Test") }
+@JS func throwsWithJSObjectResult() throws(JSException) -> JSObject { return JSObject() }
+
 @JS class Greeter {
     var name: String
 
diff --git a/Tests/BridgeJSRuntimeTests/Generated/BridgeJS.ExportSwift.swift b/Tests/BridgeJSRuntimeTests/Generated/BridgeJS.ExportSwift.swift
new file mode 100644
index 000000000..2a91da9fd
--- /dev/null
+++ b/Tests/BridgeJSRuntimeTests/Generated/BridgeJS.ExportSwift.swift
@@ -0,0 +1,363 @@
+// NOTICE: This is auto-generated code by BridgeJS from JavaScriptKit,
+// DO NOT EDIT.
+//
+// To update this file, just rebuild your project or run
+// `swift package bridge-js`.
+
+@_spi(BridgeJS) import JavaScriptKit
+
+@_expose(wasm, "bjs_roundTripVoid")
+@_cdecl("bjs_roundTripVoid")
+public func _bjs_roundTripVoid() -> Void {
+    #if arch(wasm32)
+    roundTripVoid()
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_roundTripInt")
+@_cdecl("bjs_roundTripInt")
+public func _bjs_roundTripInt(v: Int32) -> Int32 {
+    #if arch(wasm32)
+    let ret = roundTripInt(v: Int(v))
+    return Int32(ret)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_roundTripFloat")
+@_cdecl("bjs_roundTripFloat")
+public func _bjs_roundTripFloat(v: Float32) -> Float32 {
+    #if arch(wasm32)
+    let ret = roundTripFloat(v: v)
+    return Float32(ret)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_roundTripDouble")
+@_cdecl("bjs_roundTripDouble")
+public func _bjs_roundTripDouble(v: Float64) -> Float64 {
+    #if arch(wasm32)
+    let ret = roundTripDouble(v: v)
+    return Float64(ret)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_roundTripBool")
+@_cdecl("bjs_roundTripBool")
+public func _bjs_roundTripBool(v: Int32) -> Int32 {
+    #if arch(wasm32)
+    let ret = roundTripBool(v: v == 1)
+    return Int32(ret ? 1 : 0)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_roundTripString")
+@_cdecl("bjs_roundTripString")
+public func _bjs_roundTripString(vBytes: Int32, vLen: Int32) -> Void {
+    #if arch(wasm32)
+    let v = String(unsafeUninitializedCapacity: Int(vLen)) { b in
+        _swift_js_init_memory(vBytes, b.baseAddress.unsafelyUnwrapped)
+        return Int(vLen)
+    }
+    var ret = roundTripString(v: v)
+    return ret.withUTF8 { ptr in
+        _swift_js_return_string(ptr.baseAddress, Int32(ptr.count))
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_roundTripSwiftHeapObject")
+@_cdecl("bjs_roundTripSwiftHeapObject")
+public func _bjs_roundTripSwiftHeapObject(v: UnsafeMutableRawPointer) -> UnsafeMutableRawPointer {
+    #if arch(wasm32)
+    let ret = roundTripSwiftHeapObject(v: Unmanaged<Greeter>.fromOpaque(v).takeUnretainedValue())
+    return Unmanaged.passRetained(ret).toOpaque()
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_roundTripJSObject")
+@_cdecl("bjs_roundTripJSObject")
+public func _bjs_roundTripJSObject(v: Int32) -> Int32 {
+    #if arch(wasm32)
+    let ret = roundTripJSObject(v: JSObject(id: UInt32(bitPattern: v)))
+    return _swift_js_retain(Int32(bitPattern: ret.id))
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_throwsSwiftError")
+@_cdecl("bjs_throwsSwiftError")
+public func _bjs_throwsSwiftError(shouldThrow: Int32) -> Void {
+    #if arch(wasm32)
+    do {
+        try throwsSwiftError(shouldThrow: shouldThrow == 1)
+    } catch let error {
+        if let error = error.thrownValue.object {
+            withExtendedLifetime(error) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        } else {
+            let jsError = JSError(message: String(describing: error))
+            withExtendedLifetime(jsError.jsObject) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        }
+        return
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_throwsWithIntResult")
+@_cdecl("bjs_throwsWithIntResult")
+public func _bjs_throwsWithIntResult() -> Int32 {
+    #if arch(wasm32)
+    do {
+        let ret = try throwsWithIntResult()
+        return Int32(ret)
+    } catch let error {
+        if let error = error.thrownValue.object {
+            withExtendedLifetime(error) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        } else {
+            let jsError = JSError(message: String(describing: error))
+            withExtendedLifetime(jsError.jsObject) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        }
+        return 0
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_throwsWithStringResult")
+@_cdecl("bjs_throwsWithStringResult")
+public func _bjs_throwsWithStringResult() -> Void {
+    #if arch(wasm32)
+    do {
+        var ret = try throwsWithStringResult()
+        return ret.withUTF8 { ptr in
+            _swift_js_return_string(ptr.baseAddress, Int32(ptr.count))
+        }
+    } catch let error {
+        if let error = error.thrownValue.object {
+            withExtendedLifetime(error) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        } else {
+            let jsError = JSError(message: String(describing: error))
+            withExtendedLifetime(jsError.jsObject) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        }
+        return
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_throwsWithBoolResult")
+@_cdecl("bjs_throwsWithBoolResult")
+public func _bjs_throwsWithBoolResult() -> Int32 {
+    #if arch(wasm32)
+    do {
+        let ret = try throwsWithBoolResult()
+        return Int32(ret ? 1 : 0)
+    } catch let error {
+        if let error = error.thrownValue.object {
+            withExtendedLifetime(error) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        } else {
+            let jsError = JSError(message: String(describing: error))
+            withExtendedLifetime(jsError.jsObject) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        }
+        return 0
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_throwsWithFloatResult")
+@_cdecl("bjs_throwsWithFloatResult")
+public func _bjs_throwsWithFloatResult() -> Float32 {
+    #if arch(wasm32)
+    do {
+        let ret = try throwsWithFloatResult()
+        return Float32(ret)
+    } catch let error {
+        if let error = error.thrownValue.object {
+            withExtendedLifetime(error) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        } else {
+            let jsError = JSError(message: String(describing: error))
+            withExtendedLifetime(jsError.jsObject) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        }
+        return 0.0
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_throwsWithDoubleResult")
+@_cdecl("bjs_throwsWithDoubleResult")
+public func _bjs_throwsWithDoubleResult() -> Float64 {
+    #if arch(wasm32)
+    do {
+        let ret = try throwsWithDoubleResult()
+        return Float64(ret)
+    } catch let error {
+        if let error = error.thrownValue.object {
+            withExtendedLifetime(error) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        } else {
+            let jsError = JSError(message: String(describing: error))
+            withExtendedLifetime(jsError.jsObject) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        }
+        return 0.0
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_throwsWithSwiftHeapObjectResult")
+@_cdecl("bjs_throwsWithSwiftHeapObjectResult")
+public func _bjs_throwsWithSwiftHeapObjectResult() -> UnsafeMutableRawPointer {
+    #if arch(wasm32)
+    do {
+        let ret = try throwsWithSwiftHeapObjectResult()
+        return Unmanaged.passRetained(ret).toOpaque()
+    } catch let error {
+        if let error = error.thrownValue.object {
+            withExtendedLifetime(error) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        } else {
+            let jsError = JSError(message: String(describing: error))
+            withExtendedLifetime(jsError.jsObject) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        }
+        return UnsafeMutableRawPointer(bitPattern: -1).unsafelyUnwrapped
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_throwsWithJSObjectResult")
+@_cdecl("bjs_throwsWithJSObjectResult")
+public func _bjs_throwsWithJSObjectResult() -> Int32 {
+    #if arch(wasm32)
+    do {
+        let ret = try throwsWithJSObjectResult()
+        return _swift_js_retain(Int32(bitPattern: ret.id))
+    } catch let error {
+        if let error = error.thrownValue.object {
+            withExtendedLifetime(error) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        } else {
+            let jsError = JSError(message: String(describing: error))
+            withExtendedLifetime(jsError.jsObject) {
+                _swift_js_throw(Int32(bitPattern: $0.id))
+            }
+        }
+        return 0
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_takeGreeter")
+@_cdecl("bjs_takeGreeter")
+public func _bjs_takeGreeter(g: UnsafeMutableRawPointer, nameBytes: Int32, nameLen: Int32) -> Void {
+    #if arch(wasm32)
+    let name = String(unsafeUninitializedCapacity: Int(nameLen)) { b in
+        _swift_js_init_memory(nameBytes, b.baseAddress.unsafelyUnwrapped)
+        return Int(nameLen)
+    }
+    takeGreeter(g: Unmanaged<Greeter>.fromOpaque(g).takeUnretainedValue(), name: name)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_Greeter_init")
+@_cdecl("bjs_Greeter_init")
+public func _bjs_Greeter_init(nameBytes: Int32, nameLen: Int32) -> UnsafeMutableRawPointer {
+    #if arch(wasm32)
+    let name = String(unsafeUninitializedCapacity: Int(nameLen)) { b in
+        _swift_js_init_memory(nameBytes, b.baseAddress.unsafelyUnwrapped)
+        return Int(nameLen)
+    }
+    let ret = Greeter(name: name)
+    return Unmanaged.passRetained(ret).toOpaque()
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_Greeter_greet")
+@_cdecl("bjs_Greeter_greet")
+public func _bjs_Greeter_greet(_self: UnsafeMutableRawPointer) -> Void {
+    #if arch(wasm32)
+    var ret = Unmanaged<Greeter>.fromOpaque(_self).takeUnretainedValue().greet()
+    return ret.withUTF8 { ptr in
+        _swift_js_return_string(ptr.baseAddress, Int32(ptr.count))
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_Greeter_changeName")
+@_cdecl("bjs_Greeter_changeName")
+public func _bjs_Greeter_changeName(_self: UnsafeMutableRawPointer, nameBytes: Int32, nameLen: Int32) -> Void {
+    #if arch(wasm32)
+    let name = String(unsafeUninitializedCapacity: Int(nameLen)) { b in
+        _swift_js_init_memory(nameBytes, b.baseAddress.unsafelyUnwrapped)
+        return Int(nameLen)
+    }
+    Unmanaged<Greeter>.fromOpaque(_self).takeUnretainedValue().changeName(name: name)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_Greeter_deinit")
+@_cdecl("bjs_Greeter_deinit")
+public func _bjs_Greeter_deinit(pointer: UnsafeMutableRawPointer) {
+    Unmanaged<Greeter>.fromOpaque(pointer).release()
+}
\ No newline at end of file
diff --git a/Tests/BridgeJSRuntimeTests/Generated/BridgeJS.ImportTS.swift b/Tests/BridgeJSRuntimeTests/Generated/BridgeJS.ImportTS.swift
new file mode 100644
index 000000000..fd558ab8c
--- /dev/null
+++ b/Tests/BridgeJSRuntimeTests/Generated/BridgeJS.ImportTS.swift
@@ -0,0 +1,279 @@
+// NOTICE: This is auto-generated code by BridgeJS from JavaScriptKit,
+// DO NOT EDIT.
+//
+// To update this file, just rebuild your project or run
+// `swift package bridge-js`.
+
+@_spi(BridgeJS) import JavaScriptKit
+
+func jsRoundTripVoid() throws(JSException) -> Void {
+    #if arch(wasm32)
+    @_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_jsRoundTripVoid")
+    func bjs_jsRoundTripVoid() -> Void
+    #else
+    func bjs_jsRoundTripVoid() -> Void {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
+    bjs_jsRoundTripVoid()
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
+}
+
+func jsRoundTripNumber(_ v: Double) throws(JSException) -> Double {
+    #if arch(wasm32)
+    @_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_jsRoundTripNumber")
+    func bjs_jsRoundTripNumber(_ v: Float64) -> Float64
+    #else
+    func bjs_jsRoundTripNumber(_ v: Float64) -> Float64 {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
+    let ret = bjs_jsRoundTripNumber(v)
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
+    return Double(ret)
+}
+
+func jsRoundTripBool(_ v: Bool) throws(JSException) -> Bool {
+    #if arch(wasm32)
+    @_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_jsRoundTripBool")
+    func bjs_jsRoundTripBool(_ v: Int32) -> Int32
+    #else
+    func bjs_jsRoundTripBool(_ v: Int32) -> Int32 {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
+    let ret = bjs_jsRoundTripBool(Int32(v ? 1 : 0))
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
+    return ret == 1
+}
+
+func jsRoundTripString(_ v: String) throws(JSException) -> String {
+    #if arch(wasm32)
+    @_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_jsRoundTripString")
+    func bjs_jsRoundTripString(_ v: Int32) -> Int32
+    #else
+    func bjs_jsRoundTripString(_ v: Int32) -> Int32 {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
+    var v = v
+    let vId = v.withUTF8 { b in
+        _swift_js_make_js_string(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
+    }
+    let ret = bjs_jsRoundTripString(vId)
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
+    return String(unsafeUninitializedCapacity: Int(ret)) { b in
+        _swift_js_init_memory_with_result(b.baseAddress.unsafelyUnwrapped, Int32(ret))
+        return Int(ret)
+    }
+}
+
+func jsThrowOrVoid(_ shouldThrow: Bool) throws(JSException) -> Void {
+    #if arch(wasm32)
+    @_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_jsThrowOrVoid")
+    func bjs_jsThrowOrVoid(_ shouldThrow: Int32) -> Void
+    #else
+    func bjs_jsThrowOrVoid(_ shouldThrow: Int32) -> Void {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
+    bjs_jsThrowOrVoid(Int32(shouldThrow ? 1 : 0))
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
+}
+
+func jsThrowOrNumber(_ shouldThrow: Bool) throws(JSException) -> Double {
+    #if arch(wasm32)
+    @_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_jsThrowOrNumber")
+    func bjs_jsThrowOrNumber(_ shouldThrow: Int32) -> Float64
+    #else
+    func bjs_jsThrowOrNumber(_ shouldThrow: Int32) -> Float64 {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
+    let ret = bjs_jsThrowOrNumber(Int32(shouldThrow ? 1 : 0))
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
+    return Double(ret)
+}
+
+func jsThrowOrBool(_ shouldThrow: Bool) throws(JSException) -> Bool {
+    #if arch(wasm32)
+    @_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_jsThrowOrBool")
+    func bjs_jsThrowOrBool(_ shouldThrow: Int32) -> Int32
+    #else
+    func bjs_jsThrowOrBool(_ shouldThrow: Int32) -> Int32 {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
+    let ret = bjs_jsThrowOrBool(Int32(shouldThrow ? 1 : 0))
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
+    return ret == 1
+}
+
+func jsThrowOrString(_ shouldThrow: Bool) throws(JSException) -> String {
+    #if arch(wasm32)
+    @_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_jsThrowOrString")
+    func bjs_jsThrowOrString(_ shouldThrow: Int32) -> Int32
+    #else
+    func bjs_jsThrowOrString(_ shouldThrow: Int32) -> Int32 {
+        fatalError("Only available on WebAssembly")
+    }
+    #endif
+    let ret = bjs_jsThrowOrString(Int32(shouldThrow ? 1 : 0))
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
+    return String(unsafeUninitializedCapacity: Int(ret)) { b in
+        _swift_js_init_memory_with_result(b.baseAddress.unsafelyUnwrapped, Int32(ret))
+        return Int(ret)
+    }
+}
+
+struct JsGreeter {
+    let this: JSObject
+
+    init(this: JSObject) {
+        self.this = this
+    }
+
+    init(takingThis this: Int32) {
+        self.this = JSObject(id: UInt32(bitPattern: this))
+    }
+
+    init(_ name: String, _ prefix: String) throws(JSException) {
+        #if arch(wasm32)
+        @_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_JsGreeter_init")
+        func bjs_JsGreeter_init(_ name: Int32, _ prefix: Int32) -> Int32
+        #else
+        func bjs_JsGreeter_init(_ name: Int32, _ prefix: Int32) -> Int32 {
+            fatalError("Only available on WebAssembly")
+        }
+        #endif
+        var name = name
+        let nameId = name.withUTF8 { b in
+            _swift_js_make_js_string(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
+        }
+        var prefix = prefix
+        let prefixId = prefix.withUTF8 { b in
+            _swift_js_make_js_string(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
+        }
+        let ret = bjs_JsGreeter_init(nameId, prefixId)
+        if let error = _swift_js_take_exception() {
+            throw error
+        }
+        self.this = JSObject(id: UInt32(bitPattern: ret))
+    }
+
+    var name: String {
+        get throws(JSException) {
+            #if arch(wasm32)
+            @_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_JsGreeter_name_get")
+            func bjs_JsGreeter_name_get(_ self: Int32) -> Int32
+            #else
+            func bjs_JsGreeter_name_get(_ self: Int32) -> Int32 {
+                fatalError("Only available on WebAssembly")
+            }
+            #endif
+            let ret = bjs_JsGreeter_name_get(Int32(bitPattern: self.this.id))
+            if let error = _swift_js_take_exception() {
+                throw error
+            }
+            return String(unsafeUninitializedCapacity: Int(ret)) { b in
+                _swift_js_init_memory_with_result(b.baseAddress.unsafelyUnwrapped, Int32(ret))
+                return Int(ret)
+            }
+        }
+    }
+
+    func setName(_ newValue: String) throws(JSException) -> Void {
+        #if arch(wasm32)
+        @_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_JsGreeter_name_set")
+        func bjs_JsGreeter_name_set(_ self: Int32, _ newValue: Int32) -> Void
+        #else
+        func bjs_JsGreeter_name_set(_ self: Int32, _ newValue: Int32) -> Void {
+            fatalError("Only available on WebAssembly")
+        }
+        #endif
+        var newValue = newValue
+        let newValueId = newValue.withUTF8 { b in
+            _swift_js_make_js_string(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
+        }
+        bjs_JsGreeter_name_set(Int32(bitPattern: self.this.id), newValueId)
+        if let error = _swift_js_take_exception() {
+            throw error
+        }
+    }
+
+    var prefix: String {
+        get throws(JSException) {
+            #if arch(wasm32)
+            @_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_JsGreeter_prefix_get")
+            func bjs_JsGreeter_prefix_get(_ self: Int32) -> Int32
+            #else
+            func bjs_JsGreeter_prefix_get(_ self: Int32) -> Int32 {
+                fatalError("Only available on WebAssembly")
+            }
+            #endif
+            let ret = bjs_JsGreeter_prefix_get(Int32(bitPattern: self.this.id))
+            if let error = _swift_js_take_exception() {
+                throw error
+            }
+            return String(unsafeUninitializedCapacity: Int(ret)) { b in
+                _swift_js_init_memory_with_result(b.baseAddress.unsafelyUnwrapped, Int32(ret))
+                return Int(ret)
+            }
+        }
+    }
+
+    func greet() throws(JSException) -> String {
+        #if arch(wasm32)
+        @_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_JsGreeter_greet")
+        func bjs_JsGreeter_greet(_ self: Int32) -> Int32
+        #else
+        func bjs_JsGreeter_greet(_ self: Int32) -> Int32 {
+            fatalError("Only available on WebAssembly")
+        }
+        #endif
+        let ret = bjs_JsGreeter_greet(Int32(bitPattern: self.this.id))
+        if let error = _swift_js_take_exception() {
+            throw error
+        }
+        return String(unsafeUninitializedCapacity: Int(ret)) { b in
+            _swift_js_init_memory_with_result(b.baseAddress.unsafelyUnwrapped, Int32(ret))
+            return Int(ret)
+        }
+    }
+
+    func changeName(_ name: String) throws(JSException) -> Void {
+        #if arch(wasm32)
+        @_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_JsGreeter_changeName")
+        func bjs_JsGreeter_changeName(_ self: Int32, _ name: Int32) -> Void
+        #else
+        func bjs_JsGreeter_changeName(_ self: Int32, _ name: Int32) -> Void {
+            fatalError("Only available on WebAssembly")
+        }
+        #endif
+        var name = name
+        let nameId = name.withUTF8 { b in
+            _swift_js_make_js_string(b.baseAddress.unsafelyUnwrapped, Int32(b.count))
+        }
+        bjs_JsGreeter_changeName(Int32(bitPattern: self.this.id), nameId)
+        if let error = _swift_js_take_exception() {
+            throw error
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/Tests/BridgeJSRuntimeTests/Generated/ExportSwift.swift b/Tests/BridgeJSRuntimeTests/Generated/ExportSwift.swift
deleted file mode 100644
index cc3c9df31..000000000
--- a/Tests/BridgeJSRuntimeTests/Generated/ExportSwift.swift
+++ /dev/null
@@ -1,98 +0,0 @@
-@_extern(wasm, module: "bjs", name: "return_string")
-private func _return_string(_ ptr: UnsafePointer<UInt8>?, _ len: Int32)
-@_extern(wasm, module: "bjs", name: "init_memory")
-private func _init_memory(_ sourceId: Int32, _ ptr: UnsafeMutablePointer<UInt8>?)
-
-@_expose(wasm, "bjs_roundTripInt")
-@_cdecl("bjs_roundTripInt")
-public func _bjs_roundTripInt(v: Int32) -> Int32 {
-    let ret = roundTripInt(v: Int(v))
-    return Int32(ret)
-}
-
-@_expose(wasm, "bjs_roundTripFloat")
-@_cdecl("bjs_roundTripFloat")
-public func _bjs_roundTripFloat(v: Float32) -> Float32 {
-    let ret = roundTripFloat(v: v)
-    return Float32(ret)
-}
-
-@_expose(wasm, "bjs_roundTripDouble")
-@_cdecl("bjs_roundTripDouble")
-public func _bjs_roundTripDouble(v: Float64) -> Float64 {
-    let ret = roundTripDouble(v: v)
-    return Float64(ret)
-}
-
-@_expose(wasm, "bjs_roundTripBool")
-@_cdecl("bjs_roundTripBool")
-public func _bjs_roundTripBool(v: Int32) -> Int32 {
-    let ret = roundTripBool(v: v == 1)
-    return Int32(ret ? 1 : 0)
-}
-
-@_expose(wasm, "bjs_roundTripString")
-@_cdecl("bjs_roundTripString")
-public func _bjs_roundTripString(vBytes: Int32, vLen: Int32) -> Void {
-    let v = String(unsafeUninitializedCapacity: Int(vLen)) { b in
-        _init_memory(vBytes, b.baseAddress.unsafelyUnwrapped)
-        return Int(vLen)
-    }
-    var ret = roundTripString(v: v)
-    return ret.withUTF8 { ptr in
-        _return_string(ptr.baseAddress, Int32(ptr.count))
-    }
-}
-
-@_expose(wasm, "bjs_roundTripSwiftHeapObject")
-@_cdecl("bjs_roundTripSwiftHeapObject")
-public func _bjs_roundTripSwiftHeapObject(v: UnsafeMutableRawPointer) -> UnsafeMutableRawPointer {
-    let ret = roundTripSwiftHeapObject(v: Unmanaged<Greeter>.fromOpaque(v).takeUnretainedValue())
-    return Unmanaged.passRetained(ret).toOpaque()
-}
-
-@_expose(wasm, "bjs_takeGreeter")
-@_cdecl("bjs_takeGreeter")
-public func _bjs_takeGreeter(g: UnsafeMutableRawPointer, nameBytes: Int32, nameLen: Int32) -> Void {
-    let name = String(unsafeUninitializedCapacity: Int(nameLen)) { b in
-        _init_memory(nameBytes, b.baseAddress.unsafelyUnwrapped)
-        return Int(nameLen)
-    }
-    takeGreeter(g: Unmanaged<Greeter>.fromOpaque(g).takeUnretainedValue(), name: name)
-}
-
-@_expose(wasm, "bjs_Greeter_init")
-@_cdecl("bjs_Greeter_init")
-public func _bjs_Greeter_init(nameBytes: Int32, nameLen: Int32) -> UnsafeMutableRawPointer {
-    let name = String(unsafeUninitializedCapacity: Int(nameLen)) { b in
-        _init_memory(nameBytes, b.baseAddress.unsafelyUnwrapped)
-        return Int(nameLen)
-    }
-    let ret = Greeter(name: name)
-    return Unmanaged.passRetained(ret).toOpaque()
-}
-
-@_expose(wasm, "bjs_Greeter_greet")
-@_cdecl("bjs_Greeter_greet")
-public func _bjs_Greeter_greet(_self: UnsafeMutableRawPointer) -> Void {
-    var ret = Unmanaged<Greeter>.fromOpaque(_self).takeUnretainedValue().greet()
-    return ret.withUTF8 { ptr in
-        _return_string(ptr.baseAddress, Int32(ptr.count))
-    }
-}
-
-@_expose(wasm, "bjs_Greeter_changeName")
-@_cdecl("bjs_Greeter_changeName")
-public func _bjs_Greeter_changeName(_self: UnsafeMutableRawPointer, nameBytes: Int32, nameLen: Int32) -> Void {
-    let name = String(unsafeUninitializedCapacity: Int(nameLen)) { b in
-        _init_memory(nameBytes, b.baseAddress.unsafelyUnwrapped)
-        return Int(nameLen)
-    }
-    Unmanaged<Greeter>.fromOpaque(_self).takeUnretainedValue().changeName(name: name)
-}
-
-@_expose(wasm, "bjs_Greeter_deinit")
-@_cdecl("bjs_Greeter_deinit")
-public func _bjs_Greeter_deinit(pointer: UnsafeMutableRawPointer) {
-    Unmanaged<Greeter>.fromOpaque(pointer).release()
-}
\ No newline at end of file
diff --git a/Tests/BridgeJSRuntimeTests/Generated/JavaScript/BridgeJS.ExportSwift.json b/Tests/BridgeJSRuntimeTests/Generated/JavaScript/BridgeJS.ExportSwift.json
new file mode 100644
index 000000000..7a467cc30
--- /dev/null
+++ b/Tests/BridgeJSRuntimeTests/Generated/JavaScript/BridgeJS.ExportSwift.json
@@ -0,0 +1,422 @@
+{
+  "classes" : [
+    {
+      "constructor" : {
+        "abiName" : "bjs_Greeter_init",
+        "effects" : {
+          "isAsync" : false,
+          "isThrows" : false
+        },
+        "parameters" : [
+          {
+            "label" : "name",
+            "name" : "name",
+            "type" : {
+              "string" : {
+
+              }
+            }
+          }
+        ]
+      },
+      "methods" : [
+        {
+          "abiName" : "bjs_Greeter_greet",
+          "effects" : {
+            "isAsync" : false,
+            "isThrows" : false
+          },
+          "name" : "greet",
+          "parameters" : [
+
+          ],
+          "returnType" : {
+            "string" : {
+
+            }
+          }
+        },
+        {
+          "abiName" : "bjs_Greeter_changeName",
+          "effects" : {
+            "isAsync" : false,
+            "isThrows" : false
+          },
+          "name" : "changeName",
+          "parameters" : [
+            {
+              "label" : "name",
+              "name" : "name",
+              "type" : {
+                "string" : {
+
+                }
+              }
+            }
+          ],
+          "returnType" : {
+            "void" : {
+
+            }
+          }
+        }
+      ],
+      "name" : "Greeter"
+    }
+  ],
+  "functions" : [
+    {
+      "abiName" : "bjs_roundTripVoid",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
+      "name" : "roundTripVoid",
+      "parameters" : [
+
+      ],
+      "returnType" : {
+        "void" : {
+
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_roundTripInt",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
+      "name" : "roundTripInt",
+      "parameters" : [
+        {
+          "label" : "v",
+          "name" : "v",
+          "type" : {
+            "int" : {
+
+            }
+          }
+        }
+      ],
+      "returnType" : {
+        "int" : {
+
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_roundTripFloat",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
+      "name" : "roundTripFloat",
+      "parameters" : [
+        {
+          "label" : "v",
+          "name" : "v",
+          "type" : {
+            "float" : {
+
+            }
+          }
+        }
+      ],
+      "returnType" : {
+        "float" : {
+
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_roundTripDouble",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
+      "name" : "roundTripDouble",
+      "parameters" : [
+        {
+          "label" : "v",
+          "name" : "v",
+          "type" : {
+            "double" : {
+
+            }
+          }
+        }
+      ],
+      "returnType" : {
+        "double" : {
+
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_roundTripBool",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
+      "name" : "roundTripBool",
+      "parameters" : [
+        {
+          "label" : "v",
+          "name" : "v",
+          "type" : {
+            "bool" : {
+
+            }
+          }
+        }
+      ],
+      "returnType" : {
+        "bool" : {
+
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_roundTripString",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
+      "name" : "roundTripString",
+      "parameters" : [
+        {
+          "label" : "v",
+          "name" : "v",
+          "type" : {
+            "string" : {
+
+            }
+          }
+        }
+      ],
+      "returnType" : {
+        "string" : {
+
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_roundTripSwiftHeapObject",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
+      "name" : "roundTripSwiftHeapObject",
+      "parameters" : [
+        {
+          "label" : "v",
+          "name" : "v",
+          "type" : {
+            "swiftHeapObject" : {
+              "_0" : "Greeter"
+            }
+          }
+        }
+      ],
+      "returnType" : {
+        "swiftHeapObject" : {
+          "_0" : "Greeter"
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_roundTripJSObject",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
+      "name" : "roundTripJSObject",
+      "parameters" : [
+        {
+          "label" : "v",
+          "name" : "v",
+          "type" : {
+            "jsObject" : {
+
+            }
+          }
+        }
+      ],
+      "returnType" : {
+        "jsObject" : {
+
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_throwsSwiftError",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : true
+      },
+      "name" : "throwsSwiftError",
+      "parameters" : [
+        {
+          "label" : "shouldThrow",
+          "name" : "shouldThrow",
+          "type" : {
+            "bool" : {
+
+            }
+          }
+        }
+      ],
+      "returnType" : {
+        "void" : {
+
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_throwsWithIntResult",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : true
+      },
+      "name" : "throwsWithIntResult",
+      "parameters" : [
+
+      ],
+      "returnType" : {
+        "int" : {
+
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_throwsWithStringResult",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : true
+      },
+      "name" : "throwsWithStringResult",
+      "parameters" : [
+
+      ],
+      "returnType" : {
+        "string" : {
+
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_throwsWithBoolResult",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : true
+      },
+      "name" : "throwsWithBoolResult",
+      "parameters" : [
+
+      ],
+      "returnType" : {
+        "bool" : {
+
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_throwsWithFloatResult",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : true
+      },
+      "name" : "throwsWithFloatResult",
+      "parameters" : [
+
+      ],
+      "returnType" : {
+        "float" : {
+
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_throwsWithDoubleResult",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : true
+      },
+      "name" : "throwsWithDoubleResult",
+      "parameters" : [
+
+      ],
+      "returnType" : {
+        "double" : {
+
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_throwsWithSwiftHeapObjectResult",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : true
+      },
+      "name" : "throwsWithSwiftHeapObjectResult",
+      "parameters" : [
+
+      ],
+      "returnType" : {
+        "swiftHeapObject" : {
+          "_0" : "Greeter"
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_throwsWithJSObjectResult",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : true
+      },
+      "name" : "throwsWithJSObjectResult",
+      "parameters" : [
+
+      ],
+      "returnType" : {
+        "jsObject" : {
+
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_takeGreeter",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
+      "name" : "takeGreeter",
+      "parameters" : [
+        {
+          "label" : "g",
+          "name" : "g",
+          "type" : {
+            "swiftHeapObject" : {
+              "_0" : "Greeter"
+            }
+          }
+        },
+        {
+          "label" : "name",
+          "name" : "name",
+          "type" : {
+            "string" : {
+
+            }
+          }
+        }
+      ],
+      "returnType" : {
+        "void" : {
+
+        }
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Tests/BridgeJSRuntimeTests/Generated/JavaScript/BridgeJS.ImportTS.json b/Tests/BridgeJSRuntimeTests/Generated/JavaScript/BridgeJS.ImportTS.json
new file mode 100644
index 000000000..bf3190b80
--- /dev/null
+++ b/Tests/BridgeJSRuntimeTests/Generated/JavaScript/BridgeJS.ImportTS.json
@@ -0,0 +1,222 @@
+{
+  "children" : [
+    {
+      "functions" : [
+        {
+          "name" : "jsRoundTripVoid",
+          "parameters" : [
+
+          ],
+          "returnType" : {
+            "void" : {
+
+            }
+          }
+        },
+        {
+          "name" : "jsRoundTripNumber",
+          "parameters" : [
+            {
+              "name" : "v",
+              "type" : {
+                "double" : {
+
+                }
+              }
+            }
+          ],
+          "returnType" : {
+            "double" : {
+
+            }
+          }
+        },
+        {
+          "name" : "jsRoundTripBool",
+          "parameters" : [
+            {
+              "name" : "v",
+              "type" : {
+                "bool" : {
+
+                }
+              }
+            }
+          ],
+          "returnType" : {
+            "bool" : {
+
+            }
+          }
+        },
+        {
+          "name" : "jsRoundTripString",
+          "parameters" : [
+            {
+              "name" : "v",
+              "type" : {
+                "string" : {
+
+                }
+              }
+            }
+          ],
+          "returnType" : {
+            "string" : {
+
+            }
+          }
+        },
+        {
+          "name" : "jsThrowOrVoid",
+          "parameters" : [
+            {
+              "name" : "shouldThrow",
+              "type" : {
+                "bool" : {
+
+                }
+              }
+            }
+          ],
+          "returnType" : {
+            "void" : {
+
+            }
+          }
+        },
+        {
+          "name" : "jsThrowOrNumber",
+          "parameters" : [
+            {
+              "name" : "shouldThrow",
+              "type" : {
+                "bool" : {
+
+                }
+              }
+            }
+          ],
+          "returnType" : {
+            "double" : {
+
+            }
+          }
+        },
+        {
+          "name" : "jsThrowOrBool",
+          "parameters" : [
+            {
+              "name" : "shouldThrow",
+              "type" : {
+                "bool" : {
+
+                }
+              }
+            }
+          ],
+          "returnType" : {
+            "bool" : {
+
+            }
+          }
+        },
+        {
+          "name" : "jsThrowOrString",
+          "parameters" : [
+            {
+              "name" : "shouldThrow",
+              "type" : {
+                "bool" : {
+
+                }
+              }
+            }
+          ],
+          "returnType" : {
+            "string" : {
+
+            }
+          }
+        }
+      ],
+      "types" : [
+        {
+          "constructor" : {
+            "parameters" : [
+              {
+                "name" : "name",
+                "type" : {
+                  "string" : {
+
+                  }
+                }
+              },
+              {
+                "name" : "prefix",
+                "type" : {
+                  "string" : {
+
+                  }
+                }
+              }
+            ]
+          },
+          "methods" : [
+            {
+              "name" : "greet",
+              "parameters" : [
+
+              ],
+              "returnType" : {
+                "string" : {
+
+                }
+              }
+            },
+            {
+              "name" : "changeName",
+              "parameters" : [
+                {
+                  "name" : "name",
+                  "type" : {
+                    "string" : {
+
+                    }
+                  }
+                }
+              ],
+              "returnType" : {
+                "void" : {
+
+                }
+              }
+            }
+          ],
+          "name" : "JsGreeter",
+          "properties" : [
+            {
+              "isReadonly" : false,
+              "name" : "name",
+              "type" : {
+                "string" : {
+
+                }
+              }
+            },
+            {
+              "isReadonly" : true,
+              "name" : "prefix",
+              "type" : {
+                "string" : {
+
+                }
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "moduleName" : "BridgeJSRuntimeTests"
+}
\ No newline at end of file
diff --git a/Tests/BridgeJSRuntimeTests/Generated/JavaScript/ExportSwift.json b/Tests/BridgeJSRuntimeTests/Generated/JavaScript/ExportSwift.json
deleted file mode 100644
index f60426a09..000000000
--- a/Tests/BridgeJSRuntimeTests/Generated/JavaScript/ExportSwift.json
+++ /dev/null
@@ -1,206 +0,0 @@
-{
-  "classes" : [
-    {
-      "constructor" : {
-        "abiName" : "bjs_Greeter_init",
-        "parameters" : [
-          {
-            "label" : "name",
-            "name" : "name",
-            "type" : {
-              "string" : {
-
-              }
-            }
-          }
-        ]
-      },
-      "methods" : [
-        {
-          "abiName" : "bjs_Greeter_greet",
-          "name" : "greet",
-          "parameters" : [
-
-          ],
-          "returnType" : {
-            "string" : {
-
-            }
-          }
-        },
-        {
-          "abiName" : "bjs_Greeter_changeName",
-          "name" : "changeName",
-          "parameters" : [
-            {
-              "label" : "name",
-              "name" : "name",
-              "type" : {
-                "string" : {
-
-                }
-              }
-            }
-          ],
-          "returnType" : {
-            "void" : {
-
-            }
-          }
-        }
-      ],
-      "name" : "Greeter"
-    }
-  ],
-  "functions" : [
-    {
-      "abiName" : "bjs_roundTripInt",
-      "name" : "roundTripInt",
-      "parameters" : [
-        {
-          "label" : "v",
-          "name" : "v",
-          "type" : {
-            "int" : {
-
-            }
-          }
-        }
-      ],
-      "returnType" : {
-        "int" : {
-
-        }
-      }
-    },
-    {
-      "abiName" : "bjs_roundTripFloat",
-      "name" : "roundTripFloat",
-      "parameters" : [
-        {
-          "label" : "v",
-          "name" : "v",
-          "type" : {
-            "float" : {
-
-            }
-          }
-        }
-      ],
-      "returnType" : {
-        "float" : {
-
-        }
-      }
-    },
-    {
-      "abiName" : "bjs_roundTripDouble",
-      "name" : "roundTripDouble",
-      "parameters" : [
-        {
-          "label" : "v",
-          "name" : "v",
-          "type" : {
-            "double" : {
-
-            }
-          }
-        }
-      ],
-      "returnType" : {
-        "double" : {
-
-        }
-      }
-    },
-    {
-      "abiName" : "bjs_roundTripBool",
-      "name" : "roundTripBool",
-      "parameters" : [
-        {
-          "label" : "v",
-          "name" : "v",
-          "type" : {
-            "bool" : {
-
-            }
-          }
-        }
-      ],
-      "returnType" : {
-        "bool" : {
-
-        }
-      }
-    },
-    {
-      "abiName" : "bjs_roundTripString",
-      "name" : "roundTripString",
-      "parameters" : [
-        {
-          "label" : "v",
-          "name" : "v",
-          "type" : {
-            "string" : {
-
-            }
-          }
-        }
-      ],
-      "returnType" : {
-        "string" : {
-
-        }
-      }
-    },
-    {
-      "abiName" : "bjs_roundTripSwiftHeapObject",
-      "name" : "roundTripSwiftHeapObject",
-      "parameters" : [
-        {
-          "label" : "v",
-          "name" : "v",
-          "type" : {
-            "swiftHeapObject" : {
-              "_0" : "Greeter"
-            }
-          }
-        }
-      ],
-      "returnType" : {
-        "swiftHeapObject" : {
-          "_0" : "Greeter"
-        }
-      }
-    },
-    {
-      "abiName" : "bjs_takeGreeter",
-      "name" : "takeGreeter",
-      "parameters" : [
-        {
-          "label" : "g",
-          "name" : "g",
-          "type" : {
-            "swiftHeapObject" : {
-              "_0" : "Greeter"
-            }
-          }
-        },
-        {
-          "label" : "name",
-          "name" : "name",
-          "type" : {
-            "string" : {
-
-            }
-          }
-        }
-      ],
-      "returnType" : {
-        "void" : {
-
-        }
-      }
-    }
-  ]
-}
\ No newline at end of file
diff --git a/Tests/BridgeJSRuntimeTests/ImportAPITests.swift b/Tests/BridgeJSRuntimeTests/ImportAPITests.swift
new file mode 100644
index 000000000..f0112ed1a
--- /dev/null
+++ b/Tests/BridgeJSRuntimeTests/ImportAPITests.swift
@@ -0,0 +1,87 @@
+import XCTest
+import JavaScriptKit
+
+class ImportAPITests: XCTestCase {
+    func testRoundTripVoid() throws {
+        try jsRoundTripVoid()
+    }
+
+    func testRoundTripNumber() throws {
+        for v in [
+            0, 1, -1,
+            Double(Int32.max), Double(Int32.min),
+            Double(Int64.max), Double(Int64.min),
+            Double(UInt32.max), Double(UInt32.min),
+            Double(UInt64.max), Double(UInt64.min),
+            Double.greatestFiniteMagnitude, Double.leastNonzeroMagnitude,
+            Double.infinity,
+            Double.pi,
+        ] {
+            try XCTAssertEqual(jsRoundTripNumber(v), v)
+        }
+
+        try XCTAssert(jsRoundTripNumber(Double.nan).isNaN)
+    }
+
+    func testRoundTripBool() throws {
+        for v in [true, false] {
+            try XCTAssertEqual(jsRoundTripBool(v), v)
+        }
+    }
+
+    func testRoundTripString() throws {
+        for v in ["", "Hello, world!", "🧑‍🧑‍🧒"] {
+            try XCTAssertEqual(jsRoundTripString(v), v)
+        }
+    }
+
+    func ensureThrows<T>(_ f: (Bool) throws(JSException) -> T) throws {
+        do {
+            _ = try f(true)
+            XCTFail("Expected exception")
+        } catch {
+            XCTAssertTrue(error.description.contains("TestError"))
+        }
+    }
+    func ensureDoesNotThrow<T>(_ f: (Bool) throws(JSException) -> T, _ assertValue: (T) -> Void) throws {
+        do {
+            let result = try f(false)
+            assertValue(result)
+        } catch {
+            XCTFail("Expected no exception")
+        }
+    }
+
+    func testThrowOrVoid() throws {
+        try ensureThrows(jsThrowOrVoid)
+        try ensureDoesNotThrow(jsThrowOrVoid, { _ in })
+    }
+
+    func testThrowOrNumber() throws {
+        try ensureThrows(jsThrowOrNumber)
+        try ensureDoesNotThrow(jsThrowOrNumber, { XCTAssertEqual($0, 1) })
+    }
+
+    func testThrowOrBool() throws {
+        try ensureThrows(jsThrowOrBool)
+        try ensureDoesNotThrow(jsThrowOrBool, { XCTAssertEqual($0, true) })
+    }
+
+    func testThrowOrString() throws {
+        try ensureThrows(jsThrowOrString)
+        try ensureDoesNotThrow(jsThrowOrString, { XCTAssertEqual($0, "Hello, world!") })
+    }
+
+    func testClass() throws {
+        let greeter = try JsGreeter("Alice", "Hello")
+        XCTAssertEqual(try greeter.greet(), "Hello, Alice!")
+        try greeter.changeName("Bob")
+        XCTAssertEqual(try greeter.greet(), "Hello, Bob!")
+
+        try greeter.setName("Charlie")
+        XCTAssertEqual(try greeter.greet(), "Hello, Charlie!")
+        XCTAssertEqual(try greeter.name, "Charlie")
+
+        XCTAssertEqual(try greeter.prefix, "Hello")
+    }
+}
diff --git a/Tests/BridgeJSRuntimeTests/bridge-js.config.json b/Tests/BridgeJSRuntimeTests/bridge-js.config.json
new file mode 100644
index 000000000..9e26dfeeb
--- /dev/null
+++ b/Tests/BridgeJSRuntimeTests/bridge-js.config.json
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/Tests/BridgeJSRuntimeTests/bridge-js.d.ts b/Tests/BridgeJSRuntimeTests/bridge-js.d.ts
new file mode 100644
index 000000000..b03ef5706
--- /dev/null
+++ b/Tests/BridgeJSRuntimeTests/bridge-js.d.ts
@@ -0,0 +1,16 @@
+export function jsRoundTripVoid(): void
+export function jsRoundTripNumber(v: number): number
+export function jsRoundTripBool(v: boolean): boolean
+export function jsRoundTripString(v: string): string
+export function jsThrowOrVoid(shouldThrow: boolean): void
+export function jsThrowOrNumber(shouldThrow: boolean): number
+export function jsThrowOrBool(shouldThrow: boolean): boolean
+export function jsThrowOrString(shouldThrow: boolean): string
+
+export class JsGreeter {
+    name: string;
+    readonly prefix: string;
+    constructor(name: string, prefix: string);
+    greet(): string;
+    changeName(name: string): void;
+}
diff --git a/Tests/JavaScriptEventLoopTests/JSClosure+AsyncTests.swift b/Tests/JavaScriptEventLoopTests/JSClosure+AsyncTests.swift
new file mode 100644
index 000000000..e3c19a8e4
--- /dev/null
+++ b/Tests/JavaScriptEventLoopTests/JSClosure+AsyncTests.swift
@@ -0,0 +1,110 @@
+import JavaScriptKit
+import XCTest
+
+class JSClosureAsyncTests: XCTestCase {
+    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+    final class AnyTaskExecutor: TaskExecutor {
+        func enqueue(_ job: UnownedJob) {
+            job.runSynchronously(on: asUnownedTaskExecutor())
+        }
+    }
+
+    final class UnsafeSendableBox<T>: @unchecked Sendable {
+        var value: T
+        init(_ value: T) {
+            self.value = value
+        }
+    }
+
+    func testAsyncClosure() async throws {
+        let closure = JSClosure.async { _ in
+            return (42.0).jsValue
+        }.jsValue
+        let result = try await JSPromise(from: closure.function!())!.value()
+        XCTAssertEqual(result, 42.0)
+    }
+
+    func testAsyncClosureWithPriority() async throws {
+        let priority = UnsafeSendableBox<TaskPriority?>(nil)
+        let closure = JSClosure.async(priority: .high) { _ in
+            priority.value = Task.currentPriority
+            return (42.0).jsValue
+        }.jsValue
+        let result = try await JSPromise(from: closure.function!())!.value()
+        XCTAssertEqual(result, 42.0)
+        XCTAssertEqual(priority.value, .high)
+    }
+
+    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+    func testAsyncClosureWithTaskExecutor() async throws {
+        let executor = AnyTaskExecutor()
+        let closure = JSClosure.async(executorPreference: executor) { _ in
+            return (42.0).jsValue
+        }.jsValue
+        let result = try await JSPromise(from: closure.function!())!.value()
+        XCTAssertEqual(result, 42.0)
+    }
+
+    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+    func testAsyncClosureWithTaskExecutorPreference() async throws {
+        let executor = AnyTaskExecutor()
+        let priority = UnsafeSendableBox<TaskPriority?>(nil)
+        let closure = JSClosure.async(executorPreference: executor, priority: .high) { _ in
+            priority.value = Task.currentPriority
+            return (42.0).jsValue
+        }.jsValue
+        let result = try await JSPromise(from: closure.function!())!.value()
+        XCTAssertEqual(result, 42.0)
+        XCTAssertEqual(priority.value, .high)
+    }
+
+    // TODO: Enable the following tests once:
+    // - Make JSObject a final-class
+    // - Unify JSFunction and JSObject into JSValue
+    // - Make JS(Oneshot)Closure as a wrapper of JSObject, not a subclass
+    /*
+    func testAsyncOneshotClosure() async throws {
+        let closure = JSOneshotClosure.async { _ in
+            return (42.0).jsValue
+        }.jsValue
+        let result = try await JSPromise(
+            from: closure.function!()
+        )!.value()
+        XCTAssertEqual(result, 42.0)
+    }
+
+    func testAsyncOneshotClosureWithPriority() async throws {
+        let priority = UnsafeSendableBox<TaskPriority?>(nil)
+        let closure = JSOneshotClosure.async(priority: .high) { _ in
+            priority.value = Task.currentPriority
+            return (42.0).jsValue
+        }.jsValue
+        let result = try await JSPromise(from: closure.function!())!.value()
+        XCTAssertEqual(result, 42.0)
+        XCTAssertEqual(priority.value, .high)
+    }
+
+    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+    func testAsyncOneshotClosureWithTaskExecutor() async throws {
+        let executor = AnyTaskExecutor()
+        let closure = JSOneshotClosure.async(executorPreference: executor) { _ in
+            return (42.0).jsValue
+        }.jsValue
+        let result = try await JSPromise(from: closure.function!())!.value()
+        XCTAssertEqual(result, 42.0)
+    }
+
+    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+    func testAsyncOneshotClosureWithTaskExecutorPreference() async throws {
+        let executor = AnyTaskExecutor()
+        let priority = UnsafeSendableBox<TaskPriority?>(nil)
+        let closure = JSOneshotClosure.async(executorPreference: executor, priority: .high) { _ in
+            priority.value = Task.currentPriority
+            return (42.0).jsValue
+        }.jsValue
+        let result = try await JSPromise(from: closure.function!())!.value()
+        XCTAssertEqual(result, 42.0)
+        XCTAssertEqual(priority.value, .high)
+    }
+    */
+}
diff --git a/Tests/JavaScriptFoundationCompatTests/Data+JSValueTests.swift b/Tests/JavaScriptFoundationCompatTests/Data+JSValueTests.swift
new file mode 100644
index 000000000..8c0d6162d
--- /dev/null
+++ b/Tests/JavaScriptFoundationCompatTests/Data+JSValueTests.swift
@@ -0,0 +1,55 @@
+import XCTest
+import Foundation
+import JavaScriptFoundationCompat
+import JavaScriptKit
+
+final class DataJSValueTests: XCTestCase {
+    func testDataToJSValue() {
+        let data = Data([0x00, 0x01, 0x02, 0x03])
+        let jsValue = data.jsValue
+
+        let uint8Array = JSTypedArray<UInt8>(from: jsValue)
+        XCTAssertEqual(uint8Array?.lengthInBytes, 4)
+        XCTAssertEqual(uint8Array?[0], 0x00)
+        XCTAssertEqual(uint8Array?[1], 0x01)
+        XCTAssertEqual(uint8Array?[2], 0x02)
+        XCTAssertEqual(uint8Array?[3], 0x03)
+    }
+
+    func testJSValueToData() {
+        let jsValue = JSTypedArray<UInt8>([0x00, 0x01, 0x02, 0x03]).jsValue
+        let data = Data.construct(from: jsValue)
+        XCTAssertEqual(data, Data([0x00, 0x01, 0x02, 0x03]))
+    }
+
+    func testDataToJSValue_withLargeData() {
+        let data = Data(repeating: 0x00, count: 1024 * 1024)
+        let jsValue = data.jsValue
+        let uint8Array = JSTypedArray<UInt8>(from: jsValue)
+        XCTAssertEqual(uint8Array?.lengthInBytes, 1024 * 1024)
+    }
+
+    func testJSValueToData_withLargeData() {
+        let jsValue = JSTypedArray<UInt8>(Array(repeating: 0x00, count: 1024 * 1024)).jsValue
+        let data = Data.construct(from: jsValue)
+        XCTAssertEqual(data?.count, 1024 * 1024)
+    }
+
+    func testDataToJSValue_withEmptyData() {
+        let data = Data()
+        let jsValue = data.jsValue
+        let uint8Array = JSTypedArray<UInt8>(from: jsValue)
+        XCTAssertEqual(uint8Array?.lengthInBytes, 0)
+    }
+
+    func testJSValueToData_withEmptyData() {
+        let jsValue = JSTypedArray<UInt8>([]).jsValue
+        let data = Data.construct(from: jsValue)
+        XCTAssertEqual(data, Data())
+    }
+
+    func testJSValueToData_withInvalidJSValue() {
+        let data = Data.construct(from: JSObject().jsValue)
+        XCTAssertNil(data)
+    }
+}
diff --git a/Tests/JavaScriptKitTests/JSClosureTests.swift b/Tests/JavaScriptKitTests/JSClosureTests.swift
new file mode 100644
index 000000000..2dd6c6056
--- /dev/null
+++ b/Tests/JavaScriptKitTests/JSClosureTests.swift
@@ -0,0 +1,88 @@
+import JavaScriptKit
+import XCTest
+
+class JSClosureTests: XCTestCase {
+    func testClosureLifetime() {
+        let evalClosure = JSObject.global.globalObject1.eval_closure.function!
+
+        do {
+            let c1 = JSClosure { arguments in
+                return arguments[0]
+            }
+            XCTAssertEqual(evalClosure(c1, JSValue.number(1.0)), .number(1.0))
+            #if JAVASCRIPTKIT_WITHOUT_WEAKREFS
+            c1.release()
+            #endif
+        }
+
+        do {
+            let array = JSObject.global.Array.function!.new()
+            let c1 = JSClosure { _ in .number(3) }
+            _ = array.push!(c1)
+            XCTAssertEqual(array[0].function!().number, 3.0)
+            #if JAVASCRIPTKIT_WITHOUT_WEAKREFS
+            c1.release()
+            #endif
+        }
+
+        do {
+            let c1 = JSClosure { _ in .undefined }
+            XCTAssertEqual(c1(), .undefined)
+        }
+
+        do {
+            let c1 = JSClosure { _ in .number(4) }
+            XCTAssertEqual(c1(), .number(4))
+        }
+    }
+
+    func testHostFunctionRegistration() {
+        // ```js
+        // global.globalObject1 = {
+        //   ...
+        //   "prop_6": {
+        //     "call_host_1": function() {
+        //       return global.globalObject1.prop_6.host_func_1()
+        //     }
+        //   }
+        // }
+        // ```
+        let globalObject1 = getJSValue(this: .global, name: "globalObject1")
+        let globalObject1Ref = try! XCTUnwrap(globalObject1.object)
+        let prop_6 = getJSValue(this: globalObject1Ref, name: "prop_6")
+        let prop_6Ref = try! XCTUnwrap(prop_6.object)
+
+        var isHostFunc1Called = false
+        let hostFunc1 = JSClosure { (_) -> JSValue in
+            isHostFunc1Called = true
+            return .number(1)
+        }
+
+        setJSValue(this: prop_6Ref, name: "host_func_1", value: .object(hostFunc1))
+
+        let call_host_1 = getJSValue(this: prop_6Ref, name: "call_host_1")
+        let call_host_1Func = try! XCTUnwrap(call_host_1.function)
+        XCTAssertEqual(call_host_1Func(), .number(1))
+        XCTAssertEqual(isHostFunc1Called, true)
+
+        #if JAVASCRIPTKIT_WITHOUT_WEAKREFS
+        hostFunc1.release()
+        #endif
+
+        let evalClosure = JSObject.global.globalObject1.eval_closure.function!
+        let hostFunc2 = JSClosure { (arguments) -> JSValue in
+            if let input = arguments[0].number {
+                return .number(input * 2)
+            } else {
+                return .string(String(describing: arguments[0]))
+            }
+        }
+
+        XCTAssertEqual(evalClosure(hostFunc2, 3), .number(6))
+        XCTAssertTrue(evalClosure(hostFunc2, true).string != nil)
+
+        #if JAVASCRIPTKIT_WITHOUT_WEAKREFS
+        hostFunc2.release()
+        #endif
+    }
+}
diff --git a/Tests/JavaScriptKitTests/JSExceptionTests.swift b/Tests/JavaScriptKitTests/JSExceptionTests.swift
new file mode 100644
index 000000000..4afd9ae34
--- /dev/null
+++ b/Tests/JavaScriptKitTests/JSExceptionTests.swift
@@ -0,0 +1,64 @@
+import XCTest
+import JavaScriptKit
+
+class JSExceptionTests: XCTestCase {
+    private func eval(_ code: String) -> JSValue {
+        return JSObject.global.eval!(code)
+    }
+
+    func testThrowingMethodCalls() {
+        let context = eval(
+            """
+            (() => ({
+                func1: () => { throw new Error(); },
+                func2: () => { throw 'String Error'; },
+                func3: () => { throw 3.0; },
+            }))()
+            """
+        ).object!
+
+        // MARK: Throwing method calls
+        XCTAssertThrowsError(try context.throwing.func1!()) { error in
+            XCTAssertTrue(error is JSException)
+            let errorObject = JSError(from: (error as! JSException).thrownValue)
+            XCTAssertNotNil(errorObject)
+        }
+
+        XCTAssertThrowsError(try context.throwing.func2!()) { error in
+            XCTAssertTrue(error is JSException)
+            let thrownValue = (error as! JSException).thrownValue
+            XCTAssertEqual(thrownValue.string, "String Error")
+        }
+
+        XCTAssertThrowsError(try context.throwing.func3!()) { error in
+            XCTAssertTrue(error is JSException)
+            let thrownValue = (error as! JSException).thrownValue
+            XCTAssertEqual(thrownValue.number, 3.0)
+        }
+    }
+
+    func testThrowingUnboundFunctionCalls() {
+        let jsThrowError = eval("() => { throw new Error(); }")
+        XCTAssertThrowsError(try jsThrowError.function!.throws()) { error in
+            XCTAssertTrue(error is JSException)
+            let errorObject = JSError(from: (error as! JSException).thrownValue)
+            XCTAssertNotNil(errorObject)
+        }
+    }
+
+    func testThrowingConstructorCalls() {
+        let Animal = JSObject.global.Animal.function!
+        XCTAssertNoThrow(try Animal.throws.new("Tama", 3, true))
+        XCTAssertThrowsError(try Animal.throws.new("Tama", -3, true)) { error in
+            XCTAssertTrue(error is JSException)
+            let errorObject = JSError(from: (error as! JSException).thrownValue)
+            XCTAssertNotNil(errorObject)
+        }
+    }
+
+    func testInitWithMessage() {
+        let message = "THIS IS AN ERROR MESSAGE"
+        let exception = JSException(message: message)
+        XCTAssertTrue(exception.description.contains(message))
+    }
+}
diff --git a/Tests/JavaScriptKitTests/JavaScriptKitTests.swift b/Tests/JavaScriptKitTests/JavaScriptKitTests.swift
index 246df522a..ffab816ab 100644
--- a/Tests/JavaScriptKitTests/JavaScriptKitTests.swift
+++ b/Tests/JavaScriptKitTests/JavaScriptKitTests.swift
@@ -197,90 +197,6 @@ class JavaScriptKitTests: XCTestCase {
         XCTAssertEqual(func6(true, "OK", 2), .string("OK"))
     }
 
-    func testClosureLifetime() {
-        let evalClosure = JSObject.global.globalObject1.eval_closure.function!
-
-        do {
-            let c1 = JSClosure { arguments in
-                return arguments[0]
-            }
-            XCTAssertEqual(evalClosure(c1, JSValue.number(1.0)), .number(1.0))
-            #if JAVASCRIPTKIT_WITHOUT_WEAKREFS
-            c1.release()
-            #endif
-        }
-
-        do {
-            let array = JSObject.global.Array.function!.new()
-            let c1 = JSClosure { _ in .number(3) }
-            _ = array.push!(c1)
-            XCTAssertEqual(array[0].function!().number, 3.0)
-            #if JAVASCRIPTKIT_WITHOUT_WEAKREFS
-            c1.release()
-            #endif
-        }
-
-        do {
-            let c1 = JSClosure { _ in .undefined }
-            XCTAssertEqual(c1(), .undefined)
-        }
-
-        do {
-            let c1 = JSClosure { _ in .number(4) }
-            XCTAssertEqual(c1(), .number(4))
-        }
-    }
-
-    func testHostFunctionRegistration() {
-        // ```js
-        // global.globalObject1 = {
-        //   ...
-        //   "prop_6": {
-        //     "call_host_1": function() {
-        //       return global.globalObject1.prop_6.host_func_1()
-        //     }
-        //   }
-        // }
-        // ```
-        let globalObject1 = getJSValue(this: .global, name: "globalObject1")
-        let globalObject1Ref = try! XCTUnwrap(globalObject1.object)
-        let prop_6 = getJSValue(this: globalObject1Ref, name: "prop_6")
-        let prop_6Ref = try! XCTUnwrap(prop_6.object)
-
-        var isHostFunc1Called = false
-        let hostFunc1 = JSClosure { (_) -> JSValue in
-            isHostFunc1Called = true
-            return .number(1)
-        }
-
-        setJSValue(this: prop_6Ref, name: "host_func_1", value: .object(hostFunc1))
-
-        let call_host_1 = getJSValue(this: prop_6Ref, name: "call_host_1")
-        let call_host_1Func = try! XCTUnwrap(call_host_1.function)
-        XCTAssertEqual(call_host_1Func(), .number(1))
-        XCTAssertEqual(isHostFunc1Called, true)
-
-        #if JAVASCRIPTKIT_WITHOUT_WEAKREFS
-        hostFunc1.release()
-        #endif
-
-        let evalClosure = JSObject.global.globalObject1.eval_closure.function!
-        let hostFunc2 = JSClosure { (arguments) -> JSValue in
-            if let input = arguments[0].number {
-                return .number(input * 2)
-            } else {
-                return .string(String(describing: arguments[0]))
-            }
-        }
-
-        XCTAssertEqual(evalClosure(hostFunc2, 3), .number(6))
-        XCTAssertTrue(evalClosure(hostFunc2, true).string != nil)
-
-        #if JAVASCRIPTKIT_WITHOUT_WEAKREFS
-        hostFunc2.release()
-        #endif
-    }
-
     func testNewObjectConstruction() {
         // ```js
         // global.Animal = function(name, age, isCat) {
@@ -507,64 +423,6 @@ class JavaScriptKitTests: XCTestCase {
         globalObject1.prop_1.nested_prop = originalProp1
     }
 
-    func testException() {
-        // ```js
-        // global.globalObject1 = {
-        //   ...
-        //   prop_9: {
-        //       func1: function () {
-        //           throw new Error();
-        //       },
-        //       func2: function () {
-        //           throw "String Error";
-        //       },
-        //       func3: function () {
-        //           throw 3.0
-        //       },
-        //   },
-        //   ...
-        // }
-        // ```
-        //
-        let globalObject1 = JSObject.global.globalObject1
-        let prop_9: JSValue = globalObject1.prop_9
-
-        // MARK: Throwing method calls
-        XCTAssertThrowsError(try prop_9.object!.throwing.func1!()) { error in
-            XCTAssertTrue(error is JSException)
-            let errorObject = JSError(from: (error as! JSException).thrownValue)
-            XCTAssertNotNil(errorObject)
-        }
-
-        XCTAssertThrowsError(try prop_9.object!.throwing.func2!()) { error in
-            XCTAssertTrue(error is JSException)
-            let thrownValue = (error as! JSException).thrownValue
-            XCTAssertEqual(thrownValue.string, "String Error")
-        }
-
-        XCTAssertThrowsError(try prop_9.object!.throwing.func3!()) { error in
-            XCTAssertTrue(error is JSException)
-            let thrownValue = (error as! JSException).thrownValue
-            XCTAssertEqual(thrownValue.number, 3.0)
-        }
-
-        // MARK: Simple function calls
-        XCTAssertThrowsError(try prop_9.func1.function!.throws()) { error in
-            XCTAssertTrue(error is JSException)
-            let errorObject = JSError(from: (error as! JSException).thrownValue)
-            XCTAssertNotNil(errorObject)
-        }
-
-        // MARK: Throwing constructor call
-        let Animal = JSObject.global.Animal.function!
-        XCTAssertNoThrow(try Animal.throws.new("Tama", 3, true))
-        XCTAssertThrowsError(try Animal.throws.new("Tama", -3, true)) { error in
-            XCTAssertTrue(error is JSException)
-            let errorObject = JSError(from: (error as! JSException).thrownValue)
-            XCTAssertNotNil(errorObject)
-        }
-    }
-
     func testSymbols() {
         let symbol1 = JSSymbol("abc")
         let symbol2 = JSSymbol("abc")
diff --git a/Tests/prelude.mjs b/Tests/prelude.mjs
index 1e12d3755..c6ac428a0 100644
--- a/Tests/prelude.mjs
+++ b/Tests/prelude.mjs
@@ -1,27 +1,85 @@
-/** @type {import('./../.build/plugins/PackageToJS/outputs/PackageTests/test.d.ts').Prelude["setupOptions"]} */
-export function setupOptions(options, context) {
+// @ts-check
+
+/** @type {import('../.build/plugins/PackageToJS/outputs/PackageTests/test.d.ts').SetupOptionsFn} */
+export async function setupOptions(options, context) {
     Error.stackTraceLimit = 100;
     setupTestGlobals(globalThis);
     return {
         ...options,
-        addToCoreImports(importObject, getInstance, getExports) {
-            options.addToCoreImports?.(importObject);
+        imports: {
+            "jsRoundTripVoid": () => {
+                return;
+            },
+            "jsRoundTripNumber": (v) => {
+                return v;
+            },
+            "jsRoundTripBool": (v) => {
+                return v;
+            },
+            "jsRoundTripString": (v) => {
+                return v;
+            },
+            "jsThrowOrVoid": (shouldThrow) => {
+                if (shouldThrow) {
+                    throw new Error("TestError");
+                }
+            },
+            "jsThrowOrNumber": (shouldThrow) => {
+                if (shouldThrow) {
+                    throw new Error("TestError");
+                }
+                return 1;
+            },
+            "jsThrowOrBool": (shouldThrow) => {
+                if (shouldThrow) {
+                    throw new Error("TestError");
+                }
+                return true;
+            },
+            "jsThrowOrString": (shouldThrow) => {
+                if (shouldThrow) {
+                    throw new Error("TestError");
+                }
+                return "Hello, world!";
+            },
+            JsGreeter: class {
+                /**
+                 * @param {string} name
+                 * @param {string} prefix
+                 */
+                constructor(name, prefix) {
+                    this.name = name;
+                    this.prefix = prefix;
+                }
+                greet() {
+                    return `${this.prefix}, ${this.name}!`;
+                }
+                /** @param {string} name */
+                changeName(name) {
+                    this.name = name;
+                }
+            }
+        },
+        addToCoreImports(importObject, importsContext) {
+            const { getInstance, getExports } = importsContext;
+            options.addToCoreImports?.(importObject, importsContext);
             importObject["JavaScriptEventLoopTestSupportTests"] = {
                 "isMainThread": () => context.isMainThread,
             }
-            importObject["BridgeJSRuntimeTests"] = {
-                "runJsWorks": () => {
-                    return BridgeJSRuntimeTests_runJsWorks(getInstance(), getExports());
-                },
+            const bridgeJSRuntimeTests = importObject["BridgeJSRuntimeTests"] || {};
+            bridgeJSRuntimeTests["runJsWorks"] = () => {
+                return BridgeJSRuntimeTests_runJsWorks(getInstance(), getExports());
             }
+            importObject["BridgeJSRuntimeTests"] = bridgeJSRuntimeTests;
         }
     }
 }
 
 import assert from "node:assert";
 
-/** @param {import('./../.build/plugins/PackageToJS/outputs/PackageTests/bridge.d.ts').Exports} exports */
+/** @param {import('./../.build/plugins/PackageToJS/outputs/PackageTests/bridge-js.d.ts').Exports} exports */
 function BridgeJSRuntimeTests_runJsWorks(instance, exports) {
+    exports.roundTripVoid();
     for (const v of [0, 1, -1, 2147483647, -2147483648]) {
         assert.equal(exports.roundTripInt(v), v);
     }
@@ -67,6 +125,22 @@ function BridgeJSRuntimeTests_runJsWorks(instance, exports) {
     exports.takeGreeter(g, "Jay");
     assert.equal(g.greet(), "Hello, Jay!");
     g.release();
+
+    const anyObject = {};
+    assert.equal(exports.roundTripJSObject(anyObject), anyObject);
+
+    try {
+        exports.throwsSwiftError(true);
+        assert.fail("Expected error");
+    } catch (error) {
+        assert.equal(error.message, "TestError", error);
+    }
+
+    try {
+        exports.throwsSwiftError(false);
+    } catch (error) {
+        assert.fail("Expected no error");
+    }
 }
 
 function setupTestGlobals(global) {
@@ -108,17 +182,6 @@ function setupTestGlobals(global) {
         },
         prop_7: 3.14,
         prop_8: [0, , 2, 3, , , 6],
-        prop_9: {
-            func1: function () {
-                throw new Error();
-            },
-            func2: function () {
-                throw "String Error";
-            },
-            func3: function () {
-                throw 3.0;
-            },
-        },
         eval_closure: function (fn) {
             return fn(arguments[1]);
         },
diff --git a/Utilities/bridge-js-generate.sh b/Utilities/bridge-js-generate.sh
new file mode 100755
index 000000000..b79befa2b
--- /dev/null
+++ b/Utilities/bridge-js-generate.sh
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+env JAVASCRIPTKIT_EXPERIMENTAL_BRIDGEJS=1 swift package plugin --allow-writing-to-package-directory bridge-js
+env JAVASCRIPTKIT_EXPERIMENTAL_BRIDGEJS=1 swift package --package-path ./Benchmarks plugin --allow-writing-to-package-directory bridge-js
+env JAVASCRIPTKIT_EXPERIMENTAL_BRIDGEJS=1 swift package --package-path ./Examples/PlayBridgeJS plugin --allow-writing-to-package-directory bridge-js
+
diff --git a/Utilities/build-examples.sh b/Utilities/build-examples.sh
new file mode 100755
index 000000000..2b51307d3
--- /dev/null
+++ b/Utilities/build-examples.sh
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+for example in Examples/*; do
+    if [ -d "$example" ] && [ -f "$example/build.sh" ]; then
+        echo "Building $example"
+        set -x
+        (cd "$example" && ./build.sh release)
+        { set +x; } 2>/dev/null
+    fi
+done
\ No newline at end of file