From ab79667509a20d65d53fe73928a4ac88c7484a19 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Thu, 1 Oct 2026 09:38:57 +0200
Subject: [PATCH] ffi: allow native exceptions in target library

We currently do not allow callbacks to throw exceptions
(including the special termination exception used when e.g.
tearing down worker threads), because we have no way of
generically propagating exceptions through the native layer
back to the calling JS code that originally entered the
native code.

However, exceptions may be explicitly or implicitly enabled,
e.g. when the target library is a C++ library, or when the
compiler was configured to emit unwinding information as
part of the code generation process.

Since this change currently makes no attempt to automatically
discover the library's level of exception support (which would
likely be possible, but platform-dependent), it expects users
to actively indicate whether this feature is available in the
called library.

Since this change requires access to native exceptions and
most of Node.js is built without support for it, a small part
of the code is split out into a new GYP target where exceptions
are enabled, and as a part of the Node.js source is also
on the path for passing exceptions through, the compiler
flags for it are changed to include `-funwind-tables`.
The total effect on compiled binary sizes of this patch
is approximately 15 kB, which is negligible compared to the
total size of the binary.
---
 doc/api/ffi.md                                |  48 +++++--
 lib/ffi.js                                    |  12 +-
 node.gyp                                      |  40 ++++++
 src/ffi/cxx_exceptions.cc                     |  31 +++++
 src/ffi/cxx_exceptions.h                      |  41 ++++++
 src/node_ffi.cc                               | 125 ++++++++++++++----
 src/node_ffi.h                                |   6 +-
 ...st-ffi-callback-throw-exception-support.js |  25 ++++
 .../test-ffi-callback-worker-termination.js   |  30 +++--
 9 files changed, 309 insertions(+), 49 deletions(-)
 create mode 100644 src/ffi/cxx_exceptions.cc
 create mode 100644 src/ffi/cxx_exceptions.h
 create mode 100644 test/ffi/test-ffi-callback-throw-exception-support.js

diff --git a/doc/api/ffi.md b/doc/api/ffi.md
index 342acfbec503..0c4a900dbd34 100644
--- a/doc/api/ffi.md
+++ b/doc/api/ffi.md
@@ -206,11 +206,14 @@ const { suffix } = require('node:ffi');
 const path = `libsqlite3.${suffix}`;
 ```
 
-## `ffi.dlopen(path[, definitions])`
+## `ffi.dlopen(path[, definitions[, options]])`
 
 <!-- YAML
 added: v26.1.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/REPLACEME
+    description: Added the `options.supportsExceptions` option.
   - version: v26.10.0
     pr-url: https://github.com/nodejs/node/pull/65909
     description: Library paths inside a mounted virtual file system are now
@@ -220,6 +223,12 @@ changes:
 * `path` {string|null} Path to a dynamic library, or `null` to resolve symbols
   from the current process image.
 * `definitions` {Object} Symbol definitions to resolve immediately.
+* `options` {Object}
+  * `supportsExceptions` {boolean} Allow callbacks registered on the loaded
+    library to throw JavaScript exceptions that propagate to the caller of
+    the native function that invoked them, instead of crashing the process.
+    This requires the library to be built with exception unwinding support.
+    **Default:** `false`.
 * Returns: {Object}
 
 Loads a dynamic library and resolves the requested function definitions.
@@ -312,10 +321,13 @@ added: v26.1.0
 
 Represents a loaded dynamic library.
 
-### `new DynamicLibrary(path)`
+### `new DynamicLibrary(path[, options])`
 
 <!-- YAML
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/REPLACEME
+    description: Added the `options.supportsExceptions` option.
   - version: v26.10.0
     pr-url: https://github.com/nodejs/node/pull/65909
     description: Library paths inside a mounted virtual file system are now
@@ -324,6 +336,12 @@ changes:
 
 * `path` {string|null} Path to a dynamic library, or `null` to resolve symbols
   from the current process image.
+* `options` {Object}
+  * `supportsExceptions` {boolean} Allow callbacks registered on this library
+    to throw JavaScript exceptions that propagate to the caller of the
+    native function that invoked them, instead of crashing the process.
+    This requires the library to be built with exception unwinding support.
+    **Default:** `false`.
 
 Loads the dynamic library without resolving any functions eagerly.
 
@@ -484,7 +502,7 @@ const callback = lib.registerCallback(
 Callbacks are subject to the following restrictions:
 
 * They must be invoked on the same system thread where they were created.
-* They must not throw exceptions.
+* By default, they must not throw exceptions.
 * They must not return promises.
 * They must return a value compatible with the declared return type.
 * They must not call `library.close()` on their owning library while running.
@@ -494,13 +512,26 @@ Closing the owning library or unregistering the currently executing callback
 from inside the callback is unsupported and dangerous. Doing so may crash the
 process, produce incorrect output, or corrupt memory.
 
+Callbacks may throw exceptions if the library has been loaded with
+`supportsExceptions: true` (see [`ffi.dlopen()`][] and [`new DynamicLibrary()`][])
+and every native function on the stack below the callback comes
+from a library that provides stack unwinding support. C++ libraries typically
+fulfill this requirement, but C libraries may need to be built with
+explicit support for this feature (e.g. the `-funwind-tables` flag of some
+compilers).
+
 If the thread running a callback is stopped while the callback executes, for
 example by `worker.terminate()`, by `process.exit()` in a Worker, or by the
 main thread exiting, only that thread stops. The callback returns to native
-code without a value: non-void return values are zero-initialized, so native
-code receives `0`, `false`, or a null pointer. Native code that does not
-handle such a value, for example by dereferencing a returned null pointer, can
-crash the process.
+code without a value:
+* If the library does not support exceptions, non-void return values are
+  zero-initialized, so native code receives `0`, `false`, or a null pointer.
+  Native code that does not handle such a value, for example by dereferencing
+  a returned null pointer, can crash the process.
+* If the library does support exceptions and was instantiated using
+  `supportsExceptions: true`, the termination will be passed down as a C++
+  exception. Execution will still terminate once control is returned back
+  from native code.
 
 ### `library.unregisterCallback(pointer)`
 
@@ -964,12 +995,13 @@ and keep callback and pointer lifetimes explicit on the native side.
 [Fast API call path]: #fast-api-call-path
 [Permission Model]: permissions.md#permission-model
 [`--allow-ffi`]: cli.md#--allow-ffi
-[`ffi.dlopen()`]: #ffidlopenpath-definitions
+[`ffi.dlopen()`]: #ffidlopenpath-definitions-options
 [`ffi.toBuffer(pointer, length, copy)`]: #ffitobufferpointer-length-copy
 [`library.functions`]: #libraryfunctions
 [`library.getFunction()`]: #librarygetfunctionname-signature
 [`library.getFunctions()`]: #librarygetfunctionsdefinitions
 [`library.registerCallback()`]: #libraryregistercallbacksignature-callback
+[`new DynamicLibrary()`]: #new-dynamiclibrarypath-options
 [`using`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/using
 [call paths]: #call-paths
 [generic call path]: #generic-call-path
diff --git a/lib/ffi.js b/lib/ffi.js
index 5cd7c4b354ab..c9413263c294 100644
--- a/lib/ffi.js
+++ b/lib/ffi.js
@@ -16,7 +16,7 @@ const {
   TypedArrayPrototypeGetBuffer,
 } = primordials;
 const { Buffer } = require('buffer');
-const { emitExperimentalWarning } = require('internal/util');
+const { emitExperimentalWarning, kEmptyObject } = require('internal/util');
 const {
   isDataView,
   isArrayBufferView,
@@ -130,17 +130,17 @@ const { getVfsLibraryReader } = require('internal/ffi/vfs');
 // (see internal/ffi/vfs), so no VFS code is ever loaded from here. The
 // wrapper shares the native prototype, so instances and instanceof behave
 // as if the native class were exposed directly.
-function DynamicLibrary(path) {
+function DynamicLibrary(path, options = kEmptyObject) {
   if (new.target === undefined) {
     // Let the native constructor produce its usual error.
-    return FunctionPrototypeCall(NativeDynamicLibrary, this, path);
+    return FunctionPrototypeCall(NativeDynamicLibrary, this, path, undefined, !!options.supportsExceptions);
   }
   const readVirtualLibrary = getVfsLibraryReader();
   const binary =
     readVirtualLibrary === null || typeof path !== 'string' ?
       undefined : readVirtualLibrary(path);
   return ReflectConstruct(NativeDynamicLibrary,
-                          binary === undefined ? [path] : [path, binary],
+                          [path, binary, !!options.supportsExceptions],
                           new.target);
 }
 DynamicLibrary.prototype = NativeDynamicLibrary.prototype;
@@ -234,10 +234,10 @@ function checkFFIPermission() {
     'FFI');
 }
 
-function dlopen(path, definitions) {
+function dlopen(path, definitions, options = kEmptyObject) {
   checkFFIPermission();
 
-  const lib = new DynamicLibrary(path);
+  const lib = new DynamicLibrary(path, options);
   try {
     const functions = definitions === undefined ? ObjectFreeze({ __proto__: null }) : lib.getFunctions(definitions);
     return {
diff --git a/node.gyp b/node.gyp
index c9db6bcf28c2..24e56a9ad294 100644
--- a/node.gyp
+++ b/node.gyp
@@ -853,6 +853,36 @@
          }],
       ],
     }, # node_core_target_name
+    {
+      'target_name': 'node_cxx_exceptions',
+      'type': 'static_library',
+
+      'sources': [
+        'src/ffi/cxx_exceptions.cc',
+        'src/ffi/cxx_exceptions.h',
+      ],
+
+      'include_dirs': [
+        'src',
+      ],
+
+      'defines': [
+        'NODE_WANT_INTERNALS=1',
+      ],
+      'defines!': [
+        '_HAS_EXCEPTIONS=0',
+      ],
+      'cflags_cc!': [ '-fno-exceptions' ],
+      'cflags_cc': [ '-fexceptions' ],
+      'xcode_settings': {
+        'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
+      },
+      'msvs_settings': {
+        'VCCLCompilerTool': {
+          'ExceptionHandling': 1,
+        },
+      },
+    },
     {
       'target_name': 'node_base',
       'type': 'static_library',
@@ -945,6 +975,16 @@
           'sources': [
             '<@(node_ffi_sources)',
           ],
+          'dependencies': [
+            'node_cxx_exceptions',
+          ],
+          # Needed for exceptions to be able to reach
+          # the FFI exception handling code. This does
+          # *not* need to be set for e.g. V8.
+          'cflags': [ '-funwind-tables' ],
+          'xcode_settings': {
+            'OTHER_CFLAGS': [ '-funwind-tables' ],
+          },
           'conditions': [
             [ 'node_shared_ffi=="false"', {
               'dependencies': [
diff --git a/src/ffi/cxx_exceptions.cc b/src/ffi/cxx_exceptions.cc
new file mode 100644
index 000000000000..7385ac3f29c4
--- /dev/null
+++ b/src/ffi/cxx_exceptions.cc
@@ -0,0 +1,31 @@
+#include "ffi/cxx_exceptions.h"
+
+#include <exception>
+
+namespace node::cxx_exceptions {
+
+struct CxxException final : std::exception {
+  CxxExceptionInfo info;
+  CxxException(const CxxExceptionInfo& info) : info(info) {}
+  const char* what() const noexcept override { return info.message.c_str(); }
+};
+
+void CxxExceptionThrow(const CxxExceptionInfo& exception) {
+  throw CxxException(exception);
+}
+
+std::optional<CxxExceptionInfo> CxxExceptionCatch(void (*fn)(void*),
+                                                  void* arg) noexcept {
+  try {
+    fn(arg);
+    return std::nullopt;
+  } catch (const CxxException& e) {
+    return e.info;
+  } catch (const std::exception& e) {
+    return CxxExceptionInfo{.message = e.what()};
+  } catch (...) {
+    return CxxExceptionInfo{.message = "Unknown exception"};
+  }
+}
+
+}  // namespace node::cxx_exceptions
diff --git a/src/ffi/cxx_exceptions.h b/src/ffi/cxx_exceptions.h
new file mode 100644
index 000000000000..efd12ba190ee
--- /dev/null
+++ b/src/ffi/cxx_exceptions.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <memory>
+#include <optional>
+#include <string>
+
+// Using forward declarations to avoid including V8 headers
+// and inlining V8 code by accident.
+namespace v8 {
+template <typename T>
+class Global;
+class Value;
+}  // namespace v8
+
+namespace node::cxx_exceptions {
+
+// `js_exception` is set when the original error is a JS exception that should
+// be rethrown as-is instead of being reported only through `message`.
+struct CxxExceptionInfo {
+  std::string message;
+  std::shared_ptr<v8::Global<v8::Value>> js_exception = {};
+};
+
+// Throws `exception` as a C++ exception; must be caught via CxxExceptionCatch()
+// or catch { ... }.
+void CxxExceptionThrow(const CxxExceptionInfo& exception);
+// Runs fn(arg), catching any C++ exception thrown through it (including ones
+// thrown by CxxExceptionThrow() further down the call stack).
+std::optional<CxxExceptionInfo> CxxExceptionCatch(void (*fn)(void*),
+                                                  void* arg) noexcept;
+template <typename T>
+std::optional<CxxExceptionInfo> CxxExceptionCatch(T fn) noexcept {
+  return CxxExceptionCatch([](void* ptr) { (*static_cast<T*>(ptr))(); },
+                           static_cast<void*>(&fn));
+}
+
+}  // namespace node::cxx_exceptions
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/node_ffi.cc b/src/node_ffi.cc
index 7cd865484fc9..1ef47352bc0f 100644
--- a/src/node_ffi.cc
+++ b/src/node_ffi.cc
@@ -15,6 +15,9 @@
 
 namespace node {
 
+using cxx_exceptions::CxxExceptionCatch;
+using cxx_exceptions::CxxExceptionInfo;
+using cxx_exceptions::CxxExceptionThrow;
 using v8::Array;
 using v8::ArrayBuffer;
 using v8::BigInt;
@@ -43,15 +46,66 @@ using v8::Value;
 
 namespace ffi {
 
-void FFIFunction::Invoke(void* result, void** values) {
-#if defined(NODE_FFI_HAS_FAST_CALL_PLAN)
-  if (call_plan != nullptr) {
-    ffi_call_plan_invoke(call_plan.get(), FFI_FN(ptr), result, values);
+namespace {
+struct CxxExceptionThrowScope {
+  bool enabled;
+  std::optional<CxxExceptionInfo> scheduled_exception;
+
+  explicit CxxExceptionThrowScope(bool enabled) : enabled(enabled) {}
+  ~CxxExceptionThrowScope() {
+    if (scheduled_exception.has_value()) {
+      CHECK(enabled);
+      // Normally, throwing an exception from a destructor is not
+      // acceptable in C++, but here we know for sure that we're not
+      // already in the destructor because of another pending exception
+      // since Node.js is built without support for those.
+      CxxExceptionThrow(scheduled_exception.value());
+    }
+  }
+
+  bool ScheduleExceptionIfAvailable(std::string_view message,
+                                    v8::Global<v8::Value> exception = {}) {
+    CHECK(!scheduled_exception.has_value());
+    if (!enabled) return false;
+    std::shared_ptr<v8::Global<v8::Value>> shared_exception;
+    if (!exception.IsEmpty())
+      shared_exception =
+          std::make_shared<v8::Global<v8::Value>>(std::move(exception));
+    scheduled_exception =
+        CxxExceptionInfo{std::string{message}, shared_exception};
+    return true;
+  }
+  void ScheduleExceptionOrAbort(std::string_view message,
+                                v8::Global<v8::Value> exception = {}) {
+    if (!ScheduleExceptionIfAvailable(message, std::move(exception))) {
+      FPrintF(stderr, "%s\n", message);
+      ABORT();
+    }
+  }
+};
+
+void ThrowExceptionFromInvoke(Environment* env,
+                              const CxxExceptionInfo& exception) {
+  if (exception.js_exception && !exception.js_exception->IsEmpty()) {
+    env->isolate()->ThrowException(exception.js_exception->Get(env->isolate()));
     return;
   }
-#endif
+  THROW_ERR_FFI_CALL_FAILED(env, "FFI call failed: %s", exception.message);
+}
 
-  ffi_call(&cif, FFI_FN(ptr), result, values);
+}  // anonymous namespace
+
+std::optional<CxxExceptionInfo> FFIFunction::Invoke(void* result,
+                                                    void** values) {
+  return CxxExceptionCatch([&]() {
+#if defined(NODE_FFI_HAS_FAST_CALL_PLAN)
+    if (call_plan != nullptr) {
+      ffi_call_plan_invoke(call_plan.get(), FFI_FN(ptr), result, values);
+      return;
+    }
+#endif
+    ffi_call(&cif, FFI_FN(ptr), result, values);
+  });
 }
 
 void FFIFunctionInfo::MemoryInfo(MemoryTracker* tracker) const {
@@ -71,6 +125,10 @@ bool DynamicLibrary::is_closed() const {
   return static_cast<void*>(lib_.handle) == nullptr;
 }
 
+bool DynamicLibrary::supports_exceptions() const {
+  return supports_exceptions_;
+}
+
 void DynamicLibrary::MemoryInfo(MemoryTracker* tracker) const {
   tracker->TrackFieldWithSize("path", path_.capacity() + 1, "std::string");
 
@@ -569,6 +627,7 @@ void DynamicLibrary::New(const FunctionCallbackInfo<Value>& args) {
     THROW_ERR_FFI_CALL_FAILED(env, "dlopen failed: %s", uv_dlerror(&lib->lib_));
     return;
   }
+  lib->supports_exceptions_ = args[2]->IsTrue();
 }
 
 void DynamicLibrary::Close(const FunctionCallbackInfo<Value>& args) {
@@ -643,10 +702,14 @@ void DynamicLibrary::InvokeFunction(const FunctionCallbackInfo<Value>& args) {
     result = Malloc(GetFFIReturnValueStorageSize(fn->return_type));
   }
 
-  fn->Invoke(result, ffi_args.data());
+  auto exception = fn->Invoke(result, ffi_args.data());
 
-  // Return result back to Javascript
-  ToJSReturnValue(env, args, fn->return_type, result);
+  if (exception.has_value()) {
+    ThrowExceptionFromInvoke(env, exception.value());
+  } else {
+    // Return result back to Javascript
+    ToJSReturnValue(env, args, fn->return_type, result);
+  }
   free(result);
 }
 
@@ -702,9 +765,11 @@ void DynamicLibrary::InvokeFunctionSB(const FunctionCallbackInfo<Value>& args) {
   alignas(8) uint8_t result_storage[kSBResultStorageSize] = {0};
   void* result = (fn->return_type != &ffi_type_void) ? result_storage : nullptr;
 
-  fn->Invoke(result, ffi_args.data());
+  auto exception = fn->Invoke(result, ffi_args.data());
 
-  if (result != nullptr) {
+  if (exception.has_value()) {
+    ThrowExceptionFromInvoke(env, exception.value());
+  } else if (result != nullptr) {
     WriteFFIReturnToBuffer(fn->return_type, result, buffer, 0);
   }
 }
@@ -722,11 +787,18 @@ void DynamicLibrary::InvokeCallback(ffi_cif* cif,
                                     void** args,
                                     void* user_data) {
   FFICallback* cb = static_cast<FFICallback*>(user_data);
+  // This needs to be at the top of the function so that we do not
+  // miss out on executing destructors, i.e. we need to make sure
+  // that the destructor of this scope is the last thing that executes
+  // before returning to FFI.
+  CxxExceptionThrowScope exception_scope(cb->owner->supports_exceptions());
 
   // It is unsupported and dangerous for a callback to unregister itself or
   // close its owning library while executing. The current invocation must
   // return before teardown APIs are used.
   if (cb->owner->is_closed() || cb->ptr == nullptr) {
+    exception_scope.ScheduleExceptionIfAvailable(
+        "Callback invoked on closed library or after being unregistered");
     if (ret != nullptr && cb->return_type->size > 0) {
       std::memset(ret, 0, GetFFIReturnValueStorageSize(cb->return_type));
     }
@@ -734,10 +806,10 @@ void DynamicLibrary::InvokeCallback(ffi_cif* cif,
   }
 
   if (std::this_thread::get_id() != cb->thread_id) {
-    FPrintF(stderr,
-            "Callbacks can only be invoked on the system thread they were "
-            "created on\n");
-    ABORT();
+    exception_scope.ScheduleExceptionOrAbort(
+        "Callbacks can only be invoked on the system thread they were "
+        "created on");
+    return;
   }
 
   Environment* env = cb->env;
@@ -772,6 +844,8 @@ void DynamicLibrary::InvokeCallback(ffi_cif* cif,
   // environment teardown) is not an exception thrown by the callback.
   // Return a zeroed result and let the caller unwind.
   if (try_catch.HasTerminated()) {
+    exception_scope.ScheduleExceptionIfAvailable(
+        "Callback execution terminated");
     if (ret != nullptr && cb->return_type->size > 0) {
       std::memset(ret, 0, GetFFIReturnValueStorageSize(cb->return_type));
     }
@@ -780,27 +854,32 @@ void DynamicLibrary::InvokeCallback(ffi_cif* cif,
 
   // Handle exceptions by crashing (can't propagate across FFI boundary)
   if (try_catch.HasCaught()) {
-    FPrintF(stderr, "Callbacks cannot throw an exception\n");
-    ABORT();
+    exception_scope.ScheduleExceptionOrAbort(
+        "Callbacks cannot throw an exception",
+        {isolate, try_catch.Exception()});
+    return;
   }
 
   Local<Value> result_val;
   if (!result.ToLocal(&result_val)) {
     if (try_catch.HasCaught()) {
-      FPrintF(stderr, "Callbacks cannot return an exception\n");
-      ABORT();
+      exception_scope.ScheduleExceptionOrAbort(
+          "Callbacks cannot return an exception",
+          {isolate, try_catch.Exception()});
     }
     return;
   }
 
   if (result_val->IsPromise()) {
-    FPrintF(stderr, "Callbacks cannot return promises\n");
-    ABORT();
+    exception_scope.ScheduleExceptionOrAbort(
+        "Callbacks cannot return promises");
+    return;
   }
 
   if (!ToFFIReturnValue(result_val, cb->return_type, ret)) {
-    FPrintF(stderr, "Callback returned invalid value for declared FFI type\n");
-    ABORT();
+    exception_scope.ScheduleExceptionOrAbort(
+        "Callback returned invalid value for declared FFI type");
+    return;
   }
 }
 
diff --git a/src/node_ffi.h b/src/node_ffi.h
index 7758380138fd..612651037eda 100644
--- a/src/node_ffi.h
+++ b/src/node_ffi.h
@@ -4,6 +4,7 @@
 
 #include "base_object.h"
 #include "ffi.h"
+#include "ffi/cxx_exceptions.h"
 #include "ffi/fast.h"
 #include "uv.h"
 
@@ -48,7 +49,8 @@ struct FFIFunction {
       nullptr, ffi_call_plan_free};
 #endif
 
-  void Invoke(void* result, void** values);
+  [[nodiscard]] std::optional<cxx_exceptions::CxxExceptionInfo> Invoke(
+      void* result, void** values);
 };
 
 class FFIFunctionInfo final : public BaseObject {
@@ -164,8 +166,10 @@ class DynamicLibrary : public BaseObject {
   static void CleanupFunctionInfo(
       const v8::WeakCallbackInfo<FFIFunctionInfo>& data);
   bool is_closed() const;
+  bool supports_exceptions() const;
 
   uv_lib_t lib_ = {};
+  bool supports_exceptions_ = false;
   std::string path_;
   std::unordered_map<std::string, void*> symbols_;
   std::unordered_map<std::string, std::shared_ptr<FFIFunction>> functions_;
diff --git a/test/ffi/test-ffi-callback-throw-exception-support.js b/test/ffi/test-ffi-callback-throw-exception-support.js
new file mode 100644
index 000000000000..67184411cfbd
--- /dev/null
+++ b/test/ffi/test-ffi-callback-throw-exception-support.js
@@ -0,0 +1,25 @@
+'use strict';
+const common = require('../common');
+common.skipIfFFIMissing();
+const assert = require('node:assert');
+const ffi = require('node:ffi');
+const { fixtureSymbols, libraryPath } = require('./ffi-test-common');
+const { lib, functions } = ffi.dlopen(libraryPath, fixtureSymbols, { supportsExceptions: true });
+
+let exception;
+const callback = lib.registerCallback(
+  { arguments: ['i32'], return: 'i32' },
+  function callback() {
+    exception = new Error('test exception');
+    throw exception;
+  },
+);
+function callFFIMethod() {
+  return functions.call_int_callback(callback, 21);
+}
+assert.throws(callFFIMethod, exception);
+const stack = exception.stack.split('\n');
+assert.match(stack[0], /test exception/);
+assert.match(stack[1], /\bcallback\b/);
+assert.match(stack[2], /\bcall_int_callback\b/);
+assert.match(stack[3], /\bcallFFIMethod\b/);
diff --git a/test/ffi/test-ffi-callback-worker-termination.js b/test/ffi/test-ffi-callback-worker-termination.js
index 54500bc604a0..3bd8c83db22b 100644
--- a/test/ffi/test-ffi-callback-worker-termination.js
+++ b/test/ffi/test-ffi-callback-worker-termination.js
@@ -10,13 +10,13 @@ const { libraryPath } = require('./ffi-test-common');
 // That must stop only the Worker instead of aborting the process.
 // The Worker must not load test/common: its 'exit' handler would throw from
 // inside the callback on process.exit(), which is a real exception.
-function runWorker(mode) {
+function runWorker(workerMode, libraryOptions) {
   const workerSource = `
 const { parentPort, workerData } = require('node:worker_threads');
 const ffi = require('node:ffi');
 const { lib, functions } = ffi.dlopen(${JSON.stringify(libraryPath)}, {
   call_int_callback: { arguments: ['pointer', 'i32'], return: 'i32' },
-});
+}, ${JSON.stringify(libraryOptions)});
 const callback = lib.registerCallback(
   { arguments: ['i32'], return: 'i32' },
   () => {
@@ -31,22 +31,30 @@ functions.call_int_callback(callback, 21);
 const { Worker } = require('node:worker_threads');
 const worker = new Worker(${JSON.stringify(workerSource)}, {
   eval: true,
-  workerData: ${JSON.stringify(mode)},
+  workerData: ${JSON.stringify(workerMode)},
 });
 worker.on('message', () => {
-  if (${JSON.stringify(mode)} === 'shutdown') process.exit(0);
+  if (${JSON.stringify(workerMode)} === 'shutdown') process.exit(0);
   worker.terminate();
 });
 worker.on('exit', (code) => console.log('worker exited with code ' + code));`);
 }
 
-for (const [mode, stdout] of [
-  ['shutdown', ''],
-  ['terminate', 'worker exited with code 1\n'],
-  ['exit', 'worker exited with code 0\n'],
-]) {
-  test(`stopping a Worker inside a callback (${mode}) does not abort`, () => {
-    const { status, signal, stdout: actual, stderr } = runWorker(mode);
+function* generateTests() {
+  for (const libraryOptions of [ {}, { supportsExceptions: true } ]) {
+    for (const [workerMode, stdout] of [
+      ['shutdown', ''],
+      ['terminate', 'worker exited with code 1\n'],
+      ['exit', 'worker exited with code 0\n'],
+    ]) {
+      yield [libraryOptions, workerMode, stdout];
+    }
+  }
+}
+
+for (const [libraryOptions, workerMode, stdout] of generateTests()) {
+  test(`stopping a Worker inside a callback (${workerMode}) does not abort`, () => {
+    const { status, signal, stdout: actual, stderr } = runWorker(workerMode, libraryOptions);
     assert.strictEqual(status, 0, `signal: ${signal}\nstderr: ${stderr}`);
     assert.strictEqual(actual, stdout);
     assert.doesNotMatch(stderr, /Callbacks cannot throw an exception/);