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/);