Implement custom serialization of errors as host object (#4216)

Author: jasnell

build/deps/v8.bzl

@@ -32,6 +32,7 @@ PATCHES = [
     "0024-Modify-where-to-look-for-dragonbox.patch",
     "0025-Disable-slow-handle-check.patch",
     "0026-Workaround-for-builtin-can-allocate-issue.patch",
+    "0027-Implement-additional-Exception-construction-methods.patch",
 ]
 
 # V8 and its dependencies

patches/v8/0027-Implement-additional-Exception-construction-methods.patch

@@ -0,0 +1,58 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: James M Snell <[email protected]>
+Date: Tue, 1 Jul 2025 17:33:43 -0700
+Subject: Implement additional Exception construction methods
+
+Signed-off-by: James M Snell <[email protected]>
+
+diff --git a/include/v8-exception.h b/include/v8-exception.h
+index 5441a0ab6a403c566e7b0b6002e720c971480893..b9933027aaf9f7842740d6a6742a2c73da65a46a 100644
+--- a/include/v8-exception.h
++++ b/include/v8-exception.h
+@@ -48,6 +48,14 @@ class V8_EXPORT Exception {
+   static Local<Value> WasmSuspendError(Local<String> message,
+                                        Local<Value> options = {});
+   static Local<Value> Error(Local<String> message, Local<Value> options = {});
++  static Local<Value> URIError(Local<String> message,
++                               Local<Value> options = {});
++  static Local<Value> EvalError(Local<String> message,
++                               Local<Value> options = {});
++  static Local<Value> AggregateError(Local<String> message,
++                                     Local<Value> options = {});
++  static Local<Value> SuppressedError(Local<String> message,
++                                      Local<Value> options = {});
+ 
+   /**
+    * Creates an error message for the given exception.
+diff --git a/src/api/api.cc b/src/api/api.cc
+index 99eb9a5dc075a0e7aa38fe31b0576a652bd12cdf..345bfb3fac0e16ad532179dd915c80b454d0cb88 100644
+--- a/src/api/api.cc
++++ b/src/api/api.cc
+@@ -11281,6 +11281,10 @@ DEFINE_ERROR(WasmCompileError, wasm_compile_error)
+ DEFINE_ERROR(WasmLinkError, wasm_link_error)
+ DEFINE_ERROR(WasmRuntimeError, wasm_runtime_error)
+ DEFINE_ERROR(WasmSuspendError, wasm_suspend_error)
++DEFINE_ERROR(EvalError, eval_error)
++DEFINE_ERROR(URIError, uri_error)
++DEFINE_ERROR(AggregateError, aggregate_error)
++DEFINE_ERROR(SuppressedError, suppressed_error)
+ DEFINE_ERROR(Error, error)
+ 
+ #undef DEFINE_ERROR
+diff --git a/src/logging/runtime-call-stats.h b/src/logging/runtime-call-stats.h
+index 9509646458bd4c7b6e4cdfa7a5109a431b8121c1..03c2063841224df6b043a4edeaea9ee1f568b563 100644
+--- a/src/logging/runtime-call-stats.h
++++ b/src/logging/runtime-call-stats.h
+@@ -218,7 +218,11 @@ namespace v8::internal {
+   V(WeakMap_Delete)                                        \
+   V(WeakMap_Get)                                           \
+   V(WeakMap_New)                                           \
+-  V(WeakMap_Set)
++  V(WeakMap_Set)                                           \
++  V(EvalError_New)                                         \
++  V(URIError_New)                                          \
++  V(AggregateError_New)                                    \
++  V(SuppressedError_New)
+ 
+ #define ADD_THREAD_SPECIFIC_COUNTER(V, Prefix, Suffix) \
+   V(Prefix##Suffix)                                    \

src/workerd/io/worker-interface.capnp

@@ -398,6 +398,11 @@ enum SerializationTag {
   # without breaking things).
 
   abortSignal @9;
+
+  nativeError @10;
+  # A JavaScript native error, such as Error, TypeError, etc. These are typically
+  # not handled as host objects in V8 but we handle them as such in workers in
+  # order to preserve additional information that we may attach to them.
 }
 
 enum StreamEncoding {

src/workerd/jsg/jsvalue.c++

@@ -69,6 +69,11 @@ void JsObject::set(Lock& js, kj::StringPtr name, const JsValue& value) {
   set(js, js.strIntern(name), value);
 }
 
+void JsObject::defineProperty(Lock& js, kj::StringPtr name, const JsValue& value) {
+  v8::Local<v8::String> nameStr = js.strIntern(name);
+  check(inner->DefineOwnProperty(js.v8Context(), nameStr, value));
+}
+
 void JsObject::setReadOnly(Lock& js, kj::StringPtr name, const JsValue& value) {
   v8::Local<v8::String> nameStr = js.strIntern(name);
   check(inner->DefineOwnProperty(js.v8Context(), nameStr, value,

src/workerd/jsg/jsvalue.h

@@ -363,6 +363,13 @@ class JsObject final: public JsBase<v8::Object, JsObject> {
   void set(Lock& js, kj::StringPtr name, const JsValue& value);
   void setReadOnly(Lock& js, kj::StringPtr name, const JsValue& value);
   void setNonEnumerable(Lock& js, const JsSymbol& name, const JsValue& value);
+
+  // Like set but uses the defineProperty API instead in order to override
+  // the default property attributes. This is useful for defining properties
+  // that otherwise would not be normally settable, such as the name of an
+  // error object.
+  void defineProperty(Lock& js, kj::StringPtr name, const JsValue& value);
+
   JsValue get(Lock& js, const JsValue& name) KJ_WARN_UNUSED_RESULT;
   JsValue get(Lock& js, kj::StringPtr name) KJ_WARN_UNUSED_RESULT;
 

src/workerd/jsg/ser-test.c++

@@ -150,12 +150,43 @@ struct SerTestContext: public ContextGlobalObject {
     return result;
   }
 
+  JsObject roundTripError(Lock& js, JsObject errorObj) {
+    Serializer ser(js,
+        Serializer::Options{
+          .treatErrorsAsHostObjects = true,
+        });
+    ser.write(js, errorObj);
+    auto content = ser.release();
+    Deserializer deser(js, content);
+    auto val = KJ_ASSERT_NONNULL(deser.readValue(js).tryCast<JsObject>());
+
+    auto names = errorObj.getPropertyNames(js, KeyCollectionFilter::OWN_ONLY,
+        PropertyFilter::ALL_PROPERTIES, IndexFilter::SKIP_INDICES);
+    for (size_t n = 0; n < names.size(); n++) {
+      auto before = errorObj.get(js, names.get(js, n));
+      auto after = val.get(js, names.get(js, n));
+      if (before.isArray()) {
+        auto beforeArray = KJ_ASSERT_NONNULL(before.tryCast<JsArray>());
+        auto afterArray = KJ_ASSERT_NONNULL(after.tryCast<JsArray>());
+        KJ_ASSERT(beforeArray.size() == afterArray.size());
+        for (size_t i = 0; i < beforeArray.size(); i++) {
+          KJ_ASSERT(beforeArray.get(js, i).strictEquals(afterArray.get(js, i)));
+        }
+      } else {
+        KJ_ASSERT(before.strictEquals(after));
+      }
+    }
+
+    return val;
+  }
+
   JSG_RESOURCE_TYPE(SerTestContext) {
     JSG_NESTED_TYPE(Foo);
     JSG_NESTED_TYPE(Bar);
     JSG_NESTED_TYPE(Baz);
     JSG_NESTED_TYPE(Qux);
     JSG_METHOD(roundTrip);
+    JSG_METHOD(roundTripError);
   }
 };
 JSG_DECLARE_ISOLATE_TYPE(SerTestIsolate,
@@ -284,5 +315,46 @@ KJ_TEST("serialization") {
       "number", "321");
 }
 
+KJ_TEST("serialization of errors") {
+  Evaluator<SerTestContext, SerTestIsolate> e(v8System);
+
+  e.expectEval(
+      "e = new Error('a', {cause:'c'}); e.foo = true; roundTripError(e).foo", "boolean", "true");
+  e.expectEval(
+      "roundTripError(new TypeError('a', {cause:'c'})) instanceof TypeError", "boolean", "true");
+  e.expectEval(
+      "roundTripError(new RangeError('a', {cause:'c'})) instanceof RangeError", "boolean", "true");
+  e.expectEval("roundTripError(new ReferenceError('a', {cause:'c'})) instanceof ReferenceError",
+      "boolean", "true");
+  e.expectEval("roundTripError(new SyntaxError('a', {cause:'c'})) instanceof SyntaxError",
+      "boolean", "true");
+  e.expectEval("e = new Error(); Object.defineProperty(e, 'name', {value: 'CustomError'}); "
+               "roundTripError(e).name",
+      "string", "CustomError");
+
+  // Throws due to serializing a cycle. Because we serialize the errors as
+  // host objects, we end up being responsible for ensuring that cycles are
+  // not present in the serialized data. For now, we're just punting on this
+  // to keep things simple, but we end up getting an error when we try to
+  // deserialize. Fortunately this case should always be rare.
+  // TODO(later): Handle cycles in errors as an edge case.
+  e.expectEval(R"(
+    const a = new Error('a');
+    a.cause = a;
+    roundTripError(a);
+  )",
+      "throws", "Error: Unable to deserialize cloned data.");
+
+  e.expectEval(
+      "roundTripError(new URIError('a', {cause:'c'})) instanceof URIError", "boolean", "true");
+  e.expectEval(
+      "roundTripError(new EvalError('a', {cause:'c'})) instanceof EvalError", "boolean", "true");
+  e.expectEval("roundTripError(new AggregateError(['a', 'b'], 'c')) instanceof AggregateError",
+      "boolean", "true");
+  e.expectEval("roundTripError(new SuppressedError('a', 'b', 'c', {cause:'c'})) instanceof "
+               "SuppressedError",
+      "boolean", "true");
+}
+
 }  // namespace
 }  // namespace workerd::jsg::test