structured clone (#3637)

* copy `SerializedScriptValue`

* format

* make `SerializedScriptValue` compile

* add `transfer` option

* tests

* serialize/deserialize blobs

* tests for blobs

* serialize/deserialize file blobs

* more tests

* small cleanup

* format

* small changes + serialize offset

* slice helper

* map and set test

17 files changed, 6411 insertions, 9 deletions

diff --git a/src/bun.js/bindings/ProcessIdentifier.cpp b/src/bun.js/bindings/ProcessIdentifier.cpp
new file mode 100644
index 000000000..5e82f4fe9
--- /dev/null
+++ b/src/bun.js/bindings/ProcessIdentifier.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2017 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "ProcessIdentifier.h"
+
+#include <wtf/MainThread.h>
+
+namespace WebCore {
+namespace ProcessIdent {
+
+static std::optional<ProcessIdentifier> globalIdentifier;
+
+void setIdentifier(ProcessIdentifier processIdentifier)
+{
+    ASSERT(isUIThread());
+    globalIdentifier = processIdentifier;
+}
+
+ProcessIdentifier identifier()
+{
+    static std::once_flag onceFlag;
+    std::call_once(onceFlag, [] {
+        if (!globalIdentifier)
+            globalIdentifier = ProcessIdentifier::generate();
+    });
+
+    return *globalIdentifier;
+}
+
+} // namespace ProcessIdent
+} // namespace WebCore
diff --git a/src/bun.js/bindings/ProcessIdentifier.h b/src/bun.js/bindings/ProcessIdentifier.h
new file mode 100644
index 000000000..e6141bdc0
--- /dev/null
+++ b/src/bun.js/bindings/ProcessIdentifier.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2017 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <wtf/ObjectIdentifier.h>
+
+namespace WebCore {
+
+enum ProcessIdentifierType {};
+using ProcessIdentifier = ObjectIdentifier<ProcessIdentifierType>;
+
+namespace ProcessIdent {
+
+WEBCORE_EXPORT void setIdentifier(ProcessIdentifier);
+WEBCORE_EXPORT ProcessIdentifier identifier();
+
+} // namespace ProcessIdent
+} // namespace WebCore
diff --git a/src/bun.js/bindings/ScriptExecutionContext.cpp b/src/bun.js/bindings/ScriptExecutionContext.cpp
index 3262bdb5d..0293ecc35 100644
--- a/src/bun.js/bindings/ScriptExecutionContext.cpp
+++ b/src/bun.js/bindings/ScriptExecutionContext.cpp
@@ -137,4 +137,11 @@ void ScriptExecutionContext::removeFromContextsMap()
     // allScriptExecutionContextsMap().remove(m_identifier);
 }
 
+ScriptExecutionContext* executionContext(JSC::JSGlobalObject* globalObject)
+{
+    if (!globalObject || !globalObject->inherits<JSDOMGlobalObject>())
+        return nullptr;
+    return JSC::jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext();
+}
+
 }
diff --git a/src/bun.js/bindings/ScriptExecutionContext.h b/src/bun.js/bindings/ScriptExecutionContext.h
index aed7977a5..fcf65f477 100644
--- a/src/bun.js/bindings/ScriptExecutionContext.h
+++ b/src/bun.js/bindings/ScriptExecutionContext.h
@@ -115,6 +115,18 @@ public:
     // {
     // }
 
+#if ENABLE(WEB_CRYPTO)
+    // These two methods are used when CryptoKeys are serialized into IndexedDB. As a side effect, it is also
+    // used for things that utilize the same structure clone algorithm, for example, message passing between
+    // worker and document.
+
+    // For now these will return false. In the future, we will want to implement these similar to how WorkerGlobalScope.cpp does.
+    // virtual bool wrapCryptoKey(const Vector<uint8_t>& key, Vector<uint8_t>& wrappedKey) = 0;
+    // virtual bool unwrapCryptoKey(const Vector<uint8_t>& wrappedKey, Vector<uint8_t>& key) = 0;
+    bool wrapCryptoKey(const Vector<uint8_t>& key, Vector<uint8_t>& wrappedKey) { return false; }
+    bool unwrapCryptoKey(const Vector<uint8_t>& wrappedKey, Vector<uint8_t>& key) { return false; }
+#endif
+
     static bool postTaskTo(ScriptExecutionContextIdentifier identifier, Function<void(ScriptExecutionContext&)>&& task);
 
     void regenerateIdentifier();
@@ -194,4 +206,7 @@ public:
         }
     }
 };
+
+ScriptExecutionContext* executionContext(JSC::JSGlobalObject*);
+
 }
\ No newline at end of file
diff --git a/src/bun.js/bindings/ZigGeneratedClasses.cpp b/src/bun.js/bindings/ZigGeneratedClasses.cpp
index ce82dc1f1..c11766926 100644
--- a/src/bun.js/bindings/ZigGeneratedClasses.cpp
+++ b/src/bun.js/bindings/ZigGeneratedClasses.cpp
@@ -98,6 +98,11 @@ private:
 
 extern "C" void* BlobClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsBlobConstructor);
+
+extern "C" void Blob__onStructuredCloneSerialize(void*, JSC::JSGlobalObject*, void*, void (*)(CloneSerializer*, const uint8_t*, uint32_t));
+
+extern "C" JSC::EncodedJSValue Blob__onStructuredCloneDeserialize(JSC::JSGlobalObject*, const uint8_t*, const uint8_t*);
+
 extern "C" void BlobClass__finalize(void*);
 
 extern "C" EncodedJSValue BlobPrototype__getArrayBuffer(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
@@ -1250,6 +1255,7 @@ private:
 
 extern "C" void* BuildMessageClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsBuildMessageConstructor);
+
 extern "C" void BuildMessageClass__finalize(void*);
 
 extern "C" EncodedJSValue BuildMessagePrototype__toPrimitive(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
@@ -1727,6 +1733,7 @@ private:
 
 extern "C" void* CryptoHasherClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsCryptoHasherConstructor);
+
 extern "C" void CryptoHasherClass__finalize(void*);
 
 extern "C" JSC::EncodedJSValue CryptoHasherPrototype__getAlgorithm(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
@@ -2155,6 +2162,7 @@ private:
 
 extern "C" void* DirentClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsDirentConstructor);
+
 extern "C" void DirentClass__finalize(void*);
 
 extern "C" EncodedJSValue DirentPrototype__isBlockDevice(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
@@ -2681,6 +2689,7 @@ private:
 
 extern "C" void* ExpectClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsExpectConstructor);
+
 extern "C" void ExpectClass__finalize(void*);
 extern "C" JSC_DECLARE_HOST_FUNCTION(ExpectClass__call);
 
@@ -5783,6 +5792,7 @@ private:
 
 extern "C" void* FileSystemRouterClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsFileSystemRouterConstructor);
+
 extern "C" void FileSystemRouterClass__finalize(void*);
 
 extern "C" EncodedJSValue FileSystemRouterPrototype__match(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
@@ -6191,6 +6201,7 @@ private:
 
 extern "C" void* ListenerClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsListenerConstructor);
+
 extern "C" void ListenerClass__finalize(void*);
 
 extern "C" JSC::EncodedJSValue ListenerPrototype__getData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
@@ -6640,6 +6651,7 @@ private:
 
 extern "C" void* MD4Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsMD4Constructor);
+
 extern "C" void MD4Class__finalize(void*);
 
 extern "C" JSC::EncodedJSValue MD4Prototype__getByteLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
@@ -6967,6 +6979,7 @@ private:
 
 extern "C" void* MD5Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsMD5Constructor);
+
 extern "C" void MD5Class__finalize(void*);
 
 extern "C" JSC::EncodedJSValue MD5Prototype__getByteLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
@@ -7257,6 +7270,7 @@ private:
 
 extern "C" void* MatchedRouteClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsMatchedRouteConstructor);
+
 extern "C" void MatchedRouteClass__finalize(void*);
 
 extern "C" JSC::EncodedJSValue MatchedRoutePrototype__getFilePath(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
@@ -7756,6 +7770,7 @@ private:
 
 extern "C" void* NodeJSFSClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsNodeJSFSConstructor);
+
 extern "C" void NodeJSFSClass__finalize(void*);
 
 extern "C" EncodedJSValue NodeJSFSPrototype__access(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
@@ -10537,6 +10552,7 @@ private:
 
 extern "C" void* RequestClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsRequestConstructor);
+
 extern "C" void RequestClass__finalize(void*);
 
 extern "C" EncodedJSValue RequestPrototype__getArrayBuffer(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
@@ -11309,6 +11325,7 @@ private:
 
 extern "C" void* ResolveMessageClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsResolveMessageConstructor);
+
 extern "C" void ResolveMessageClass__finalize(void*);
 
 extern "C" EncodedJSValue ResolveMessagePrototype__toPrimitive(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
@@ -11898,6 +11915,7 @@ private:
 
 extern "C" void* ResponseClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsResponseConstructor);
+
 extern "C" void ResponseClass__finalize(void*);
 
 extern "C" EncodedJSValue ResponsePrototype__getArrayBuffer(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
@@ -12599,6 +12617,7 @@ private:
 
 extern "C" void* SHA1Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsSHA1Constructor);
+
 extern "C" void SHA1Class__finalize(void*);
 
 extern "C" JSC::EncodedJSValue SHA1Prototype__getByteLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
@@ -12926,6 +12945,7 @@ private:
 
 extern "C" void* SHA224Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsSHA224Constructor);
+
 extern "C" void SHA224Class__finalize(void*);
 
 extern "C" JSC::EncodedJSValue SHA224Prototype__getByteLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
@@ -13253,6 +13273,7 @@ private:
 
 extern "C" void* SHA256Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsSHA256Constructor);
+
 extern "C" void SHA256Class__finalize(void*);
 
 extern "C" JSC::EncodedJSValue SHA256Prototype__getByteLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
@@ -13580,6 +13601,7 @@ private:
 
 extern "C" void* SHA384Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsSHA384Constructor);
+
 extern "C" void SHA384Class__finalize(void*);
 
 extern "C" JSC::EncodedJSValue SHA384Prototype__getByteLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
@@ -13907,6 +13929,7 @@ private:
 
 extern "C" void* SHA512Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsSHA512Constructor);
+
 extern "C" void SHA512Class__finalize(void*);
 
 extern "C" JSC::EncodedJSValue SHA512Prototype__getByteLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
@@ -14234,6 +14257,7 @@ private:
 
 extern "C" void* SHA512_256Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsSHA512_256Constructor);
+
 extern "C" void SHA512_256Class__finalize(void*);
 
 extern "C" JSC::EncodedJSValue SHA512_256Prototype__getByteLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
@@ -14561,6 +14585,7 @@ private:
 
 extern "C" void* ServerWebSocketClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsServerWebSocketConstructor);
+
 extern "C" void ServerWebSocketClass__finalize(void*);
 
 extern "C" JSC::EncodedJSValue ServerWebSocketPrototype__getBinaryType(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
@@ -15504,6 +15529,7 @@ private:
 
 extern "C" void* StatsClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsStatsConstructor);
+
 extern "C" void StatsClass__finalize(void*);
 
 extern "C" JSC::EncodedJSValue StatsPrototype__atime(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
@@ -16433,6 +16459,7 @@ private:
 
 extern "C" void* SubprocessClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsSubprocessConstructor);
+
 extern "C" void SubprocessClass__finalize(void*);
 
 extern "C" JSC::EncodedJSValue SubprocessPrototype__getExitCode(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
@@ -16963,6 +16990,7 @@ private:
 
 extern "C" void* TCPSocketClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsTCPSocketConstructor);
+
 extern "C" void TCPSocketClass__finalize(void*);
 
 extern "C" JSC::EncodedJSValue TCPSocketPrototype__getALPNProtocol(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
@@ -17648,6 +17676,7 @@ private:
 
 extern "C" void* TLSSocketClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsTLSSocketConstructor);
+
 extern "C" void TLSSocketClass__finalize(void*);
 
 extern "C" JSC::EncodedJSValue TLSSocketPrototype__getALPNProtocol(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
@@ -18370,6 +18399,7 @@ private:
 
 extern "C" void* TextDecoderClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsTextDecoderConstructor);
+
 extern "C" void TextDecoderClass__finalize(void*);
 
 extern "C" EncodedJSValue TextDecoderPrototype__decode(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
@@ -19081,6 +19111,7 @@ private:
 
 extern "C" void* TranspilerClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsTranspilerConstructor);
+
 extern "C" void TranspilerClass__finalize(void*);
 
 extern "C" EncodedJSValue TranspilerPrototype__scan(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
@@ -19376,5 +19407,20 @@ extern "C" EncodedJSValue Transpiler__create(Zig::GlobalObject* globalObject, vo
 
     return JSValue::encode(instance);
 }
+std::optional<StructuredCloneableSerialize> StructuredCloneableSerialize::fromJS(JSC::JSValue value)
+{
+    if (auto* result = jsDynamicCast<JSBlob*>(value)) {
+        return StructuredCloneableSerialize { .cppWriteBytes = SerializedScriptValue::writeBytesForBun, .zigFunction = Blob__onStructuredCloneSerialize, .tag = 254, .impl = result->wrapped() };
+    }
+    return std::nullopt;
+}
+
+std::optional<JSC::EncodedJSValue> StructuredCloneableDeserialize::fromTagDeserialize(uint8_t tag, JSC::JSGlobalObject* globalObject, const uint8_t* ptr, const uint8_t* end)
+{
+    if (tag == 254) {
+        return Blob__onStructuredCloneDeserialize(globalObject, ptr, end);
+    }
+    return std::nullopt;
+}
 
 } // namespace WebCore
diff --git a/src/bun.js/bindings/ZigGeneratedClasses.h b/src/bun.js/bindings/ZigGeneratedClasses.h
index 1631f960e..f66c65e40 100644
--- a/src/bun.js/bindings/ZigGeneratedClasses.h
+++ b/src/bun.js/bindings/ZigGeneratedClasses.h
@@ -10,6 +10,7 @@ namespace Zig {
 
 #include "JSDOMWrapper.h"
 #include <wtf/NeverDestroyed.h>
+#include "SerializedScriptValue.h"
 
 namespace WebCore {
 using namespace Zig;
@@ -1998,4 +1999,27 @@ public:
     void finishCreation(JSC::VM&);
 };
 
+class StructuredCloneableSerialize {
+public:
+    void (*cppWriteBytes)(CloneSerializer*, const uint8_t*, uint32_t);
+
+    std::function<void(void*, JSC::JSGlobalObject*, void*, void (*)(CloneSerializer*, const uint8_t*, uint32_t))> zigFunction;
+
+    uint8_t tag;
+
+    // the type from zig
+    void* impl;
+
+    static std::optional<StructuredCloneableSerialize> fromJS(JSC::JSValue);
+    void write(CloneSerializer* serializer, JSC::JSGlobalObject* globalObject)
+    {
+        zigFunction(impl, globalObject, serializer, cppWriteBytes);
+    }
+};
+
+class StructuredCloneableDeserialize {
+public:
+    static std::optional<JSC::EncodedJSValue> fromTagDeserialize(uint8_t tag, JSC::JSGlobalObject*, const uint8_t*, const uint8_t*);
+};
+
 }
diff --git a/src/bun.js/bindings/ZigGlobalObject.cpp b/src/bun.js/bindings/ZigGlobalObject.cpp
index 4585b6b84..e6663bfed 100644
--- a/src/bun.js/bindings/ZigGlobalObject.cpp
+++ b/src/bun.js/bindings/ZigGlobalObject.cpp
@@ -106,6 +106,8 @@
 #include "BunJSCModule.h"
 #include "ModuleLoader.h"
 #include "NodeVMScript.h"
+#include "ProcessIdentifier.h"
+#include "SerializedScriptValue.h"
 
 #include "ZigGeneratedClasses.h"
 #include "JavaScriptCore/DateInstance.h"
@@ -660,6 +662,19 @@ extern "C" bool Zig__GlobalObject__resetModuleRegistryMap(JSC__JSGlobalObject* g
 #define PUT_WEBCORE_GENERATED_CONSTRUCTOR(name, ConstructorName) \
     putDirectCustomAccessor(vm, JSC::PropertyName(JSC::Identifier::fromString(vm, name)), JSC::CustomGetterSetter::create(vm, ConstructorName##_getter, ConstructorName##_setter), 0)
 
+String GlobalObject::defaultAgentClusterID()
+{
+    return makeString(ProcessIdent::identifier().toUInt64(), "-default"_s);
+}
+
+String GlobalObject::agentClusterID() const
+{
+    // TODO: workers
+    // if (is<SharedWorkerGlobalScope>(scriptExecutionContext()))
+    //     return makeString(WProcess::identifier().toUInt64(), "-sharedworker");
+    return defaultAgentClusterID();
+}
+
 namespace Zig {
 
 using namespace WebCore;
@@ -1211,6 +1226,50 @@ JSC_DEFINE_HOST_FUNCTION(functionClearTimeout,
     return Bun__Timer__clearTimeout(globalObject, JSC::JSValue::encode(num));
 }
 
+JSC_DEFINE_HOST_FUNCTION(functionStructuredClone,
+    (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    JSC::VM& vm = globalObject->vm();
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+
+    if (callFrame->argumentCount() == 0) {
+        throwTypeError(globalObject, throwScope, "structuredClone requires 1 argument"_s);
+        return JSValue::encode(jsUndefined());
+    }
+
+    JSC::JSValue value = callFrame->argument(0);
+    JSC::JSValue options = callFrame->argument(1);
+
+    Vector<JSC::Strong<JSC::JSObject>> transferList;
+
+    if (options.isObject()) {
+        JSC::JSObject* optionsObject = options.getObject();
+        JSC::JSValue transferListValue = optionsObject->get(globalObject, vm.propertyNames->transfer);
+        if (transferListValue.isObject()) {
+            JSC::JSObject* transferListObject = transferListValue.getObject();
+            if (auto* transferListArray = jsDynamicCast<JSC::JSArray*>(transferListObject)) {
+                for (unsigned i = 0; i < transferListArray->length(); i++) {
+                    JSC::JSValue transferListValue = transferListArray->get(globalObject, i);
+                    if (transferListValue.isObject()) {
+                        JSC::JSObject* transferListObject = transferListValue.getObject();
+                        transferList.append(JSC::Strong<JSC::JSObject>(vm, transferListObject));
+                    }
+                }
+            }
+        }
+    }
+
+    ExceptionOr<Ref<SerializedScriptValue>> serialized = SerializedScriptValue::create(*globalObject, value, WTFMove(transferList));
+    if (serialized.hasException()) {
+        WebCore::propagateException(*globalObject, throwScope, serialized.releaseException());
+        return JSValue::encode(jsUndefined());
+    }
+
+    JSValue deserialized = serialized.releaseReturnValue()->deserialize(*globalObject, globalObject);
+
+    return JSValue::encode(deserialized);
+}
+
 JSC_DEFINE_HOST_FUNCTION(functionBTOA,
     (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
 {
@@ -3652,7 +3711,7 @@ void GlobalObject::addBuiltinGlobals(JSC::VM& vm)
     auto& builtinNames = WebCore::builtinNames(vm);
 
     WTF::Vector<GlobalPropertyInfo> extraStaticGlobals;
-    extraStaticGlobals.reserveCapacity(44);
+    extraStaticGlobals.reserveCapacity(45);
 
     JSC::Identifier queueMicrotaskIdentifier = JSC::Identifier::fromString(vm, "queueMicrotask"_s);
     extraStaticGlobals.uncheckedAppend(
@@ -3676,6 +3735,12 @@ void GlobalObject::addBuiltinGlobals(JSC::VM& vm)
                 "clearImmediate"_s, functionClearTimeout, ImplementationVisibility::Public),
             JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DontDelete | 0 });
 
+    extraStaticGlobals.uncheckedAppend(
+        GlobalPropertyInfo { JSC::Identifier::fromString(vm, "structuredClone"_s),
+            JSC::JSFunction::create(vm, JSC::jsCast<JSC::JSGlobalObject*>(globalObject()), 2,
+                "structuredClone"_s, functionStructuredClone, ImplementationVisibility::Public),
+            JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DontDelete | 0 });
+
     JSC::Identifier setTimeoutIdentifier = JSC::Identifier::fromString(vm, "setTimeout"_s);
     extraStaticGlobals.uncheckedAppend(
         GlobalPropertyInfo { setTimeoutIdentifier,
diff --git a/src/bun.js/bindings/ZigGlobalObject.h b/src/bun.js/bindings/ZigGlobalObject.h
index 0b5c882f5..081ca33b3 100644
--- a/src/bun.js/bindings/ZigGlobalObject.h
+++ b/src/bun.js/bindings/ZigGlobalObject.h
@@ -373,6 +373,9 @@ public:
     JSObject* navigatorObject();
     JSFunction* nativeMicrotaskTrampoline() { return m_nativeMicrotaskTrampoline.getInitializedOnMainThread(this); }
 
+    String agentClusterID() const;
+    static String defaultAgentClusterID();
+
     void trackFFIFunction(JSC::JSFunction* function)
     {
         this->m_ffiFunctions.append(JSC::Strong<JSC::JSFunction> { vm(), function });
diff --git a/src/bun.js/bindings/generated_classes.zig b/src/bun.js/bindings/generated_classes.zig
index 5f83630c5..10aec1865 100644
--- a/src/bun.js/bindings/generated_classes.zig
+++ b/src/bun.js/bindings/generated_classes.zig
@@ -98,6 +98,14 @@ pub const JSBlob = struct {
     extern fn Blob__dangerouslySetPtr(JSC.JSValue, ?*Blob) bool;
 
     comptime {
+        if (@TypeOf(Blob.onStructuredCloneSerialize) != (fn (*Blob, globalThis: *JSC.JSGlobalObject, ctx: *anyopaque, writeBytes: *const fn (*anyopaque, ptr: [*]const u8, len: u32) callconv(.C) void) callconv(.C) void)) {
+            @compileLog("Blob.onStructuredCloneSerialize is not a structured clone serialize function");
+        }
+
+        if (@TypeOf(Blob.onStructuredCloneDeserialize) != (fn (globalThis: *JSC.JSGlobalObject, ptr: [*]u8, end: [*]u8) callconv(.C) JSC.JSValue)) {
+            @compileLog("Blob.onStructuredCloneDeserialize is not a structured clone deserialize function");
+        }
+
         if (@TypeOf(Blob.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*Blob)) {
             @compileLog("Blob.constructor is not a constructor");
         }
@@ -149,6 +157,8 @@ pub const JSBlob = struct {
             @export(Blob.getText, .{ .name = "BlobPrototype__getText" });
             @export(Blob.getType, .{ .name = "BlobPrototype__getType" });
             @export(Blob.getWriter, .{ .name = "BlobPrototype__getWriter" });
+            @export(Blob.onStructuredCloneDeserialize, .{ .name = "Blob__onStructuredCloneDeserialize" });
+            @export(Blob.onStructuredCloneSerialize, .{ .name = "Blob__onStructuredCloneSerialize" });
         }
     }
 };
diff --git a/src/bun.js/bindings/webcore/SerializedScriptValue.cpp b/src/bun.js/bindings/webcore/SerializedScriptValue.cpp
new file mode 100644
index 000000000..e3a741a02
--- /dev/null
+++ b/src/bun.js/bindings/webcore/SerializedScriptValue.cpp
@@ -0,0 +1,5456 @@
+/*
+ * Copyright (C) 2009-2023 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "config.h"
+#include "SerializedScriptValue.h"
+
+// #include "BlobRegistry.h"
+// #include "ByteArrayPixelBuffer.h"
+#include "CryptoKeyAES.h"
+#include "CryptoKeyEC.h"
+#include "CryptoKeyHMAC.h"
+#include "CryptoKeyOKP.h"
+#include "CryptoKeyRSA.h"
+#include "CryptoKeyRSAComponents.h"
+#include "CryptoKeyRaw.h"
+// #include "IDBValue.h"
+// #include "ImageBitmapBacking.h"
+// #include "JSBlob.h"
+#include "JSCryptoKey.h"
+#include "JSDOMBinding.h"
+#include "JSDOMConvertBufferSource.h"
+#include "JSDOMException.h"
+#include "JSDOMGlobalObject.h"
+// #include "JSDOMMatrix.h"
+// #include "JSDOMPoint.h"
+// #include "JSDOMQuad.h"
+// #include "JSDOMRect.h"
+// #include "JSExecState.h"
+// #include "JSFile.h"
+// #include "JSFileList.h"
+// #include "JSIDBSerializationGlobalObject.h"
+// #include "JSImageBitmap.h"
+// #include "JSImageData.h"
+// #include "JSMessagePort.h"
+// #include "JSNavigator.h"
+// #include "JSRTCCertificate.h"
+// #include "JSRTCDataChannel.h"
+// #include "JSWebCodecsEncodedVideoChunk.h"
+// #include "JSWebCodecsVideoFrame.h"
+#include "ScriptExecutionContext.h"
+#include "SharedBuffer.h"
+// #include "WebCodecsEncodedVideoChunk.h"
+#include "WebCoreJSClientData.h"
+#include <JavaScriptCore/APICast.h>
+#include <JavaScriptCore/BigIntObject.h>
+#include <JavaScriptCore/BooleanObject.h>
+#include <JavaScriptCore/CatchScope.h>
+#include <JavaScriptCore/DateInstance.h>
+#include <JavaScriptCore/Error.h>
+#include <JavaScriptCore/Exception.h>
+#include <JavaScriptCore/ExceptionHelpers.h>
+#include <JavaScriptCore/IterationKind.h>
+#include <JavaScriptCore/JSArrayBuffer.h>
+#include <JavaScriptCore/JSArrayBufferView.h>
+#include <JavaScriptCore/JSCInlines.h>
+#include <JavaScriptCore/JSDataView.h>
+#include <JavaScriptCore/JSMapInlines.h>
+#include <JavaScriptCore/JSMapIterator.h>
+#include <JavaScriptCore/JSSetInlines.h>
+#include <JavaScriptCore/JSSetIterator.h>
+#include <JavaScriptCore/JSTypedArrays.h>
+#include <JavaScriptCore/JSWebAssemblyMemory.h>
+#include <JavaScriptCore/JSWebAssemblyModule.h>
+#include <JavaScriptCore/NumberObject.h>
+#include <JavaScriptCore/ObjectConstructor.h>
+#include <JavaScriptCore/PropertyNameArray.h>
+#include <JavaScriptCore/RegExp.h>
+#include <JavaScriptCore/RegExpObject.h>
+#include <JavaScriptCore/TypedArrayInlines.h>
+#include <JavaScriptCore/TypedArrays.h>
+#include <JavaScriptCore/WasmModule.h>
+#include <JavaScriptCore/YarrFlags.h>
+#include <limits>
+#include <wtf/CheckedArithmetic.h>
+#include <wtf/CompletionHandler.h>
+#include <wtf/MainThread.h>
+#include <wtf/RunLoop.h>
+#include <wtf/Vector.h>
+#include <wtf/threads/BinarySemaphore.h>
+
+#include "blob.h"
+#include "ZigGeneratedClasses.h"
+
+#if USE(CG)
+#include <CoreGraphics/CoreGraphics.h>
+#endif
+
+#if PLATFORM(COCOA)
+#include <CoreFoundation/CoreFoundation.h>
+#endif
+
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+#include "JSOffscreenCanvas.h"
+#include "OffscreenCanvas.h"
+#endif
+
+#if CPU(BIG_ENDIAN) || CPU(MIDDLE_ENDIAN) || CPU(NEEDS_ALIGNED_ACCESS)
+#define ASSUME_LITTLE_ENDIAN 0
+#else
+#define ASSUME_LITTLE_ENDIAN 1
+#endif
+
+namespace WebCore {
+
+using namespace JSC;
+
+DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(SerializedScriptValue);
+
+static constexpr unsigned maximumFilterRecursion = 40000;
+static constexpr uint64_t autoLengthMarker = UINT64_MAX;
+
+enum class SerializationReturnCode {
+    SuccessfullyCompleted,
+    StackOverflowError,
+    InterruptedExecutionError,
+    ValidationError,
+    ExistingExceptionError,
+    DataCloneError,
+    UnspecifiedError
+};
+
+enum WalkerState { StateUnknown,
+    ArrayStartState,
+    ArrayStartVisitMember,
+    ArrayEndVisitMember,
+    ObjectStartState,
+    ObjectStartVisitMember,
+    ObjectEndVisitMember,
+    MapDataStartVisitEntry,
+    MapDataEndVisitKey,
+    MapDataEndVisitValue,
+    SetDataStartVisitEntry,
+    SetDataEndVisitKey };
+
+// These can't be reordered, and any new types must be added to the end of the list
+// When making changes to these lists please cover your new type(s) in the API test "IndexedDB.StructuredCloneBackwardCompatibility"
+enum SerializationTag {
+    ArrayTag = 1,
+    ObjectTag = 2,
+    UndefinedTag = 3,
+    NullTag = 4,
+    IntTag = 5,
+    ZeroTag = 6,
+    OneTag = 7,
+    FalseTag = 8,
+    TrueTag = 9,
+    DoubleTag = 10,
+    DateTag = 11,
+    FileTag = 12,
+    FileListTag = 13,
+    ImageDataTag = 14,
+    BlobTag = 15,
+    StringTag = 16,
+    EmptyStringTag = 17,
+    RegExpTag = 18,
+    ObjectReferenceTag = 19,
+    MessagePortReferenceTag = 20,
+    ArrayBufferTag = 21,
+    ArrayBufferViewTag = 22,
+    ArrayBufferTransferTag = 23,
+    TrueObjectTag = 24,
+    FalseObjectTag = 25,
+    StringObjectTag = 26,
+    EmptyStringObjectTag = 27,
+    NumberObjectTag = 28,
+    SetObjectTag = 29,
+    MapObjectTag = 30,
+    NonMapPropertiesTag = 31,
+    NonSetPropertiesTag = 32,
+#if ENABLE(WEB_CRYPTO)
+    CryptoKeyTag = 33,
+#endif
+    SharedArrayBufferTag = 34,
+#if ENABLE(WEBASSEMBLY)
+    WasmModuleTag = 35,
+#endif
+    DOMPointReadOnlyTag = 36,
+    DOMPointTag = 37,
+    DOMRectReadOnlyTag = 38,
+    DOMRectTag = 39,
+    DOMMatrixReadOnlyTag = 40,
+    DOMMatrixTag = 41,
+    DOMQuadTag = 42,
+    ImageBitmapTransferTag = 43,
+#if ENABLE(WEB_RTC)
+    RTCCertificateTag = 44,
+#endif
+    ImageBitmapTag = 45,
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    OffscreenCanvasTransferTag = 46,
+#endif
+    BigIntTag = 47,
+    BigIntObjectTag = 48,
+#if ENABLE(WEBASSEMBLY)
+    WasmMemoryTag = 49,
+#endif
+#if ENABLE(WEB_RTC)
+    RTCDataChannelTransferTag = 50,
+#endif
+    DOMExceptionTag = 51,
+#if ENABLE(WEB_CODECS)
+    WebCodecsEncodedVideoChunkTag = 52,
+    WebCodecsVideoFrameTag = 53,
+#endif
+    ResizableArrayBufferTag = 54,
+
+    Bun__BlobTag = 254,
+    // bun types start at 254 and decrease with each addition
+
+    ErrorTag = 255
+};
+
+enum ArrayBufferViewSubtag {
+    DataViewTag = 0,
+    Int8ArrayTag = 1,
+    Uint8ArrayTag = 2,
+    Uint8ClampedArrayTag = 3,
+    Int16ArrayTag = 4,
+    Uint16ArrayTag = 5,
+    Int32ArrayTag = 6,
+    Uint32ArrayTag = 7,
+    Float32ArrayTag = 8,
+    Float64ArrayTag = 9,
+    BigInt64ArrayTag = 10,
+    BigUint64ArrayTag = 11,
+};
+
+static unsigned typedArrayElementSize(ArrayBufferViewSubtag tag)
+{
+    switch (tag) {
+    case DataViewTag:
+    case Int8ArrayTag:
+    case Uint8ArrayTag:
+    case Uint8ClampedArrayTag:
+        return 1;
+    case Int16ArrayTag:
+    case Uint16ArrayTag:
+        return 2;
+    case Int32ArrayTag:
+    case Uint32ArrayTag:
+    case Float32ArrayTag:
+        return 4;
+    case Float64ArrayTag:
+    case BigInt64ArrayTag:
+    case BigUint64ArrayTag:
+        return 8;
+    default:
+        return 0;
+    }
+}
+
+enum class PredefinedColorSpaceTag : uint8_t {
+    SRGB = 0
+#if ENABLE(PREDEFINED_COLOR_SPACE_DISPLAY_P3)
+    ,
+    DisplayP3 = 1
+#endif
+};
+
+enum DestinationColorSpaceTag {
+    DestinationColorSpaceSRGBTag = 0,
+#if ENABLE(DESTINATION_COLOR_SPACE_LINEAR_SRGB)
+    DestinationColorSpaceLinearSRGBTag = 1,
+#endif
+#if ENABLE(DESTINATION_COLOR_SPACE_DISPLAY_P3)
+    DestinationColorSpaceDisplayP3Tag = 2,
+#endif
+#if PLATFORM(COCOA)
+    DestinationColorSpaceCGColorSpaceNameTag = 3,
+    DestinationColorSpaceCGColorSpacePropertyListTag = 4,
+#endif
+};
+
+#if ENABLE(WEBASSEMBLY)
+static String agentClusterIDFromGlobalObject(JSGlobalObject& globalObject)
+{
+    if (!globalObject.inherits<JSDOMGlobalObject>())
+        return JSDOMGlobalObject::defaultAgentClusterID();
+    return jsCast<JSDOMGlobalObject*>(&globalObject)->agentClusterID();
+}
+#endif
+
+#if ENABLE(WEB_CRYPTO)
+
+const uint32_t currentKeyFormatVersion = 1;
+
+enum class CryptoKeyClassSubtag {
+    HMAC = 0,
+    AES = 1,
+    RSA = 2,
+    EC = 3,
+    Raw = 4,
+    OKP = 5,
+};
+const uint8_t cryptoKeyClassSubtagMaximumValue = 5;
+
+enum class CryptoKeyAsymmetricTypeSubtag {
+    Public = 0,
+    Private = 1
+};
+const uint8_t cryptoKeyAsymmetricTypeSubtagMaximumValue = 1;
+
+enum class CryptoKeyUsageTag {
+    Encrypt = 0,
+    Decrypt = 1,
+    Sign = 2,
+    Verify = 3,
+    DeriveKey = 4,
+    DeriveBits = 5,
+    WrapKey = 6,
+    UnwrapKey = 7
+};
+const uint8_t cryptoKeyUsageTagMaximumValue = 7;
+
+enum class CryptoAlgorithmIdentifierTag {
+    RSAES_PKCS1_v1_5 = 0,
+    RSASSA_PKCS1_v1_5 = 1,
+    RSA_PSS = 2,
+    RSA_OAEP = 3,
+    ECDSA = 4,
+    ECDH = 5,
+    AES_CTR = 6,
+    AES_CBC = 7,
+    AES_GCM = 9,
+    AES_CFB = 10,
+    AES_KW = 11,
+    HMAC = 12,
+    SHA_1 = 14,
+    SHA_224 = 15,
+    SHA_256 = 16,
+    SHA_384 = 17,
+    SHA_512 = 18,
+    HKDF = 20,
+    PBKDF2 = 21,
+    ED25519 = 22,
+};
+
+const uint8_t cryptoAlgorithmIdentifierTagMaximumValue = 22;
+
+static unsigned countUsages(CryptoKeyUsageBitmap usages)
+{
+    // Fast bit count algorithm for sparse bit maps.
+    unsigned count = 0;
+    while (usages) {
+        usages = usages & (usages - 1);
+        ++count;
+    }
+    return count;
+}
+
+enum class CryptoKeyOKPOpNameTag {
+    X25519 = 0,
+    ED25519 = 1,
+};
+const uint8_t cryptoKeyOKPOpNameTagMaximumValue = 1;
+
+#endif
+
+/* CurrentVersion tracks the serialization version so that persistent stores
+ * are able to correctly bail out in the case of encountering newer formats.
+ *
+ * Initial version was 1.
+ * Version 2. added the ObjectReferenceTag and support for serialization of cyclic graphs.
+ * Version 3. added the FalseObjectTag, TrueObjectTag, NumberObjectTag, StringObjectTag
+ * and EmptyStringObjectTag for serialization of Boolean, Number and String objects.
+ * Version 4. added support for serializing non-index properties of arrays.
+ * Version 5. added support for Map and Set types.
+ * Version 6. added support for 8-bit strings.
+ * Version 7. added support for File's lastModified attribute.
+ * Version 8. added support for ImageData's colorSpace attribute.
+ * Version 9. added support for ImageBitmap color space.
+ * Version 10. changed the length (and offsets) of ArrayBuffers (and ArrayBufferViews) from 32 to 64 bits.
+ * Version 11. added support for Blob's memory cost.
+ * Version 12. added support for agent cluster ID.
+ */
+static const unsigned CurrentVersion = 12;
+static const unsigned TerminatorTag = 0xFFFFFFFF;
+static const unsigned StringPoolTag = 0xFFFFFFFE;
+static const unsigned NonIndexPropertiesTag = 0xFFFFFFFD;
+
+// The high bit of a StringData's length determines the character size.
+static const unsigned StringDataIs8BitFlag = 0x80000000;
+
+/*
+ * Object serialization is performed according to the following grammar, all tags
+ * are recorded as a single uint8_t.
+ *
+ * IndexType (used for the object pool and StringData's constant pool) is the
+ * minimum sized unsigned integer type required to represent the maximum index
+ * in the constant pool.
+ *
+ * SerializedValue :- <CurrentVersion:uint32_t> Value
+ * Value :- Array | Object | Map | Set | Terminal
+ *
+ * Array :-
+ *     ArrayTag <length:uint32_t>(<index:uint32_t><value:Value>)* TerminatorTag
+ *
+ * Object :-
+ *     ObjectTag (<name:StringData><value:Value>)* TerminatorTag
+ *
+ * Map :- MapObjectTag MapData
+ *
+ * Set :- SetObjectTag SetData
+ *
+ * MapData :- (<key:Value><value:Value>)* NonMapPropertiesTag (<name:StringData><value:Value>)* TerminatorTag
+ * SetData :- (<key:Value>)* NonSetPropertiesTag (<name:StringData><value:Value>)* TerminatorTag
+ *
+ * Terminal :-
+ *      UndefinedTag
+ *    | NullTag
+ *    | IntTag <value:int32_t>
+ *    | ZeroTag
+ *    | OneTag
+ *    | FalseTag
+ *    | TrueTag
+ *    | FalseObjectTag
+ *    | TrueObjectTag
+ *    | DoubleTag <value:double>
+ *    | NumberObjectTag <value:double>
+ *    | DateTag <value:double>
+ *    | String
+ *    | EmptyStringTag
+ *    | EmptyStringObjectTag
+ *    | BigInt
+ *    | File
+ *    | FileList
+ *    | ImageData
+ *    | Blob
+ *    | ObjectReference
+ *    | MessagePortReferenceTag <value:uint32_t>
+ *    | ArrayBuffer
+ *    | ArrayBufferViewTag ArrayBufferViewSubtag <byteOffset:uint64_t> <byteLength:uint64_t> (ArrayBuffer | ObjectReference)
+ *    | CryptoKeyTag <wrappedKeyLength:uint32_t> <factor:byte{wrappedKeyLength}>
+ *    | DOMPoint
+ *    | DOMRect
+ *    | DOMMatrix
+ *    | DOMQuad
+ *    | ImageBitmapTransferTag <value:uint32_t>
+ *    | RTCCertificateTag
+ *    | ImageBitmapTag <originClean:uint8_t> <logicalWidth:int32_t> <logicalHeight:int32_t> <resolutionScale:double> DestinationColorSpace <byteLength:uint32_t>(<imageByteData:uint8_t>)
+ *    | OffscreenCanvasTransferTag <value:uint32_t>
+ *    | WasmMemoryTag <value:uint32_t>
+ *    | RTCDataChannelTransferTag <identifier:uint32_t>
+ *    | DOMExceptionTag <message:String> <name:String>
+ *    | WebCodecsEncodedVideoChunkTag <identifier:uint32_t>
+ *
+ * Inside certificate, data is serialized in this format as per spec:
+ *
+ * <expires:double> <certificate:StringData> <origin:StringData> <keyingMaterial:StringData>
+ * We also add fingerprints to make sure we expose to JavaScript the same information.
+ *
+ * Inside wrapped crypto key, data is serialized in this format:
+ *
+ * <keyFormatVersion:uint32_t> <extractable:int32_t> <usagesCount:uint32_t> <usages:byte{usagesCount}> CryptoKeyClassSubtag (CryptoKeyHMAC | CryptoKeyAES | CryptoKeyRSA)
+ *
+ * String :-
+ *      EmptyStringTag
+ *      StringTag StringData
+ *
+ * StringObject:
+ *      EmptyStringObjectTag
+ *      StringObjectTag StringData
+ *
+ * StringData :-
+ *      StringPoolTag <cpIndex:IndexType>
+ *      (not (TerminatorTag | StringPoolTag))<is8Bit:uint32_t:1><length:uint32_t:31><characters:CharType{length}> // Added to constant pool when seen, string length 0xFFFFFFFF is disallowed
+ *
+ * BigInt :-
+ *      BigIntTag BigIntData
+ *      BigIntObjectTag BigIntData
+ *
+ * BigIntData :-
+ *      <sign:uint8_t> <lengthInUint64:uint32_t> <contents:uint64_t{lengthInUint64}>
+ *
+ * File :-
+ *    FileTag FileData
+ *
+ * FileData :-
+ *    <path:StringData> <url:StringData> <type:StringData> <name:StringData> <lastModified:double>
+ *
+ * FileList :-
+ *    FileListTag <length:uint32_t>(<file:FileData>){length}
+ *
+ * ImageData :-
+ *    ImageDataTag <width:int32_t> <height:int32_t> <length:uint32_t> <data:uint8_t{length}> <colorSpace:PredefinedColorSpaceTag>
+ *
+ * Blob :-
+ *    BlobTag <url:StringData><type:StringData><size:long long><memoryCost:long long>
+ *
+ * RegExp :-
+ *    RegExpTag <pattern:StringData><flags:StringData>
+ *
+ * ObjectReference :-
+ *    ObjectReferenceTag <opIndex:IndexType>
+ *
+ * ArrayBuffer :-
+ *    ArrayBufferTag <byteLength:uint64_t> <contents:byte{length}>
+ *    ResizableArrayBufferTag <byteLength:uint64_t> <maxLength:uint64_t> <contents:byte{length}>
+ *    ArrayBufferTransferTag <value:uint32_t>
+ *    SharedArrayBufferTag <value:uint32_t>
+ *
+ * CryptoKeyHMAC :-
+ *    <keySize:uint32_t> <keyData:byte{keySize}> CryptoAlgorithmIdentifierTag // Algorithm tag inner hash function.
+ *
+ * CryptoKeyAES :-
+ *    CryptoAlgorithmIdentifierTag <keySize:uint32_t> <keyData:byte{keySize}>
+ *
+ * CryptoKeyRSA :-
+ *    CryptoAlgorithmIdentifierTag <isRestrictedToHash:int32_t> CryptoAlgorithmIdentifierTag? CryptoKeyAsymmetricTypeSubtag CryptoKeyRSAPublicComponents CryptoKeyRSAPrivateComponents?
+ *
+ * CryptoKeyRSAPublicComponents :-
+ *    <modulusSize:uint32_t> <modulus:byte{modulusSize}> <exponentSize:uint32_t> <exponent:byte{exponentSize}>
+ *
+ * CryptoKeyRSAPrivateComponents :-
+ *    <privateExponentSize:uint32_t> <privateExponent:byte{privateExponentSize}> <primeCount:uint32_t> FirstPrimeInfo? PrimeInfo{primeCount - 1}
+ *
+ * // CRT data could be computed from prime factors. It is only serialized to reuse a code path that's needed for JWK.
+ * FirstPrimeInfo :-
+ *    <factorSize:uint32_t> <factor:byte{factorSize}> <crtExponentSize:uint32_t> <crtExponent:byte{crtExponentSize}>
+ *
+ * PrimeInfo :-
+ *    <factorSize:uint32_t> <factor:byte{factorSize}> <crtExponentSize:uint32_t> <crtExponent:byte{crtExponentSize}> <crtCoefficientSize:uint32_t> <crtCoefficient:byte{crtCoefficientSize}>
+ *
+ * CryptoKeyEC :-
+ *    CryptoAlgorithmIdentifierTag <namedCurve:StringData> CryptoKeyAsymmetricTypeSubtag <keySize:uint32_t> <keyData:byte{keySize}>
+ *
+ * CryptoKeyRaw :-
+ *    CryptoAlgorithmIdentifierTag <keySize:uint32_t> <keyData:byte{keySize}>
+ *
+ * DOMPoint :-
+ *        DOMPointReadOnlyTag DOMPointData
+ *      | DOMPointTag DOMPointData
+ *
+ * DOMPointData :-
+ *      <x:double> <y:double> <z:double> <w:double>
+ *
+ * DOMRect :-
+ *        DOMRectReadOnlyTag DOMRectData
+ *      | DOMRectTag DOMRectData
+ *
+ * DOMRectData :-
+ *      <x:double> <y:double> <width:double> <height:double>
+ *
+ * DOMMatrix :-
+ *        DOMMatrixReadOnlyTag DOMMatrixData
+ *      | DOMMatrixTag DOMMatrixData
+ *
+ * DOMMatrixData :-
+ *        <is2D:uint8_t:true> <m11:double> <m12:double> <m21:double> <m22:double> <m41:double> <m42:double>
+ *      | <is2D:uint8_t:false> <m11:double> <m12:double> <m13:double> <m14:double> <m21:double> <m22:double> <m23:double> <m24:double> <m31:double> <m32:double> <m33:double> <m34:double> <m41:double> <m42:double> <m43:double> <m44:double>
+ *
+ * DOMQuad :-
+ *      DOMQuadTag DOMQuadData
+ *
+ * DOMQuadData :-
+ *      <p1:DOMPointData> <p2:DOMPointData> <p3:DOMPointData> <p4:DOMPointData>
+ *
+ * DestinationColorSpace :-
+ *        DestinationColorSpaceSRGBTag
+ *      | DestinationColorSpaceLinearSRGBTag
+ *      | DestinationColorSpaceDisplayP3Tag
+ *      | DestinationColorSpaceCGColorSpaceNameTag <nameDataLength:uint32_t> <nameData:uint8_t>{nameDataLength}
+ *      | DestinationColorSpaceCGColorSpacePropertyListTag <propertyListDataLength:uint32_t> <propertyListData:uint8_t>{propertyListDataLength}
+ */
+
+using DeserializationResult = std::pair<JSC::JSValue, SerializationReturnCode>;
+
+class CloneBase {
+    WTF_FORBID_HEAP_ALLOCATION;
+
+protected:
+    CloneBase(JSGlobalObject* lexicalGlobalObject)
+        : m_lexicalGlobalObject(lexicalGlobalObject)
+        , m_failed(false)
+    {
+    }
+
+    void fail()
+    {
+        m_failed = true;
+    }
+
+    JSGlobalObject* const m_lexicalGlobalObject;
+    bool m_failed;
+    MarkedArgumentBuffer m_gcBuffer;
+};
+
+#if ENABLE(WEB_CRYPTO)
+static bool wrapCryptoKey(JSGlobalObject* lexicalGlobalObject, const Vector<uint8_t>& key, Vector<uint8_t>& wrappedKey)
+{
+    auto context = executionContext(lexicalGlobalObject);
+    return context && context->wrapCryptoKey(key, wrappedKey);
+}
+
+static bool unwrapCryptoKey(JSGlobalObject* lexicalGlobalObject, const Vector<uint8_t>& wrappedKey, Vector<uint8_t>& key)
+{
+    auto context = executionContext(lexicalGlobalObject);
+    return context && context->unwrapCryptoKey(wrappedKey, key);
+}
+#endif
+
+#if ASSUME_LITTLE_ENDIAN
+template<typename T> static void writeLittleEndian(Vector<uint8_t>& buffer, T value)
+{
+    buffer.append(reinterpret_cast<uint8_t*>(&value), sizeof(value));
+}
+#else
+template<typename T> static void writeLittleEndian(Vector<uint8_t>& buffer, T value)
+{
+    for (unsigned i = 0; i < sizeof(T); i++) {
+        buffer.append(value & 0xFF);
+        value >>= 8;
+    }
+}
+#endif
+
+template<> void writeLittleEndian<uint8_t>(Vector<uint8_t>& buffer, uint8_t value)
+{
+    buffer.append(value);
+}
+
+template<typename T> static bool writeLittleEndian(Vector<uint8_t>& buffer, const T* values, uint32_t length)
+{
+    if (length > std::numeric_limits<uint32_t>::max() / sizeof(T))
+        return false;
+
+#if ASSUME_LITTLE_ENDIAN
+    buffer.append(reinterpret_cast<const uint8_t*>(values), length * sizeof(T));
+#else
+    for (unsigned i = 0; i < length; i++) {
+        T value = values[i];
+        for (unsigned j = 0; j < sizeof(T); j++) {
+            buffer.append(static_cast<uint8_t>(value & 0xFF));
+            value >>= 8;
+        }
+    }
+#endif
+    return true;
+}
+
+template<> bool writeLittleEndian<uint8_t>(Vector<uint8_t>& buffer, const uint8_t* values, uint32_t length)
+{
+    buffer.append(values, length);
+    return true;
+}
+
+class CloneSerializer : CloneBase {
+    WTF_FORBID_HEAP_ALLOCATION;
+
+public:
+    Vector<uint8_t>& m_buffer;
+
+    void write(const uint8_t* data, unsigned length)
+    {
+        writeLittleEndian(m_buffer, data, length);
+    }
+    //     static SerializationReturnCode serialize(JSGlobalObject* lexicalGlobalObject, JSValue value, Vector<RefPtr<MessagePort>>& messagePorts, Vector<RefPtr<JSC::ArrayBuffer>>& arrayBuffers, const Vector<RefPtr<ImageBitmap>>& imageBitmaps,
+    // #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    //         const Vector<RefPtr<OffscreenCanvas>>& offscreenCanvases,
+    // #endif
+    // #if ENABLE(WEB_RTC)
+    //         const Vector<Ref<RTCDataChannel>>& rtcDataChannels,
+    // #endif
+    // #if ENABLE(WEB_CODECS)
+    //         Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>& serializedVideoChunks,
+    //         Vector<RefPtr<WebCodecsVideoFrame>>& serializedVideoFrames,
+    // #endif
+    // #if ENABLE(WEBASSEMBLY)
+    //         WasmModuleArray& wasmModules,
+    //         WasmMemoryHandleArray& wasmMemoryHandles,
+    // #endif
+    //         Vector<URLKeepingBlobAlive>& blobHandles, Vector<uint8_t>& out, SerializationContext context, ArrayBufferContentsArray& sharedBuffers,
+    //         SerializationForStorage forStorage)
+    //     {
+    //         CloneSerializer serializer(lexicalGlobalObject, messagePorts, arrayBuffers, imageBitmaps,
+    // #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    //             offscreenCanvases,
+    // #endif
+    // #if ENABLE(WEB_RTC)
+    //             rtcDataChannels,
+    // #endif
+    // #if ENABLE(WEB_CODECS)
+    //             serializedVideoChunks,
+    //             serializedVideoFrames,
+    // #endif
+    // #if ENABLE(WEBASSEMBLY)
+    //             wasmModules,
+    //             wasmMemoryHandles,
+    // #endif
+    //             blobHandles, out, context, sharedBuffers, forStorage);
+    //         return serializer.serialize(value);
+    //     }
+
+    static SerializationReturnCode serialize(JSGlobalObject* lexicalGlobalObject, JSValue value, Vector<RefPtr<JSC::ArrayBuffer>>& arrayBuffers,
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+        const Vector<RefPtr<OffscreenCanvas>>& offscreenCanvases,
+#endif
+#if ENABLE(WEB_RTC)
+        const Vector<Ref<RTCDataChannel>>& rtcDataChannels,
+#endif
+#if ENABLE(WEB_CODECS)
+        Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>& serializedVideoChunks,
+        Vector<RefPtr<WebCodecsVideoFrame>>& serializedVideoFrames,
+#endif
+#if ENABLE(WEBASSEMBLY)
+        WasmModuleArray& wasmModules,
+        WasmMemoryHandleArray& wasmMemoryHandles,
+#endif
+        Vector<uint8_t>& out, SerializationContext context, ArrayBufferContentsArray& sharedBuffers,
+        SerializationForStorage forStorage)
+    {
+        CloneSerializer serializer(lexicalGlobalObject, arrayBuffers,
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+            offscreenCanvases,
+#endif
+#if ENABLE(WEB_RTC)
+            rtcDataChannels,
+#endif
+#if ENABLE(WEB_CODECS)
+            serializedVideoChunks,
+            serializedVideoFrames,
+#endif
+#if ENABLE(WEBASSEMBLY)
+            wasmModules,
+            wasmMemoryHandles,
+#endif
+            out, context, sharedBuffers, forStorage);
+        return serializer.serialize(value);
+    }
+
+    static bool serialize(StringView string, Vector<uint8_t>& out)
+    {
+        writeLittleEndian(out, CurrentVersion);
+        if (string.isEmpty()) {
+            writeLittleEndian<uint8_t>(out, EmptyStringTag);
+            return true;
+        }
+        writeLittleEndian<uint8_t>(out, StringTag);
+        if (string.is8Bit()) {
+            writeLittleEndian(out, string.length() | StringDataIs8BitFlag);
+            return writeLittleEndian(out, string.characters8(), string.length());
+        }
+        writeLittleEndian(out, string.length());
+        return writeLittleEndian(out, string.characters16(), string.length());
+    }
+
+private:
+    typedef HashMap<JSObject*, uint32_t> ObjectPool;
+
+    //     CloneSerializer(JSGlobalObject* lexicalGlobalObject, Vector<RefPtr<MessagePort>>& messagePorts, Vector<RefPtr<JSC::ArrayBuffer>>& arrayBuffers, const Vector<RefPtr<ImageBitmap>>& imageBitmaps,
+    // #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    //         const Vector<RefPtr<OffscreenCanvas>>& offscreenCanvases,
+    // #endif
+    // #if ENABLE(WEB_RTC)
+    //         const Vector<Ref<RTCDataChannel>>& rtcDataChannels,
+    // #endif
+    // #if ENABLE(WEB_CODECS)
+    //         Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>& serializedVideoChunks,
+    //         Vector<RefPtr<WebCodecsVideoFrame>>& serializedVideoFrames,
+    // #endif
+    // #if ENABLE(WEBASSEMBLY)
+    //         WasmModuleArray& wasmModules,
+    //         WasmMemoryHandleArray& wasmMemoryHandles,
+    // #endif
+    //         Vector<URLKeepingBlobAlive>& blobHandles, Vector<uint8_t>& out, SerializationContext context, ArrayBufferContentsArray& sharedBuffers, SerializationForStorage forStorage)
+    //         : CloneBase(lexicalGlobalObject)
+    //         , m_buffer(out)
+    //         , m_blobHandles(blobHandles)
+    //         , m_emptyIdentifier(Identifier::fromString(lexicalGlobalObject->vm(), emptyString()))
+    //         , m_context(context)
+    //         , m_sharedBuffers(sharedBuffers)
+    // #if ENABLE(WEBASSEMBLY)
+    //         , m_wasmModules(wasmModules)
+    //         , m_wasmMemoryHandles(wasmMemoryHandles)
+    // #endif
+    // #if ENABLE(WEB_CODECS)
+    //         , m_serializedVideoChunks(serializedVideoChunks)
+    //         , m_serializedVideoFrames(serializedVideoFrames)
+    // #endif
+    //         , m_forStorage(forStorage)
+    //     {
+    //         write(CurrentVersion);
+    //         fillTransferMap(messagePorts, m_transferredMessagePorts);
+    //         fillTransferMap(arrayBuffers, m_transferredArrayBuffers);
+    //         fillTransferMap(imageBitmaps, m_transferredImageBitmaps);
+    // #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    //         fillTransferMap(offscreenCanvases, m_transferredOffscreenCanvases);
+    // #endif
+    // #if ENABLE(WEB_RTC)
+    //         fillTransferMap(rtcDataChannels, m_transferredRTCDataChannels);
+    // #endif
+    //     }
+
+    CloneSerializer(JSGlobalObject* lexicalGlobalObject, Vector<RefPtr<JSC::ArrayBuffer>>& arrayBuffers,
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+        const Vector<RefPtr<OffscreenCanvas>>& offscreenCanvases,
+#endif
+#if ENABLE(WEB_RTC)
+        const Vector<Ref<RTCDataChannel>>& rtcDataChannels,
+#endif
+#if ENABLE(WEB_CODECS)
+        Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>& serializedVideoChunks,
+        Vector<RefPtr<WebCodecsVideoFrame>>& serializedVideoFrames,
+#endif
+#if ENABLE(WEBASSEMBLY)
+        WasmModuleArray& wasmModules,
+        WasmMemoryHandleArray& wasmMemoryHandles,
+#endif
+        Vector<uint8_t>& out, SerializationContext context, ArrayBufferContentsArray& sharedBuffers, SerializationForStorage forStorage)
+        : CloneBase(lexicalGlobalObject)
+        , m_buffer(out)
+        , m_emptyIdentifier(Identifier::fromString(lexicalGlobalObject->vm(), emptyString()))
+        , m_context(context)
+        , m_sharedBuffers(sharedBuffers)
+#if ENABLE(WEBASSEMBLY)
+        , m_wasmModules(wasmModules)
+        , m_wasmMemoryHandles(wasmMemoryHandles)
+#endif
+#if ENABLE(WEB_CODECS)
+        , m_serializedVideoChunks(serializedVideoChunks)
+        , m_serializedVideoFrames(serializedVideoFrames)
+#endif
+        , m_forStorage(forStorage)
+    {
+        write(CurrentVersion);
+        fillTransferMap(arrayBuffers, m_transferredArrayBuffers);
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+        fillTransferMap(offscreenCanvases, m_transferredOffscreenCanvases);
+#endif
+#if ENABLE(WEB_RTC)
+        fillTransferMap(rtcDataChannels, m_transferredRTCDataChannels);
+#endif
+    }
+
+    template<class T>
+    void fillTransferMap(const Vector<RefPtr<T>>& input, ObjectPool& result)
+    {
+        if (input.isEmpty())
+            return;
+        JSDOMGlobalObject* globalObject = jsCast<JSDOMGlobalObject*>(m_lexicalGlobalObject);
+        for (size_t i = 0; i < input.size(); i++) {
+            JSC::JSValue value = toJS(m_lexicalGlobalObject, globalObject, input[i].get());
+            JSC::JSObject* obj = value.getObject();
+            if (obj && !result.contains(obj))
+                result.add(obj, i);
+        }
+    }
+    template<class T>
+    void fillTransferMap(const Vector<Ref<T>>& input, ObjectPool& result)
+    {
+        if (input.isEmpty())
+            return;
+        JSDOMGlobalObject* globalObject = jsCast<JSDOMGlobalObject*>(m_lexicalGlobalObject);
+        for (size_t i = 0; i < input.size(); i++) {
+            JSC::JSValue value = toJS(m_lexicalGlobalObject, globalObject, input[i].get());
+            JSC::JSObject* obj = value.getObject();
+            if (obj && !result.contains(obj))
+                result.add(obj, i);
+        }
+    }
+
+    SerializationReturnCode serialize(JSValue in);
+
+    bool isArray(JSValue value)
+    {
+        if (!value.isObject())
+            return false;
+        JSObject* object = asObject(value);
+        return object->inherits<JSArray>();
+    }
+
+    bool isMap(JSValue value)
+    {
+        if (!value.isObject())
+            return false;
+        JSObject* object = asObject(value);
+        return object->inherits<JSMap>();
+    }
+    bool isSet(JSValue value)
+    {
+        if (!value.isObject())
+            return false;
+        JSObject* object = asObject(value);
+        return object->inherits<JSSet>();
+    }
+
+    bool checkForDuplicate(JSObject* object)
+    {
+        // Record object for graph reconstruction
+        ObjectPool::const_iterator found = m_objectPool.find(object);
+
+        // Handle duplicate references
+        if (found != m_objectPool.end()) {
+            write(ObjectReferenceTag);
+            ASSERT(found->value < m_objectPool.size());
+            writeObjectIndex(found->value);
+            return true;
+        }
+
+        return false;
+    }
+
+    void recordObject(JSObject* object)
+    {
+        m_objectPool.add(object, m_objectPool.size());
+        m_gcBuffer.appendWithCrashOnOverflow(object);
+    }
+
+    bool startObjectInternal(JSObject* object)
+    {
+        if (checkForDuplicate(object))
+            return false;
+        recordObject(object);
+        return true;
+    }
+
+    bool startObject(JSObject* object)
+    {
+        if (!startObjectInternal(object))
+            return false;
+        write(ObjectTag);
+        return true;
+    }
+
+    bool startArray(JSArray* array)
+    {
+        if (!startObjectInternal(array))
+            return false;
+
+        unsigned length = array->length();
+        write(ArrayTag);
+        write(length);
+        return true;
+    }
+
+    bool startSet(JSSet* set)
+    {
+        if (!startObjectInternal(set))
+            return false;
+
+        write(SetObjectTag);
+        return true;
+    }
+
+    bool startMap(JSMap* map)
+    {
+        if (!startObjectInternal(map))
+            return false;
+
+        write(MapObjectTag);
+        return true;
+    }
+
+    void endObject()
+    {
+        write(TerminatorTag);
+    }
+
+    JSValue getProperty(JSObject* object, const Identifier& propertyName)
+    {
+        PropertySlot slot(object, PropertySlot::InternalMethodType::Get);
+        if (object->methodTable()->getOwnPropertySlot(object, m_lexicalGlobalObject, propertyName, slot))
+            return slot.getValue(m_lexicalGlobalObject, propertyName);
+        return JSValue();
+    }
+
+    void dumpImmediate(JSValue value, SerializationReturnCode& code)
+    {
+        if (value.isNull()) {
+            write(NullTag);
+            return;
+        }
+        if (value.isUndefined()) {
+            write(UndefinedTag);
+            return;
+        }
+        if (value.isNumber()) {
+            if (value.isInt32()) {
+                if (!value.asInt32())
+                    write(ZeroTag);
+                else if (value.asInt32() == 1)
+                    write(OneTag);
+                else {
+                    write(IntTag);
+                    write(static_cast<uint32_t>(value.asInt32()));
+                }
+            } else {
+                write(DoubleTag);
+                write(value.asDouble());
+            }
+            return;
+        }
+        if (value.isBoolean()) {
+            if (value.isTrue())
+                write(TrueTag);
+            else
+                write(FalseTag);
+            return;
+        }
+#if USE(BIGINT32)
+        if (value.isBigInt32()) {
+            write(BigIntTag);
+            dumpBigIntData(value);
+            return;
+        }
+#endif
+
+        // Make any new primitive extension safe by throwing an error.
+        code = SerializationReturnCode::DataCloneError;
+    }
+
+    void dumpString(const String& string)
+    {
+        if (string.isEmpty())
+            write(EmptyStringTag);
+        else {
+            write(StringTag);
+            write(string);
+        }
+    }
+
+    void dumpStringObject(const String& string)
+    {
+        if (string.isEmpty())
+            write(EmptyStringObjectTag);
+        else {
+            write(StringObjectTag);
+            write(string);
+        }
+    }
+
+    void dumpBigIntData(JSValue value)
+    {
+        ASSERT(value.isBigInt());
+#if USE(BIGINT32)
+        if (value.isBigInt32()) {
+            dumpBigInt32Data(value.bigInt32AsInt32());
+            return;
+        }
+#endif
+        dumpHeapBigIntData(jsCast<JSBigInt*>(value));
+    }
+
+#if USE(BIGINT32)
+    void dumpBigInt32Data(int32_t integer)
+    {
+        write(static_cast<uint8_t>(integer < 0));
+        if (!integer) {
+            write(static_cast<uint32_t>(0)); // Length-in-uint64_t
+            return;
+        }
+        write(static_cast<uint32_t>(1)); // Length-in-uint64_t
+        int64_t value = static_cast<int64_t>(integer);
+        if (value < 0)
+            value = -value;
+        write(static_cast<uint64_t>(value));
+    }
+#endif
+
+    void dumpHeapBigIntData(JSBigInt* bigInt)
+    {
+        write(static_cast<uint8_t>(bigInt->sign()));
+        if constexpr (sizeof(JSBigInt::Digit) == sizeof(uint64_t)) {
+            write(static_cast<uint32_t>(bigInt->length()));
+            for (unsigned index = 0; index < bigInt->length(); ++index)
+                write(static_cast<uint64_t>(bigInt->digit(index)));
+        } else {
+            ASSERT(sizeof(JSBigInt::Digit) == sizeof(uint32_t));
+            uint32_t lengthInUint64 = bigInt->length() / 2;
+            if (bigInt->length() & 0x1)
+                ++lengthInUint64;
+            write(lengthInUint64);
+            uint64_t value = 0;
+            for (unsigned index = 0; index < bigInt->length(); ++index) {
+                if (!(index & 0x1))
+                    value = bigInt->digit(index);
+                else {
+                    value = (static_cast<uint64_t>(bigInt->digit(index)) << 32) | value;
+                    write(static_cast<uint64_t>(value));
+                    value = 0;
+                }
+            }
+            if (bigInt->length() & 0x1)
+                write(static_cast<uint64_t>(value));
+        }
+    }
+
+    JSC::JSValue toJSArrayBuffer(ArrayBuffer& arrayBuffer)
+    {
+        auto& vm = m_lexicalGlobalObject->vm();
+        auto* globalObject = m_lexicalGlobalObject;
+        if (globalObject->inherits<JSDOMGlobalObject>())
+            return toJS(globalObject, jsCast<JSDOMGlobalObject*>(globalObject), &arrayBuffer);
+
+        if (auto* buffer = arrayBuffer.m_wrapper.get())
+            return buffer;
+
+        return JSC::JSArrayBuffer::create(vm, globalObject->arrayBufferStructure(arrayBuffer.sharingMode()), &arrayBuffer);
+    }
+
+    bool dumpArrayBufferView(JSObject* obj, SerializationReturnCode& code)
+    {
+        VM& vm = m_lexicalGlobalObject->vm();
+        write(ArrayBufferViewTag);
+        if (obj->inherits<JSDataView>())
+            write(DataViewTag);
+        else if (obj->inherits<JSUint8ClampedArray>())
+            write(Uint8ClampedArrayTag);
+        else if (obj->inherits<JSInt8Array>())
+            write(Int8ArrayTag);
+        else if (obj->inherits<JSUint8Array>())
+            write(Uint8ArrayTag);
+        else if (obj->inherits<JSInt16Array>())
+            write(Int16ArrayTag);
+        else if (obj->inherits<JSUint16Array>())
+            write(Uint16ArrayTag);
+        else if (obj->inherits<JSInt32Array>())
+            write(Int32ArrayTag);
+        else if (obj->inherits<JSUint32Array>())
+            write(Uint32ArrayTag);
+        else if (obj->inherits<JSFloat32Array>())
+            write(Float32ArrayTag);
+        else if (obj->inherits<JSFloat64Array>())
+            write(Float64ArrayTag);
+        else if (obj->inherits<JSBigInt64Array>())
+            write(BigInt64ArrayTag);
+        else if (obj->inherits<JSBigUint64Array>())
+            write(BigUint64ArrayTag);
+        else
+            return false;
+
+        if (UNLIKELY(jsCast<JSArrayBufferView*>(obj)->isOutOfBounds())) {
+            code = SerializationReturnCode::DataCloneError;
+            return true;
+        }
+
+        RefPtr<ArrayBufferView> arrayBufferView = toPossiblySharedArrayBufferView(vm, obj);
+        if (arrayBufferView->isResizableOrGrowableShared()) {
+            uint64_t byteOffset = arrayBufferView->byteOffsetRaw();
+            write(byteOffset);
+            uint64_t byteLength = arrayBufferView->byteLengthRaw();
+            if (arrayBufferView->isAutoLength())
+                byteLength = autoLengthMarker;
+            write(byteLength);
+        } else {
+            uint64_t byteOffset = arrayBufferView->byteOffset();
+            write(byteOffset);
+            uint64_t byteLength = arrayBufferView->byteLength();
+            write(byteLength);
+        }
+        RefPtr<ArrayBuffer> arrayBuffer = arrayBufferView->possiblySharedBuffer();
+        if (!arrayBuffer) {
+            code = SerializationReturnCode::ValidationError;
+            return true;
+        }
+
+        return dumpIfTerminal(toJSArrayBuffer(*arrayBuffer), code);
+    }
+
+    // void dumpDOMPoint(const DOMPointReadOnly& point)
+    // {
+    //     write(point.x());
+    //     write(point.y());
+    //     write(point.z());
+    //     write(point.w());
+    // }
+
+    // void dumpDOMPoint(JSObject* obj)
+    // {
+    //     if (obj->inherits<JSDOMPoint>())
+    //         write(DOMPointTag);
+    //     else
+    //         write(DOMPointReadOnlyTag);
+
+    //     dumpDOMPoint(jsCast<JSDOMPointReadOnly*>(obj)->wrapped());
+    // }
+
+    // void dumpDOMRect(JSObject* obj)
+    // {
+    //     if (obj->inherits<JSDOMRect>())
+    //         write(DOMRectTag);
+    //     else
+    //         write(DOMRectReadOnlyTag);
+
+    //     auto& rect = jsCast<JSDOMRectReadOnly*>(obj)->wrapped();
+    //     write(rect.x());
+    //     write(rect.y());
+    //     write(rect.width());
+    //     write(rect.height());
+    // }
+
+    // void dumpDOMMatrix(JSObject* obj)
+    // {
+    //     if (obj->inherits<JSDOMMatrix>())
+    //         write(DOMMatrixTag);
+    //     else
+    //         write(DOMMatrixReadOnlyTag);
+
+    //     auto& matrix = jsCast<JSDOMMatrixReadOnly*>(obj)->wrapped();
+    //     bool is2D = matrix.is2D();
+    //     write(static_cast<uint8_t>(is2D));
+    //     if (is2D) {
+    //         write(matrix.m11());
+    //         write(matrix.m12());
+    //         write(matrix.m21());
+    //         write(matrix.m22());
+    //         write(matrix.m41());
+    //         write(matrix.m42());
+    //     } else {
+    //         write(matrix.m11());
+    //         write(matrix.m12());
+    //         write(matrix.m13());
+    //         write(matrix.m14());
+    //         write(matrix.m21());
+    //         write(matrix.m22());
+    //         write(matrix.m23());
+    //         write(matrix.m24());
+    //         write(matrix.m31());
+    //         write(matrix.m32());
+    //         write(matrix.m33());
+    //         write(matrix.m34());
+    //         write(matrix.m41());
+    //         write(matrix.m42());
+    //         write(matrix.m43());
+    //         write(matrix.m44());
+    //     }
+    // }
+
+    // void dumpDOMQuad(JSObject* obj)
+    // {
+    //     write(DOMQuadTag);
+
+    //     auto& quad = jsCast<JSDOMQuad*>(obj)->wrapped();
+    //     dumpDOMPoint(quad.p1());
+    //     dumpDOMPoint(quad.p2());
+    //     dumpDOMPoint(quad.p3());
+    //     dumpDOMPoint(quad.p4());
+    // }
+
+    // void dumpImageBitmap(JSObject* obj, SerializationReturnCode& code)
+    // {
+    //     auto index = m_transferredImageBitmaps.find(obj);
+    //     if (index != m_transferredImageBitmaps.end()) {
+    //         write(ImageBitmapTransferTag);
+    //         write(index->value);
+    //         return;
+    //     }
+
+    //     auto& imageBitmap = jsCast<JSImageBitmap*>(obj)->wrapped();
+    //     if (!imageBitmap.originClean()) {
+    //         code = SerializationReturnCode::DataCloneError;
+    //         return;
+    //     }
+
+    //     auto* buffer = imageBitmap.buffer();
+    //     if (!buffer) {
+    //         code = SerializationReturnCode::ValidationError;
+    //         return;
+    //     }
+
+    //     // FIXME: We should try to avoid converting pixel format.
+    //     PixelBufferFormat format { AlphaPremultiplication::Premultiplied, PixelFormat::RGBA8, buffer->colorSpace() };
+    //     const IntSize& logicalSize = buffer->truncatedLogicalSize();
+    //     auto pixelBuffer = buffer->getPixelBuffer(format, { IntPoint::zero(), logicalSize });
+    //     if (!is<ByteArrayPixelBuffer>(pixelBuffer)) {
+    //         code = SerializationReturnCode::ValidationError;
+    //         return;
+    //     }
+
+    //     auto arrayBuffer = downcast<ByteArrayPixelBuffer>(*pixelBuffer).data().possiblySharedBuffer();
+    //     if (!arrayBuffer) {
+    //         code = SerializationReturnCode::ValidationError;
+    //         return;
+    //     }
+
+    //     write(ImageBitmapTag);
+    //     write(static_cast<uint8_t>(imageBitmap.serializationState().toRaw()));
+    //     write(static_cast<int32_t>(logicalSize.width()));
+    //     write(static_cast<int32_t>(logicalSize.height()));
+    //     write(static_cast<double>(buffer->resolutionScale()));
+    //     write(buffer->colorSpace());
+
+    //     CheckedUint32 byteLength = arrayBuffer->byteLength();
+    //     if (byteLength.hasOverflowed()) {
+    //         code = SerializationReturnCode::ValidationError;
+    //         return;
+    //     }
+    //     write(byteLength);
+    //     write(static_cast<const uint8_t*>(arrayBuffer->data()), byteLength);
+    // }
+
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    void dumpOffscreenCanvas(JSObject* obj, SerializationReturnCode& code)
+    {
+        auto index = m_transferredOffscreenCanvases.find(obj);
+        if (index != m_transferredOffscreenCanvases.end()) {
+            write(OffscreenCanvasTransferTag);
+            write(index->value);
+            return;
+        }
+
+        code = SerializationReturnCode::DataCloneError;
+    }
+#endif
+
+#if ENABLE(WEB_RTC)
+    void dumpRTCDataChannel(JSObject* obj, SerializationReturnCode& code)
+    {
+        auto index = m_transferredRTCDataChannels.find(obj);
+        if (index != m_transferredRTCDataChannels.end()) {
+            write(RTCDataChannelTransferTag);
+            write(index->value);
+            return;
+        }
+
+        code = SerializationReturnCode::DataCloneError;
+    }
+#endif
+#if ENABLE(WEB_CODECS)
+    void dumpWebCodecsEncodedVideoChunk(JSObject* obj)
+    {
+        auto& videoChunk = jsCast<JSWebCodecsEncodedVideoChunk*>(obj)->wrapped();
+
+        auto index = m_serializedVideoChunks.find(&videoChunk.storage());
+        if (index == notFound) {
+            index = m_serializedVideoChunks.size();
+            m_serializedVideoChunks.append(&videoChunk.storage());
+        }
+
+        write(WebCodecsEncodedVideoChunkTag);
+        write(static_cast<uint32_t>(index));
+    }
+
+    bool dumpWebCodecsVideoFrame(JSObject* obj)
+    {
+        Ref videoFrame = jsCast<JSWebCodecsVideoFrame*>(obj)->wrapped();
+        if (videoFrame->isDetached())
+            return false;
+
+        auto index = m_serializedVideoFrames.find(videoFrame.ptr());
+        if (index == notFound) {
+            index = m_serializedVideoChunks.size();
+            m_serializedVideoFrames.append(WTFMove(videoFrame));
+        }
+        write(WebCodecsVideoFrameTag);
+        write(static_cast<uint32_t>(index));
+        return true;
+    }
+#endif
+
+    void dumpDOMException(JSObject* obj, SerializationReturnCode& code)
+    {
+        if (auto* exception = JSDOMException::toWrapped(m_lexicalGlobalObject->vm(), obj)) {
+            write(DOMExceptionTag);
+            write(exception->message());
+            write(exception->name());
+            return;
+        }
+
+        code = SerializationReturnCode::DataCloneError;
+    }
+
+    bool dumpIfTerminal(JSValue value, SerializationReturnCode& code)
+    {
+        if (!value.isCell()) {
+            dumpImmediate(value, code);
+            return true;
+        }
+        ASSERT(value.isCell());
+
+        if (value.isString()) {
+            dumpString(asString(value)->value(m_lexicalGlobalObject));
+            return true;
+        }
+
+        if (value.isHeapBigInt()) {
+            write(BigIntTag);
+            dumpBigIntData(value);
+            return true;
+        }
+
+        if (value.isSymbol()) {
+            code = SerializationReturnCode::DataCloneError;
+            return true;
+        }
+
+        VM& vm = m_lexicalGlobalObject->vm();
+        if (isArray(value))
+            return false;
+
+        if (value.isObject()) {
+            auto* obj = asObject(value);
+            if (auto* dateObject = jsDynamicCast<DateInstance*>(obj)) {
+                write(DateTag);
+                write(dateObject->internalNumber());
+                return true;
+            }
+            if (auto* booleanObject = jsDynamicCast<BooleanObject*>(obj)) {
+                if (!startObjectInternal(booleanObject)) // handle duplicates
+                    return true;
+                write(booleanObject->internalValue().toBoolean(m_lexicalGlobalObject) ? TrueObjectTag : FalseObjectTag);
+                return true;
+            }
+            if (auto* stringObject = jsDynamicCast<StringObject*>(obj)) {
+                if (!startObjectInternal(stringObject)) // handle duplicates
+                    return true;
+                String str = asString(stringObject->internalValue())->value(m_lexicalGlobalObject);
+                dumpStringObject(str);
+                return true;
+            }
+            if (auto* numberObject = jsDynamicCast<NumberObject*>(obj)) {
+                if (!startObjectInternal(numberObject)) // handle duplicates
+                    return true;
+                write(NumberObjectTag);
+                write(numberObject->internalValue().asNumber());
+                return true;
+            }
+            if (auto* bigIntObject = jsDynamicCast<BigIntObject*>(obj)) {
+                if (!startObjectInternal(bigIntObject)) // handle duplicates
+                    return true;
+                JSValue bigIntValue = bigIntObject->internalValue();
+                ASSERT(bigIntValue.isBigInt());
+                write(BigIntObjectTag);
+                dumpBigIntData(bigIntValue);
+                return true;
+            }
+            // if (auto* file = JSFile::toWrapped(vm, obj)) {
+            //     write(FileTag);
+            //     write(*file);
+            //     return true;
+            // }
+            // if (auto* list = JSFileList::toWrapped(vm, obj)) {
+            //     write(FileListTag);
+            //     write(list->length());
+            //     for (auto& file : list->files())
+            //         write(file.get());
+            //     return true;
+            // }
+
+            // write bun types
+            if (auto _cloneable = StructuredCloneableSerialize::fromJS(value)) {
+                StructuredCloneableSerialize cloneable = WTFMove(_cloneable.value());
+                write(cloneable.tag);
+                cloneable.write(this, m_lexicalGlobalObject);
+                return true;
+            }
+
+            // if (auto* blob = JSBlob::toWrapped(vm, obj)) {
+            //     write(BlobTag);
+            //     m_blobHandles.append(blob->handle().isolatedCopy());
+            //     write(blob->url().string());
+            //     write(blob->type());
+            //     static_assert(sizeof(uint64_t) == sizeof(decltype(blob->size())));
+            //     uint64_t size = blob->size();
+            //     write(size);
+            //     uint64_t memoryCost = blob->memoryCost();
+            //     write(memoryCost);
+            //     return true;
+            // }
+            // if (auto* data = JSImageData::toWrapped(vm, obj)) {
+            //     write(ImageDataTag);
+            //     write(data->width());
+            //     write(data->height());
+            //     CheckedUint32 dataLength = data->data().length();
+            //     if (dataLength.hasOverflowed()) {
+            //         code = SerializationReturnCode::DataCloneError;
+            //         return true;
+            //     }
+            //     write(dataLength);
+            //     write(data->data().data(), dataLength);
+            //     write(data->colorSpace());
+            //     return true;
+            // }
+            if (auto* regExp = jsDynamicCast<RegExpObject*>(obj)) {
+                write(RegExpTag);
+                write(regExp->regExp()->pattern());
+                write(String::fromLatin1(JSC::Yarr::flagsString(regExp->regExp()->flags()).data()));
+                return true;
+            }
+            // if (obj->inherits<JSMessagePort>()) {
+            //     auto index = m_transferredMessagePorts.find(obj);
+            //     if (index != m_transferredMessagePorts.end()) {
+            //         write(MessagePortReferenceTag);
+            //         write(index->value);
+            //         return true;
+            //     }
+            //     // MessagePort object could not be found in transferred message ports
+            //     code = SerializationReturnCode::ValidationError;
+            //     return true;
+            // }
+            if (auto* arrayBuffer = toPossiblySharedArrayBuffer(vm, obj)) {
+                if (arrayBuffer->isDetached()) {
+                    code = SerializationReturnCode::ValidationError;
+                    return true;
+                }
+                auto index = m_transferredArrayBuffers.find(obj);
+                if (index != m_transferredArrayBuffers.end()) {
+                    write(ArrayBufferTransferTag);
+                    write(index->value);
+                    return true;
+                }
+                if (!startObjectInternal(obj)) // handle duplicates
+                    return true;
+
+                if (arrayBuffer->isShared() && m_context == SerializationContext::WorkerPostMessage) {
+                    // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal
+                    if (!JSC::Options::useSharedArrayBuffer()) {
+                        code = SerializationReturnCode::DataCloneError;
+                        return true;
+                    }
+                    uint32_t index = m_sharedBuffers.size();
+                    ArrayBufferContents contents;
+                    if (arrayBuffer->shareWith(contents)) {
+                        write(SharedArrayBufferTag);
+                        m_sharedBuffers.append(WTFMove(contents));
+                        write(index);
+                        return true;
+                    }
+                }
+
+                if (arrayBuffer->isResizableOrGrowableShared()) {
+                    write(ResizableArrayBufferTag);
+                    uint64_t byteLength = arrayBuffer->byteLength();
+                    write(byteLength);
+                    uint64_t maxByteLength = arrayBuffer->maxByteLength().value_or(0);
+                    write(maxByteLength);
+                    write(static_cast<const uint8_t*>(arrayBuffer->data()), byteLength);
+                    return true;
+                }
+
+                write(ArrayBufferTag);
+                uint64_t byteLength = arrayBuffer->byteLength();
+                write(byteLength);
+                write(static_cast<const uint8_t*>(arrayBuffer->data()), byteLength);
+                return true;
+            }
+            if (obj->inherits<JSArrayBufferView>()) {
+                if (checkForDuplicate(obj))
+                    return true;
+                bool success = dumpArrayBufferView(obj, code);
+                recordObject(obj);
+                return success;
+            }
+#if ENABLE(WEB_CRYPTO)
+            if (auto* key = JSCryptoKey::toWrapped(vm, obj)) {
+                write(CryptoKeyTag);
+                Vector<uint8_t> serializedKey;
+                // Vector<URLKeepingBlobAlive> dummyBlobHandles;
+                // Vector<RefPtr<MessagePort>> dummyMessagePorts;
+                Vector<RefPtr<JSC::ArrayBuffer>> dummyArrayBuffers;
+#if ENABLE(WEB_CODECS)
+                Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>> dummyVideoChunks;
+                Vector<RefPtr<WebCodecsVideoFrame>> dummyVideoFrames;
+#endif
+#if ENABLE(WEBASSEMBLY)
+                WasmModuleArray dummyModules;
+                WasmMemoryHandleArray dummyMemoryHandles;
+#endif
+                ArrayBufferContentsArray dummySharedBuffers;
+                //                 CloneSerializer rawKeySerializer(m_lexicalGlobalObject, dummyMessagePorts, dummyArrayBuffers, {},
+                // #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+                //                     {},
+                // #endif
+                // #if ENABLE(WEB_RTC)
+                //                     {},
+                // #endif
+                // #if ENABLE(WEB_CODECS)
+                //                     dummyVideoChunks,
+                //                     dummyVideoFrames,
+                // #endif
+                // #if ENABLE(WEBASSEMBLY)
+                //                     dummyModules,
+                //                     dummyMemoryHandles,
+                // #endif
+                //                     dummyBlobHandles, serializedKey, SerializationContext::Default, dummySharedBuffers, m_forStorage);
+                CloneSerializer rawKeySerializer(m_lexicalGlobalObject, dummyArrayBuffers,
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+                    {},
+#endif
+#if ENABLE(WEB_RTC)
+                    {},
+#endif
+#if ENABLE(WEB_CODECS)
+                    dummyVideoChunks,
+                    dummyVideoFrames,
+#endif
+#if ENABLE(WEBASSEMBLY)
+                    dummyModules,
+                    dummyMemoryHandles,
+#endif
+                    serializedKey, SerializationContext::Default, dummySharedBuffers, m_forStorage);
+                rawKeySerializer.write(key);
+                Vector<uint8_t> wrappedKey;
+                if (!wrapCryptoKey(m_lexicalGlobalObject, serializedKey, wrappedKey))
+                    return false;
+                write(wrappedKey);
+                return true;
+            }
+#endif
+#if ENABLE(WEB_RTC)
+            if (auto* rtcCertificate = JSRTCCertificate::toWrapped(vm, obj)) {
+                write(RTCCertificateTag);
+                write(rtcCertificate->expires());
+                write(rtcCertificate->pemCertificate());
+                write(rtcCertificate->origin().toString());
+                write(rtcCertificate->pemPrivateKey());
+                write(static_cast<unsigned>(rtcCertificate->getFingerprints().size()));
+                for (const auto& fingerprint : rtcCertificate->getFingerprints()) {
+                    write(fingerprint.algorithm);
+                    write(fingerprint.value);
+                }
+                return true;
+            }
+#endif
+#if ENABLE(WEBASSEMBLY)
+            if (JSWebAssemblyModule* module = jsDynamicCast<JSWebAssemblyModule*>(obj)) {
+                if (m_context != SerializationContext::WorkerPostMessage && m_context != SerializationContext::WindowPostMessage)
+                    return false;
+
+                uint32_t index = m_wasmModules.size();
+                m_wasmModules.append(&module->module());
+                write(WasmModuleTag);
+                write(agentClusterIDFromGlobalObject(*m_lexicalGlobalObject));
+                write(index);
+                return true;
+            }
+            if (JSWebAssemblyMemory* memory = jsDynamicCast<JSWebAssemblyMemory*>(obj)) {
+                if (!JSC::Options::useSharedArrayBuffer() || memory->memory().sharingMode() != JSC::MemorySharingMode::Shared) {
+                    code = SerializationReturnCode::DataCloneError;
+                    return true;
+                }
+                if (m_context != SerializationContext::WorkerPostMessage) {
+                    code = SerializationReturnCode::DataCloneError;
+                    return true;
+                }
+                uint32_t index = m_wasmMemoryHandles.size();
+                m_wasmMemoryHandles.append(memory->memory().shared());
+                write(WasmMemoryTag);
+                write(agentClusterIDFromGlobalObject(*m_lexicalGlobalObject));
+                write(index);
+                return true;
+            }
+#endif
+            // if (obj->inherits<JSDOMPointReadOnly>()) {
+            //     dumpDOMPoint(obj);
+            //     return true;
+            // }
+            // if (obj->inherits<JSDOMRectReadOnly>()) {
+            //     dumpDOMRect(obj);
+            //     return true;
+            // }
+            // if (obj->inherits<JSDOMMatrixReadOnly>()) {
+            //     dumpDOMMatrix(obj);
+            //     return true;
+            // }
+            // if (obj->inherits<JSDOMQuad>()) {
+            //     dumpDOMQuad(obj);
+            //     return true;
+            // }
+            // if (obj->inherits<JSImageBitmap>()) {
+            //     dumpImageBitmap(obj, code);
+            //     return true;
+            // }
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+            if (obj->inherits<JSOffscreenCanvas>()) {
+                dumpOffscreenCanvas(obj, code);
+                return true;
+            }
+#endif
+#if ENABLE(WEB_RTC)
+            if (obj->inherits<JSRTCDataChannel>()) {
+                dumpRTCDataChannel(obj, code);
+                return true;
+            }
+#endif
+            if (obj->inherits<JSDOMException>()) {
+                dumpDOMException(obj, code);
+                return true;
+            }
+#if ENABLE(WEB_CODECS)
+            if (obj->inherits<JSWebCodecsEncodedVideoChunk>()) {
+                if (m_forStorage == SerializationForStorage::Yes)
+                    return false;
+                dumpWebCodecsEncodedVideoChunk(obj);
+                return true;
+            }
+            if (obj->inherits<JSWebCodecsVideoFrame>()) {
+                if (m_forStorage == SerializationForStorage::Yes)
+                    return false;
+                return dumpWebCodecsVideoFrame(obj);
+            }
+#endif
+
+            return false;
+        }
+        // Any other types are expected to serialize as null.
+        write(NullTag);
+        return true;
+    }
+
+    void write(SerializationTag tag)
+    {
+        writeLittleEndian<uint8_t>(m_buffer, static_cast<uint8_t>(tag));
+    }
+
+    void write(ArrayBufferViewSubtag tag)
+    {
+        writeLittleEndian<uint8_t>(m_buffer, static_cast<uint8_t>(tag));
+    }
+
+    void write(DestinationColorSpaceTag tag)
+    {
+        writeLittleEndian<uint8_t>(m_buffer, static_cast<uint8_t>(tag));
+    }
+
+#if ENABLE(WEB_CRYPTO)
+    void write(CryptoKeyClassSubtag tag)
+    {
+        writeLittleEndian<uint8_t>(m_buffer, static_cast<uint8_t>(tag));
+    }
+
+    void write(CryptoKeyAsymmetricTypeSubtag tag)
+    {
+        writeLittleEndian<uint8_t>(m_buffer, static_cast<uint8_t>(tag));
+    }
+
+    void write(CryptoKeyUsageTag tag)
+    {
+        writeLittleEndian<uint8_t>(m_buffer, static_cast<uint8_t>(tag));
+    }
+
+    void write(CryptoAlgorithmIdentifierTag tag)
+    {
+        writeLittleEndian<uint8_t>(m_buffer, static_cast<uint8_t>(tag));
+    }
+
+    void write(CryptoKeyOKPOpNameTag tag)
+    {
+        writeLittleEndian<uint8_t>(m_buffer, static_cast<uint8_t>(tag));
+    }
+#endif
+
+    void write(uint8_t c)
+    {
+        writeLittleEndian(m_buffer, c);
+    }
+
+    void write(uint32_t i)
+    {
+        writeLittleEndian(m_buffer, i);
+    }
+
+    void write(double d)
+    {
+        union {
+            double d;
+            int64_t i;
+        } u;
+        u.d = d;
+        writeLittleEndian(m_buffer, u.i);
+    }
+
+    void write(int32_t i)
+    {
+        writeLittleEndian(m_buffer, i);
+    }
+
+    void write(uint64_t i)
+    {
+        writeLittleEndian(m_buffer, i);
+    }
+
+    void write(uint16_t ch)
+    {
+        writeLittleEndian(m_buffer, ch);
+    }
+
+    void writeStringIndex(unsigned i)
+    {
+        writeConstantPoolIndex(m_constantPool, i);
+    }
+
+    void writeObjectIndex(unsigned i)
+    {
+        writeConstantPoolIndex(m_objectPool, i);
+    }
+
+    template<class T> void writeConstantPoolIndex(const T& constantPool, unsigned i)
+    {
+        ASSERT(i < constantPool.size());
+        if (constantPool.size() <= 0xFF)
+            write(static_cast<uint8_t>(i));
+        else if (constantPool.size() <= 0xFFFF)
+            write(static_cast<uint16_t>(i));
+        else
+            write(static_cast<uint32_t>(i));
+    }
+
+    void write(const Identifier& ident)
+    {
+        const String& str = ident.string();
+        StringConstantPool::AddResult addResult = m_constantPool.add(ident.impl(), m_constantPool.size());
+        if (!addResult.isNewEntry) {
+            write(StringPoolTag);
+            writeStringIndex(addResult.iterator->value);
+            return;
+        }
+
+        unsigned length = str.length();
+
+        // Guard against overflow
+        if (length > (std::numeric_limits<uint32_t>::max() - sizeof(uint32_t)) / sizeof(UChar)) {
+            fail();
+            return;
+        }
+
+        if (str.is8Bit())
+            writeLittleEndian<uint32_t>(m_buffer, length | StringDataIs8BitFlag);
+        else
+            writeLittleEndian<uint32_t>(m_buffer, length);
+
+        if (!length)
+            return;
+        if (str.is8Bit()) {
+            if (!writeLittleEndian(m_buffer, str.characters8(), length))
+                fail();
+            return;
+        }
+        if (!writeLittleEndian(m_buffer, str.characters16(), length))
+            fail();
+    }
+
+    void write(const String& str)
+    {
+        if (str.isNull())
+            write(m_emptyIdentifier);
+        else
+            write(Identifier::fromString(m_lexicalGlobalObject->vm(), str));
+    }
+
+    void write(const Vector<uint8_t>& vector)
+    {
+        uint32_t size = vector.size();
+        write(size);
+        writeLittleEndian(m_buffer, vector.data(), size);
+    }
+
+    // void write(const File& file)
+    // {
+    //     m_blobHandles.append(file.handle().isolatedCopy());
+    //     write(file.path());
+    //     write(file.url().string());
+    //     write(file.type());
+    //     write(file.name());
+    //     write(static_cast<double>(file.lastModifiedOverride().value_or(-1)));
+    // }
+
+    //     void write(PredefinedColorSpace colorSpace)
+    //     {
+    //         switch (colorSpace) {
+    //         case PredefinedColorSpace::SRGB:
+    //             writeLittleEndian<uint8_t>(m_buffer, static_cast<uint8_t>(PredefinedColorSpaceTag::SRGB));
+    //             break;
+    // #if ENABLE(PREDEFINED_COLOR_SPACE_DISPLAY_P3)
+    //         case PredefinedColorSpace::DisplayP3:
+    //             writeLittleEndian<uint8_t>(m_buffer, static_cast<uint8_t>(PredefinedColorSpaceTag::DisplayP3));
+    //             break;
+    // #endif
+    //         }
+    //     }
+
+#if PLATFORM(COCOA)
+    void write(const RetainPtr<CFDataRef>& data)
+    {
+        uint32_t dataLength = CFDataGetLength(data.get());
+        write(dataLength);
+        write(CFDataGetBytePtr(data.get()), dataLength);
+    }
+#endif
+
+    //     void write(DestinationColorSpace destinationColorSpace)
+    //     {
+    //         if (destinationColorSpace == DestinationColorSpace::SRGB()) {
+    //             write(DestinationColorSpaceSRGBTag);
+    //             return;
+    //         }
+
+    // #if ENABLE(DESTINATION_COLOR_SPACE_LINEAR_SRGB)
+    //         if (destinationColorSpace == DestinationColorSpace::LinearSRGB()) {
+    //             write(DestinationColorSpaceLinearSRGBTag);
+    //             return;
+    //         }
+    // #endif
+
+    // #if ENABLE(DESTINATION_COLOR_SPACE_DISPLAY_P3)
+    //         if (destinationColorSpace == DestinationColorSpace::DisplayP3()) {
+    //             write(DestinationColorSpaceDisplayP3Tag);
+    //             return;
+    //         }
+    // #endif
+
+    // #if PLATFORM(COCOA)
+    //         auto colorSpace = destinationColorSpace.platformColorSpace();
+
+    //         if (auto name = CGColorSpaceGetName(colorSpace)) {
+    //             auto data = adoptCF(CFStringCreateExternalRepresentation(nullptr, name, kCFStringEncodingUTF8, 0));
+    //             if (!data) {
+    //                 write(DestinationColorSpaceSRGBTag);
+    //                 return;
+    //             }
+
+    //             write(DestinationColorSpaceCGColorSpaceNameTag);
+    //             write(data);
+    //             return;
+    //         }
+
+    //         if (auto propertyList = adoptCF(CGColorSpaceCopyPropertyList(colorSpace))) {
+    //             auto data = adoptCF(CFPropertyListCreateData(nullptr, propertyList.get(), kCFPropertyListBinaryFormat_v1_0, 0, nullptr));
+    //             if (!data) {
+    //                 write(DestinationColorSpaceSRGBTag);
+    //                 return;
+    //             }
+
+    //             write(DestinationColorSpaceCGColorSpacePropertyListTag);
+    //             write(data);
+    //             return;
+    //         }
+    // #endif
+
+    //         ASSERT_NOT_REACHED();
+    //         write(DestinationColorSpaceSRGBTag);
+    //     }
+
+#if ENABLE(WEB_CRYPTO)
+    void write(CryptoKeyOKP::NamedCurve curve)
+    {
+        switch (curve) {
+        case CryptoKeyOKP::NamedCurve::X25519:
+            write(CryptoKeyOKPOpNameTag::X25519);
+            break;
+        case CryptoKeyOKP::NamedCurve::Ed25519:
+            write(CryptoKeyOKPOpNameTag::ED25519);
+            break;
+        }
+    }
+
+    void write(CryptoAlgorithmIdentifier algorithm)
+    {
+        switch (algorithm) {
+        case CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5:
+            write(CryptoAlgorithmIdentifierTag::RSAES_PKCS1_v1_5);
+            break;
+        case CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5:
+            write(CryptoAlgorithmIdentifierTag::RSASSA_PKCS1_v1_5);
+            break;
+        case CryptoAlgorithmIdentifier::RSA_PSS:
+            write(CryptoAlgorithmIdentifierTag::RSA_PSS);
+            break;
+        case CryptoAlgorithmIdentifier::RSA_OAEP:
+            write(CryptoAlgorithmIdentifierTag::RSA_OAEP);
+            break;
+        case CryptoAlgorithmIdentifier::ECDSA:
+            write(CryptoAlgorithmIdentifierTag::ECDSA);
+            break;
+        case CryptoAlgorithmIdentifier::ECDH:
+            write(CryptoAlgorithmIdentifierTag::ECDH);
+            break;
+        case CryptoAlgorithmIdentifier::AES_CTR:
+            write(CryptoAlgorithmIdentifierTag::AES_CTR);
+            break;
+        case CryptoAlgorithmIdentifier::AES_CBC:
+            write(CryptoAlgorithmIdentifierTag::AES_CBC);
+            break;
+        case CryptoAlgorithmIdentifier::AES_GCM:
+            write(CryptoAlgorithmIdentifierTag::AES_GCM);
+            break;
+        case CryptoAlgorithmIdentifier::AES_CFB:
+            write(CryptoAlgorithmIdentifierTag::AES_CFB);
+            break;
+        case CryptoAlgorithmIdentifier::AES_KW:
+            write(CryptoAlgorithmIdentifierTag::AES_KW);
+            break;
+        case CryptoAlgorithmIdentifier::HMAC:
+            write(CryptoAlgorithmIdentifierTag::HMAC);
+            break;
+        case CryptoAlgorithmIdentifier::SHA_1:
+            write(CryptoAlgorithmIdentifierTag::SHA_1);
+            break;
+        case CryptoAlgorithmIdentifier::SHA_224:
+            write(CryptoAlgorithmIdentifierTag::SHA_224);
+            break;
+        case CryptoAlgorithmIdentifier::SHA_256:
+            write(CryptoAlgorithmIdentifierTag::SHA_256);
+            break;
+        case CryptoAlgorithmIdentifier::SHA_384:
+            write(CryptoAlgorithmIdentifierTag::SHA_384);
+            break;
+        case CryptoAlgorithmIdentifier::SHA_512:
+            write(CryptoAlgorithmIdentifierTag::SHA_512);
+            break;
+        case CryptoAlgorithmIdentifier::HKDF:
+            write(CryptoAlgorithmIdentifierTag::HKDF);
+            break;
+        case CryptoAlgorithmIdentifier::PBKDF2:
+            write(CryptoAlgorithmIdentifierTag::PBKDF2);
+            break;
+        case CryptoAlgorithmIdentifier::Ed25519:
+            write(CryptoAlgorithmIdentifierTag::ED25519);
+            break;
+        }
+    }
+
+    void write(CryptoKeyRSAComponents::Type type)
+    {
+        switch (type) {
+        case CryptoKeyRSAComponents::Type::Public:
+            write(CryptoKeyAsymmetricTypeSubtag::Public);
+            return;
+        case CryptoKeyRSAComponents::Type::Private:
+            write(CryptoKeyAsymmetricTypeSubtag::Private);
+            return;
+        }
+    }
+
+    void write(const CryptoKeyRSAComponents& key)
+    {
+        write(key.type());
+        write(key.modulus());
+        write(key.exponent());
+        if (key.type() == CryptoKeyRSAComponents::Type::Public)
+            return;
+
+        write(key.privateExponent());
+
+        unsigned primeCount = key.hasAdditionalPrivateKeyParameters() ? key.otherPrimeInfos().size() + 2 : 0;
+        write(primeCount);
+        if (!primeCount)
+            return;
+
+        write(key.firstPrimeInfo().primeFactor);
+        write(key.firstPrimeInfo().factorCRTExponent);
+        write(key.secondPrimeInfo().primeFactor);
+        write(key.secondPrimeInfo().factorCRTExponent);
+        write(key.secondPrimeInfo().factorCRTCoefficient);
+        for (unsigned i = 2; i < primeCount; ++i) {
+            write(key.otherPrimeInfos()[i].primeFactor);
+            write(key.otherPrimeInfos()[i].factorCRTExponent);
+            write(key.otherPrimeInfos()[i].factorCRTCoefficient);
+        }
+    }
+
+    void write(const CryptoKey* key)
+    {
+        write(currentKeyFormatVersion);
+
+        write(key->extractable());
+
+        CryptoKeyUsageBitmap usages = key->usagesBitmap();
+        write(countUsages(usages));
+        if (usages & CryptoKeyUsageEncrypt)
+            write(CryptoKeyUsageTag::Encrypt);
+        if (usages & CryptoKeyUsageDecrypt)
+            write(CryptoKeyUsageTag::Decrypt);
+        if (usages & CryptoKeyUsageSign)
+            write(CryptoKeyUsageTag::Sign);
+        if (usages & CryptoKeyUsageVerify)
+            write(CryptoKeyUsageTag::Verify);
+        if (usages & CryptoKeyUsageDeriveKey)
+            write(CryptoKeyUsageTag::DeriveKey);
+        if (usages & CryptoKeyUsageDeriveBits)
+            write(CryptoKeyUsageTag::DeriveBits);
+        if (usages & CryptoKeyUsageWrapKey)
+            write(CryptoKeyUsageTag::WrapKey);
+        if (usages & CryptoKeyUsageUnwrapKey)
+            write(CryptoKeyUsageTag::UnwrapKey);
+
+        switch (key->keyClass()) {
+        case CryptoKeyClass::HMAC:
+            write(CryptoKeyClassSubtag::HMAC);
+            write(downcast<CryptoKeyHMAC>(*key).key());
+            write(downcast<CryptoKeyHMAC>(*key).hashAlgorithmIdentifier());
+            break;
+        case CryptoKeyClass::AES:
+            write(CryptoKeyClassSubtag::AES);
+            write(key->algorithmIdentifier());
+            write(downcast<CryptoKeyAES>(*key).key());
+            break;
+        case CryptoKeyClass::EC:
+            write(CryptoKeyClassSubtag::EC);
+            write(key->algorithmIdentifier());
+            write(downcast<CryptoKeyEC>(*key).namedCurveString());
+            switch (key->type()) {
+            case CryptoKey::Type::Public: {
+                write(CryptoKeyAsymmetricTypeSubtag::Public);
+                auto result = downcast<CryptoKeyEC>(*key).exportRaw();
+                ASSERT(!result.hasException());
+                write(result.releaseReturnValue());
+                break;
+            }
+            case CryptoKey::Type::Private: {
+                write(CryptoKeyAsymmetricTypeSubtag::Private);
+                // Use the standard complied method is not very efficient, but simple/reliable.
+                auto result = downcast<CryptoKeyEC>(*key).exportPkcs8();
+                ASSERT(!result.hasException());
+                write(result.releaseReturnValue());
+                break;
+            }
+            default:
+                ASSERT_NOT_REACHED();
+            }
+            break;
+        case CryptoKeyClass::Raw:
+            write(CryptoKeyClassSubtag::Raw);
+            write(key->algorithmIdentifier());
+            write(downcast<CryptoKeyRaw>(*key).key());
+            break;
+        case CryptoKeyClass::RSA: {
+            write(CryptoKeyClassSubtag::RSA);
+            write(key->algorithmIdentifier());
+            CryptoAlgorithmIdentifier hash;
+            bool isRestrictedToHash = downcast<CryptoKeyRSA>(*key).isRestrictedToHash(hash);
+            write(isRestrictedToHash);
+            if (isRestrictedToHash)
+                write(hash);
+            write(*downcast<CryptoKeyRSA>(*key).exportData());
+            break;
+        }
+        case CryptoKeyClass::OKP:
+            write(CryptoKeyClassSubtag::OKP);
+            write(key->algorithmIdentifier());
+            write(downcast<CryptoKeyOKP>(*key).namedCurve());
+            write(downcast<CryptoKeyOKP>(*key).platformKey());
+            break;
+        }
+    }
+#endif
+    // Vector<URLKeepingBlobAlive>& m_blobHandles;
+    ObjectPool m_objectPool;
+    ObjectPool m_transferredMessagePorts;
+    ObjectPool m_transferredArrayBuffers;
+    ObjectPool m_transferredImageBitmaps;
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    ObjectPool m_transferredOffscreenCanvases;
+#endif
+#if ENABLE(WEB_RTC)
+    ObjectPool m_transferredRTCDataChannels;
+#endif
+    typedef HashMap<RefPtr<UniquedStringImpl>, uint32_t, IdentifierRepHash> StringConstantPool;
+    StringConstantPool m_constantPool;
+    Identifier m_emptyIdentifier;
+    SerializationContext m_context;
+    ArrayBufferContentsArray& m_sharedBuffers;
+#if ENABLE(WEBASSEMBLY)
+    WasmModuleArray& m_wasmModules;
+    WasmMemoryHandleArray& m_wasmMemoryHandles;
+#endif
+#if ENABLE(WEB_CODECS)
+    Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>& m_serializedVideoChunks;
+    Vector<RefPtr<WebCodecsVideoFrame>>& m_serializedVideoFrames;
+#endif
+    SerializationForStorage m_forStorage;
+};
+
+void SerializedScriptValue::writeBytesForBun(CloneSerializer* ctx, const uint8_t* data, uint32_t size)
+{
+    ctx->write(data, size);
+}
+
+SerializationReturnCode CloneSerializer::serialize(JSValue in)
+{
+    VM& vm = m_lexicalGlobalObject->vm();
+    Vector<uint32_t, 16> indexStack;
+    Vector<uint32_t, 16> lengthStack;
+    Vector<PropertyNameArray, 16> propertyStack;
+    Vector<JSObject*, 32> inputObjectStack;
+    Vector<JSMapIterator*, 4> mapIteratorStack;
+    Vector<JSSetIterator*, 4> setIteratorStack;
+    Vector<JSValue, 4> mapIteratorValueStack;
+    Vector<WalkerState, 16> stateStack;
+    WalkerState state = StateUnknown;
+    JSValue inValue = in;
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    while (1) {
+        switch (state) {
+        arrayStartState:
+        case ArrayStartState: {
+            ASSERT(isArray(inValue));
+            if (inputObjectStack.size() > maximumFilterRecursion)
+                return SerializationReturnCode::StackOverflowError;
+
+            JSArray* inArray = asArray(inValue);
+            unsigned length = inArray->length();
+            if (!startArray(inArray))
+                break;
+            inputObjectStack.append(inArray);
+            indexStack.append(0);
+            lengthStack.append(length);
+        }
+        arrayStartVisitMember:
+            FALLTHROUGH;
+        case ArrayStartVisitMember: {
+            JSObject* array = inputObjectStack.last();
+            uint32_t index = indexStack.last();
+            if (index == lengthStack.last()) {
+                indexStack.removeLast();
+                lengthStack.removeLast();
+
+                propertyStack.append(PropertyNameArray(vm, PropertyNameMode::Strings, PrivateSymbolMode::Exclude));
+                array->getOwnNonIndexPropertyNames(m_lexicalGlobalObject, propertyStack.last(), DontEnumPropertiesMode::Exclude);
+                if (UNLIKELY(scope.exception()))
+                    return SerializationReturnCode::ExistingExceptionError;
+                if (propertyStack.last().size()) {
+                    write(NonIndexPropertiesTag);
+                    indexStack.append(0);
+                    goto objectStartVisitMember;
+                }
+                propertyStack.removeLast();
+
+                endObject();
+                inputObjectStack.removeLast();
+                break;
+            }
+            inValue = array->getDirectIndex(m_lexicalGlobalObject, index);
+            if (UNLIKELY(scope.exception()))
+                return SerializationReturnCode::ExistingExceptionError;
+            if (!inValue) {
+                indexStack.last()++;
+                goto arrayStartVisitMember;
+            }
+
+            write(index);
+            auto terminalCode = SerializationReturnCode::SuccessfullyCompleted;
+            if (dumpIfTerminal(inValue, terminalCode)) {
+                if (terminalCode != SerializationReturnCode::SuccessfullyCompleted)
+                    return terminalCode;
+                indexStack.last()++;
+                goto arrayStartVisitMember;
+            }
+            stateStack.append(ArrayEndVisitMember);
+            goto stateUnknown;
+        }
+        case ArrayEndVisitMember: {
+            indexStack.last()++;
+            goto arrayStartVisitMember;
+        }
+        objectStartState:
+        case ObjectStartState: {
+            ASSERT(inValue.isObject());
+            if (inputObjectStack.size() > maximumFilterRecursion)
+                return SerializationReturnCode::StackOverflowError;
+            JSObject* inObject = asObject(inValue);
+            if (!startObject(inObject))
+                break;
+            // At this point, all supported objects other than Object
+            // objects have been handled. If we reach this point and
+            // the input is not an Object object then we should throw
+            // a DataCloneError.
+            if (inObject->classInfo() != JSFinalObject::info())
+                return SerializationReturnCode::DataCloneError;
+            inputObjectStack.append(inObject);
+            indexStack.append(0);
+            propertyStack.append(PropertyNameArray(vm, PropertyNameMode::Strings, PrivateSymbolMode::Exclude));
+            inObject->methodTable()->getOwnPropertyNames(inObject, m_lexicalGlobalObject, propertyStack.last(), DontEnumPropertiesMode::Exclude);
+            if (UNLIKELY(scope.exception()))
+                return SerializationReturnCode::ExistingExceptionError;
+        }
+        objectStartVisitMember:
+            FALLTHROUGH;
+        case ObjectStartVisitMember: {
+            JSObject* object = inputObjectStack.last();
+            uint32_t index = indexStack.last();
+            PropertyNameArray& properties = propertyStack.last();
+            if (index == properties.size()) {
+                endObject();
+                inputObjectStack.removeLast();
+                indexStack.removeLast();
+                propertyStack.removeLast();
+                break;
+            }
+            inValue = getProperty(object, properties[index]);
+            if (UNLIKELY(scope.exception()))
+                return SerializationReturnCode::ExistingExceptionError;
+
+            if (!inValue) {
+                // Property was removed during serialisation
+                indexStack.last()++;
+                goto objectStartVisitMember;
+            }
+            write(properties[index]);
+
+            if (UNLIKELY(scope.exception()))
+                return SerializationReturnCode::ExistingExceptionError;
+
+            auto terminalCode = SerializationReturnCode::SuccessfullyCompleted;
+            if (!dumpIfTerminal(inValue, terminalCode)) {
+                stateStack.append(ObjectEndVisitMember);
+                goto stateUnknown;
+            }
+            if (terminalCode != SerializationReturnCode::SuccessfullyCompleted)
+                return terminalCode;
+            FALLTHROUGH;
+        }
+        case ObjectEndVisitMember: {
+            if (UNLIKELY(scope.exception()))
+                return SerializationReturnCode::ExistingExceptionError;
+
+            indexStack.last()++;
+            goto objectStartVisitMember;
+        }
+        mapStartState : {
+            ASSERT(inValue.isObject());
+            if (inputObjectStack.size() > maximumFilterRecursion)
+                return SerializationReturnCode::StackOverflowError;
+            JSMap* inMap = jsCast<JSMap*>(inValue);
+            if (!startMap(inMap))
+                break;
+            JSMapIterator* iterator = JSMapIterator::create(vm, m_lexicalGlobalObject->mapIteratorStructure(), inMap, IterationKind::Entries);
+            m_gcBuffer.appendWithCrashOnOverflow(inMap);
+            m_gcBuffer.appendWithCrashOnOverflow(iterator);
+            mapIteratorStack.append(iterator);
+            inputObjectStack.append(inMap);
+            goto mapDataStartVisitEntry;
+        }
+        mapDataStartVisitEntry:
+        case MapDataStartVisitEntry: {
+            JSMapIterator* iterator = mapIteratorStack.last();
+            JSValue key, value;
+            if (!iterator->nextKeyValue(m_lexicalGlobalObject, key, value)) {
+                mapIteratorStack.removeLast();
+                JSObject* object = inputObjectStack.last();
+                ASSERT(jsDynamicCast<JSMap*>(object));
+                propertyStack.append(PropertyNameArray(vm, PropertyNameMode::Strings, PrivateSymbolMode::Exclude));
+                object->methodTable()->getOwnPropertyNames(object, m_lexicalGlobalObject, propertyStack.last(), DontEnumPropertiesMode::Exclude);
+                if (UNLIKELY(scope.exception()))
+                    return SerializationReturnCode::ExistingExceptionError;
+                write(NonMapPropertiesTag);
+                indexStack.append(0);
+                goto objectStartVisitMember;
+            }
+            inValue = key;
+            m_gcBuffer.appendWithCrashOnOverflow(value);
+            mapIteratorValueStack.append(value);
+            stateStack.append(MapDataEndVisitKey);
+            goto stateUnknown;
+        }
+        case MapDataEndVisitKey: {
+            inValue = mapIteratorValueStack.last();
+            mapIteratorValueStack.removeLast();
+            stateStack.append(MapDataEndVisitValue);
+            goto stateUnknown;
+        }
+        case MapDataEndVisitValue: {
+            goto mapDataStartVisitEntry;
+        }
+
+        setStartState : {
+            ASSERT(inValue.isObject());
+            if (inputObjectStack.size() > maximumFilterRecursion)
+                return SerializationReturnCode::StackOverflowError;
+            JSSet* inSet = jsCast<JSSet*>(inValue);
+            if (!startSet(inSet))
+                break;
+            JSSetIterator* iterator = JSSetIterator::create(vm, m_lexicalGlobalObject->setIteratorStructure(), inSet, IterationKind::Keys);
+            m_gcBuffer.appendWithCrashOnOverflow(inSet);
+            m_gcBuffer.appendWithCrashOnOverflow(iterator);
+            setIteratorStack.append(iterator);
+            inputObjectStack.append(inSet);
+            goto setDataStartVisitEntry;
+        }
+        setDataStartVisitEntry:
+        case SetDataStartVisitEntry: {
+            JSSetIterator* iterator = setIteratorStack.last();
+            JSValue key;
+            if (!iterator->next(m_lexicalGlobalObject, key)) {
+                setIteratorStack.removeLast();
+                JSObject* object = inputObjectStack.last();
+                ASSERT(jsDynamicCast<JSSet*>(object));
+                propertyStack.append(PropertyNameArray(vm, PropertyNameMode::Strings, PrivateSymbolMode::Exclude));
+                object->methodTable()->getOwnPropertyNames(object, m_lexicalGlobalObject, propertyStack.last(), DontEnumPropertiesMode::Exclude);
+                if (UNLIKELY(scope.exception()))
+                    return SerializationReturnCode::ExistingExceptionError;
+                write(NonSetPropertiesTag);
+                indexStack.append(0);
+                goto objectStartVisitMember;
+            }
+            inValue = key;
+            stateStack.append(SetDataEndVisitKey);
+            goto stateUnknown;
+        }
+        case SetDataEndVisitKey: {
+            goto setDataStartVisitEntry;
+        }
+
+        stateUnknown:
+        case StateUnknown: {
+            auto terminalCode = SerializationReturnCode::SuccessfullyCompleted;
+            if (dumpIfTerminal(inValue, terminalCode)) {
+                if (terminalCode != SerializationReturnCode::SuccessfullyCompleted)
+                    return terminalCode;
+                break;
+            }
+
+            if (isArray(inValue))
+                goto arrayStartState;
+            if (isMap(inValue))
+                goto mapStartState;
+            if (isSet(inValue))
+                goto setStartState;
+            goto objectStartState;
+        }
+        }
+        if (stateStack.isEmpty())
+            break;
+
+        state = stateStack.last();
+        stateStack.removeLast();
+    }
+    if (m_failed)
+        return SerializationReturnCode::UnspecifiedError;
+
+    return SerializationReturnCode::SuccessfullyCompleted;
+}
+
+class CloneDeserializer : CloneBase {
+    WTF_FORBID_HEAP_ALLOCATION;
+
+public:
+    static String deserializeString(const Vector<uint8_t>& buffer)
+    {
+        if (buffer.isEmpty())
+            return String();
+        const uint8_t* ptr = buffer.begin();
+        const uint8_t* end = buffer.end();
+        uint32_t version;
+        if (!readLittleEndian(ptr, end, version) || version > CurrentVersion)
+            return String();
+        uint8_t tag;
+        if (!readLittleEndian(ptr, end, tag) || tag != StringTag)
+            return String();
+        uint32_t length;
+        if (!readLittleEndian(ptr, end, length))
+            return String();
+        bool is8Bit = length & StringDataIs8BitFlag;
+        length &= ~StringDataIs8BitFlag;
+        String str;
+        if (!readString(ptr, end, str, length, is8Bit))
+            return String();
+        return str;
+    }
+
+    //     static DeserializationResult deserialize(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, Vector<std::optional<ImageBitmapBacking>>&& backingStores
+    // #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    //         ,
+    //         Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& detachedOffscreenCanvases
+    // #endif
+    // #if ENABLE(WEB_RTC)
+    //         ,
+    //         Vector<std::unique_ptr<DetachedRTCDataChannel>>&& detachedRTCDataChannels
+    // #endif
+    //         ,
+    //         ArrayBufferContentsArray* arrayBufferContentsArray, const Vector<uint8_t>& buffer, const Vector<String>& blobURLs, const Vector<String> blobFilePaths, ArrayBufferContentsArray* sharedBuffers
+    // #if ENABLE(WEBASSEMBLY)
+    //         ,
+    //         WasmModuleArray* wasmModules, WasmMemoryHandleArray* wasmMemoryHandles
+    // #endif
+    // #if ENABLE(WEB_CODECS)
+    //         ,
+    //         Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>&& serializedVideoChunks, Vector<WebCodecsVideoFrameData>&& serializedVideoFrames
+    // #endif
+    //     )
+    //     {
+    //         if (!buffer.size())
+    //             return std::make_pair(jsNull(), SerializationReturnCode::UnspecifiedError);
+    //         CloneDeserializer deserializer(lexicalGlobalObject, globalObject, messagePorts, arrayBufferContentsArray, buffer, blobURLs, blobFilePaths, sharedBuffers, WTFMove(backingStores)
+    // #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    //                                                                                                                                                                       ,
+    //             WTFMove(detachedOffscreenCanvases)
+    // #endif
+    // #if ENABLE(WEB_RTC)
+    //                 ,
+    //             WTFMove(detachedRTCDataChannels)
+    // #endif
+    // #if ENABLE(WEBASSEMBLY)
+    //                 ,
+    //             wasmModules, wasmMemoryHandles
+    // #endif
+    // #if ENABLE(WEB_CODECS)
+    //             ,
+    //             WTFMove(serializedVideoChunks), WTFMove(serializedVideoFrames)
+    // #endif
+    //         );
+    //         if (!deserializer.isValid())
+    //             return std::make_pair(JSValue(), SerializationReturnCode::ValidationError);
+    //         return deserializer.deserialize();
+    //     }
+
+    static DeserializationResult deserialize(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+        ,
+        Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& detachedOffscreenCanvases
+#endif
+#if ENABLE(WEB_RTC)
+        ,
+        Vector<std::unique_ptr<DetachedRTCDataChannel>>&& detachedRTCDataChannels
+#endif
+        ,
+        ArrayBufferContentsArray* arrayBufferContentsArray, const Vector<uint8_t>& buffer, const Vector<String>& blobURLs, const Vector<String> blobFilePaths, ArrayBufferContentsArray* sharedBuffers
+#if ENABLE(WEBASSEMBLY)
+        ,
+        WasmModuleArray* wasmModules, WasmMemoryHandleArray* wasmMemoryHandles
+#endif
+#if ENABLE(WEB_CODECS)
+        ,
+        Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>&& serializedVideoChunks, Vector<WebCodecsVideoFrameData>&& serializedVideoFrames
+#endif
+    )
+    {
+        if (!buffer.size())
+            return std::make_pair(jsNull(), SerializationReturnCode::UnspecifiedError);
+        CloneDeserializer deserializer(lexicalGlobalObject, globalObject, arrayBufferContentsArray, buffer, blobURLs, blobFilePaths, sharedBuffers
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+            ,
+            WTFMove(detachedOffscreenCanvases)
+#endif
+#if ENABLE(WEB_RTC)
+                ,
+            WTFMove(detachedRTCDataChannels)
+#endif
+#if ENABLE(WEBASSEMBLY)
+                ,
+            wasmModules, wasmMemoryHandles
+#endif
+#if ENABLE(WEB_CODECS)
+            ,
+            WTFMove(serializedVideoChunks), WTFMove(serializedVideoFrames)
+#endif
+        );
+        if (!deserializer.isValid())
+            return std::make_pair(JSValue(), SerializationReturnCode::ValidationError);
+        return deserializer.deserialize();
+    }
+
+private:
+    struct CachedString {
+        CachedString(const String& string)
+            : m_string(string)
+        {
+        }
+
+        JSValue jsString(JSGlobalObject* lexicalGlobalObject)
+        {
+            if (!m_jsString)
+                m_jsString = JSC::jsString(lexicalGlobalObject->vm(), m_string);
+            return m_jsString;
+        }
+        const String& string() { return m_string; }
+        String takeString() { return WTFMove(m_string); }
+
+    private:
+        String m_string;
+        JSValue m_jsString;
+    };
+
+    struct CachedStringRef {
+        CachedStringRef()
+            : m_base(0)
+            , m_index(0)
+        {
+        }
+        CachedStringRef(Vector<CachedString>* base, size_t index)
+            : m_base(base)
+            , m_index(index)
+        {
+        }
+
+        CachedString* operator->()
+        {
+            ASSERT(m_base);
+            return &m_base->at(m_index);
+        }
+
+    private:
+        Vector<CachedString>* m_base;
+        size_t m_index;
+    };
+
+    //     CloneDeserializer(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, ArrayBufferContentsArray* arrayBufferContents, Vector<std::optional<ImageBitmapBacking>>&& backingStores, const Vector<uint8_t>& buffer
+    // #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    //         ,
+    //         Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& detachedOffscreenCanvases = {}
+    // #endif
+    // #if ENABLE(WEB_RTC)
+    //         ,
+    //         Vector<std::unique_ptr<DetachedRTCDataChannel>>&& detachedRTCDataChannels = {}
+    // #endif
+    // #if ENABLE(WEBASSEMBLY)
+    //         ,
+    //         WasmModuleArray* wasmModules = nullptr, WasmMemoryHandleArray* wasmMemoryHandles = nullptr
+    // #endif
+    // #if ENABLE(WEB_CODECS)
+    //         ,
+    //         Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>&& serializedVideoChunks = {}, Vector<WebCodecsVideoFrameData>&& serializedVideoFrames = {}
+    // #endif
+    //         )
+    //         : CloneBase(lexicalGlobalObject)
+    //         , m_globalObject(globalObject)
+    //         , m_isDOMGlobalObject(globalObject->inherits<JSDOMGlobalObject>())
+    //         , m_canCreateDOMObject(m_isDOMGlobalObject && !globalObject->inherits<JSIDBSerializationGlobalObject>())
+    //         , m_ptr(buffer.data())
+    //         , m_end(buffer.data() + buffer.size())
+    //         , m_version(0xFFFFFFFF)
+    //         , m_messagePorts(messagePorts)
+    //         , m_arrayBufferContents(arrayBufferContents)
+    //         , m_arrayBuffers(arrayBufferContents ? arrayBufferContents->size() : 0)
+    //         , m_backingStores(WTFMove(backingStores))
+    //         , m_imageBitmaps(m_backingStores.size())
+    // #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    //         , m_detachedOffscreenCanvases(WTFMove(detachedOffscreenCanvases))
+    //         , m_offscreenCanvases(m_detachedOffscreenCanvases.size())
+    // #endif
+    // #if ENABLE(WEB_RTC)
+    //         , m_detachedRTCDataChannels(WTFMove(detachedRTCDataChannels))
+    //         , m_rtcDataChannels(m_detachedRTCDataChannels.size())
+    // #endif
+    // #if ENABLE(WEBASSEMBLY)
+    //         , m_wasmModules(wasmModules)
+    //         , m_wasmMemoryHandles(wasmMemoryHandles)
+    // #endif
+    // #if ENABLE(WEB_CODECS)
+    //         , m_serializedVideoChunks(WTFMove(serializedVideoChunks))
+    //         , m_videoChunks(m_serializedVideoChunks.size())
+    //         , m_serializedVideoFrames(WTFMove(serializedVideoFrames))
+    //         , m_videoFrames(m_serializedVideoFrames.size())
+    // #endif
+    //     {
+    //         if (!read(m_version))
+    //             m_version = 0xFFFFFFFF;
+    //     }
+
+    CloneDeserializer(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject, ArrayBufferContentsArray* arrayBufferContents, const Vector<uint8_t>& buffer
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+        ,
+        Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& detachedOffscreenCanvases = {}
+#endif
+#if ENABLE(WEB_RTC)
+        ,
+        Vector<std::unique_ptr<DetachedRTCDataChannel>>&& detachedRTCDataChannels = {}
+#endif
+#if ENABLE(WEBASSEMBLY)
+        ,
+        WasmModuleArray* wasmModules = nullptr, WasmMemoryHandleArray* wasmMemoryHandles = nullptr
+#endif
+#if ENABLE(WEB_CODECS)
+        ,
+        Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>&& serializedVideoChunks = {}, Vector<WebCodecsVideoFrameData>&& serializedVideoFrames = {}
+#endif
+        )
+        : CloneBase(lexicalGlobalObject)
+        , m_globalObject(globalObject)
+        , m_isDOMGlobalObject(globalObject->inherits<JSDOMGlobalObject>())
+        , m_canCreateDOMObject(m_isDOMGlobalObject)
+        , m_ptr(buffer.data())
+        , m_end(buffer.data() + buffer.size())
+        , m_version(0xFFFFFFFF)
+        , m_arrayBufferContents(arrayBufferContents)
+        , m_arrayBuffers(arrayBufferContents ? arrayBufferContents->size() : 0)
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+        , m_detachedOffscreenCanvases(WTFMove(detachedOffscreenCanvases))
+        , m_offscreenCanvases(m_detachedOffscreenCanvases.size())
+#endif
+#if ENABLE(WEB_RTC)
+        , m_detachedRTCDataChannels(WTFMove(detachedRTCDataChannels))
+        , m_rtcDataChannels(m_detachedRTCDataChannels.size())
+#endif
+#if ENABLE(WEBASSEMBLY)
+        , m_wasmModules(wasmModules)
+        , m_wasmMemoryHandles(wasmMemoryHandles)
+#endif
+#if ENABLE(WEB_CODECS)
+        , m_serializedVideoChunks(WTFMove(serializedVideoChunks))
+        , m_videoChunks(m_serializedVideoChunks.size())
+        , m_serializedVideoFrames(WTFMove(serializedVideoFrames))
+        , m_videoFrames(m_serializedVideoFrames.size())
+#endif
+    {
+        if (!read(m_version))
+            m_version = 0xFFFFFFFF;
+    }
+
+    //     CloneDeserializer(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, ArrayBufferContentsArray* arrayBufferContents, const Vector<uint8_t>& buffer, const Vector<String>& blobURLs, const Vector<String> blobFilePaths, ArrayBufferContentsArray* sharedBuffers, Vector<std::optional<ImageBitmapBacking>>&& backingStores
+    // #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    //         ,
+    //         Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& detachedOffscreenCanvases
+    // #endif
+    // #if ENABLE(WEB_RTC)
+    //         ,
+    //         Vector<std::unique_ptr<DetachedRTCDataChannel>>&& detachedRTCDataChannels
+    // #endif
+    // #if ENABLE(WEBASSEMBLY)
+    //         ,
+    //         WasmModuleArray* wasmModules, WasmMemoryHandleArray* wasmMemoryHandles
+    // #endif
+    // #if ENABLE(WEB_CODECS)
+    //         ,
+    //         Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>&& serializedVideoChunks = {}, Vector<WebCodecsVideoFrameData>&& serializedVideoFrames = {}
+    // #endif
+    //         )
+    //         : CloneBase(lexicalGlobalObject)
+    //         , m_globalObject(globalObject)
+    //         , m_isDOMGlobalObject(globalObject->inherits<JSDOMGlobalObject>())
+    //         , m_canCreateDOMObject(m_isDOMGlobalObject && !globalObject->inherits<JSIDBSerializationGlobalObject>())
+    //         , m_ptr(buffer.data())
+    //         , m_end(buffer.data() + buffer.size())
+    //         , m_version(0xFFFFFFFF)
+    //         , m_messagePorts(messagePorts)
+    //         , m_arrayBufferContents(arrayBufferContents)
+    //         , m_arrayBuffers(arrayBufferContents ? arrayBufferContents->size() : 0)
+    //         , m_blobURLs(blobURLs)
+    //         , m_blobFilePaths(blobFilePaths)
+    //         , m_sharedBuffers(sharedBuffers)
+    //         , m_backingStores(WTFMove(backingStores))
+    //         , m_imageBitmaps(m_backingStores.size())
+    // #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    //         , m_detachedOffscreenCanvases(WTFMove(detachedOffscreenCanvases))
+    //         , m_offscreenCanvases(m_detachedOffscreenCanvases.size())
+    // #endif
+    // #if ENABLE(WEB_RTC)
+    //         , m_detachedRTCDataChannels(WTFMove(detachedRTCDataChannels))
+    //         , m_rtcDataChannels(m_detachedRTCDataChannels.size())
+    // #endif
+    // #if ENABLE(WEBASSEMBLY)
+    //         , m_wasmModules(wasmModules)
+    //         , m_wasmMemoryHandles(wasmMemoryHandles)
+    // #endif
+    // #if ENABLE(WEB_CODECS)
+    //         , m_serializedVideoChunks(WTFMove(serializedVideoChunks))
+    //         , m_videoChunks(m_serializedVideoChunks.size())
+    //         , m_serializedVideoFrames(WTFMove(serializedVideoFrames))
+    //         , m_videoFrames(m_serializedVideoFrames.size())
+    // #endif
+    //     {
+    //         if (!read(m_version))
+    //             m_version = 0xFFFFFFFF;
+    //     }
+
+    CloneDeserializer(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject, ArrayBufferContentsArray* arrayBufferContents, const Vector<uint8_t>& buffer, const Vector<String>& blobURLs, const Vector<String> blobFilePaths, ArrayBufferContentsArray* sharedBuffers
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+        ,
+        Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& detachedOffscreenCanvases
+#endif
+#if ENABLE(WEB_RTC)
+        ,
+        Vector<std::unique_ptr<DetachedRTCDataChannel>>&& detachedRTCDataChannels
+#endif
+#if ENABLE(WEBASSEMBLY)
+        ,
+        WasmModuleArray* wasmModules, WasmMemoryHandleArray* wasmMemoryHandles
+#endif
+#if ENABLE(WEB_CODECS)
+        ,
+        Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>&& serializedVideoChunks = {}, Vector<WebCodecsVideoFrameData>&& serializedVideoFrames = {}
+#endif
+        )
+        : CloneBase(lexicalGlobalObject)
+        , m_globalObject(globalObject)
+        , m_isDOMGlobalObject(globalObject->inherits<JSDOMGlobalObject>())
+        , m_canCreateDOMObject(m_isDOMGlobalObject)
+        , m_ptr(buffer.data())
+        , m_end(buffer.data() + buffer.size())
+        , m_version(0xFFFFFFFF)
+        , m_arrayBufferContents(arrayBufferContents)
+        , m_arrayBuffers(arrayBufferContents ? arrayBufferContents->size() : 0)
+        , m_blobURLs(blobURLs)
+        , m_blobFilePaths(blobFilePaths)
+        , m_sharedBuffers(sharedBuffers)
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+        , m_detachedOffscreenCanvases(WTFMove(detachedOffscreenCanvases))
+        , m_offscreenCanvases(m_detachedOffscreenCanvases.size())
+#endif
+#if ENABLE(WEB_RTC)
+        , m_detachedRTCDataChannels(WTFMove(detachedRTCDataChannels))
+        , m_rtcDataChannels(m_detachedRTCDataChannels.size())
+#endif
+#if ENABLE(WEBASSEMBLY)
+        , m_wasmModules(wasmModules)
+        , m_wasmMemoryHandles(wasmMemoryHandles)
+#endif
+#if ENABLE(WEB_CODECS)
+        , m_serializedVideoChunks(WTFMove(serializedVideoChunks))
+        , m_videoChunks(m_serializedVideoChunks.size())
+        , m_serializedVideoFrames(WTFMove(serializedVideoFrames))
+        , m_videoFrames(m_serializedVideoFrames.size())
+#endif
+    {
+        if (!read(m_version))
+            m_version = 0xFFFFFFFF;
+    }
+
+    DeserializationResult deserialize();
+
+    bool isValid() const { return m_version <= CurrentVersion; }
+
+    template<typename T> bool readLittleEndian(T& value)
+    {
+        if (m_failed || !readLittleEndian(m_ptr, m_end, value)) {
+            fail();
+            return false;
+        }
+        return true;
+    }
+#if ASSUME_LITTLE_ENDIAN
+    template<typename T> static bool readLittleEndian(const uint8_t*& ptr, const uint8_t* end, T& value)
+    {
+        if (ptr > end - sizeof(value))
+            return false;
+
+        if (sizeof(T) == 1)
+            value = *ptr++;
+        else {
+            value = *reinterpret_cast<const T*>(ptr);
+            ptr += sizeof(T);
+        }
+        return true;
+    }
+#else
+    template<typename T> static bool readLittleEndian(const uint8_t*& ptr, const uint8_t* end, T& value)
+    {
+        if (ptr > end - sizeof(value))
+            return false;
+
+        if (sizeof(T) == 1)
+            value = *ptr++;
+        else {
+            value = 0;
+            for (unsigned i = 0; i < sizeof(T); i++)
+                value += ((T)*ptr++) << (i * 8);
+        }
+        return true;
+    }
+#endif
+
+    bool read(uint32_t& i)
+    {
+        return readLittleEndian(i);
+    }
+
+    bool read(int32_t& i)
+    {
+        return readLittleEndian(*reinterpret_cast<uint32_t*>(&i));
+    }
+
+    bool read(uint16_t& i)
+    {
+        return readLittleEndian(i);
+    }
+
+    bool read(uint8_t& i)
+    {
+        return readLittleEndian(i);
+    }
+
+    bool read(double& d)
+    {
+        union {
+            double d;
+            uint64_t i64;
+        } u;
+        if (!readLittleEndian(u.i64))
+            return false;
+        d = u.d;
+        return true;
+    }
+
+    bool read(uint64_t& i)
+    {
+        return readLittleEndian(i);
+    }
+
+    bool readStringIndex(uint32_t& i)
+    {
+        return readConstantPoolIndex(m_constantPool, i);
+    }
+
+    template<class T> bool readConstantPoolIndex(const T& constantPool, uint32_t& i)
+    {
+        if (constantPool.size() <= 0xFF) {
+            uint8_t i8;
+            if (!read(i8))
+                return false;
+            i = i8;
+            return true;
+        }
+        if (constantPool.size() <= 0xFFFF) {
+            uint16_t i16;
+            if (!read(i16))
+                return false;
+            i = i16;
+            return true;
+        }
+        return read(i);
+    }
+
+    static bool readString(const uint8_t*& ptr, const uint8_t* end, String& str, unsigned length, bool is8Bit)
+    {
+        if (length >= std::numeric_limits<int32_t>::max() / sizeof(UChar))
+            return false;
+
+        if (is8Bit) {
+            if ((end - ptr) < static_cast<int>(length))
+                return false;
+            str = String { ptr, length };
+            ptr += length;
+            return true;
+        }
+
+        unsigned size = length * sizeof(UChar);
+        if ((end - ptr) < static_cast<int>(size))
+            return false;
+
+#if ASSUME_LITTLE_ENDIAN
+        str = String(reinterpret_cast<const UChar*>(ptr), length);
+        ptr += length * sizeof(UChar);
+#else
+        UChar* characters;
+        str = String::createUninitialized(length, characters);
+        for (unsigned i = 0; i < length; ++i) {
+            uint16_t c;
+            readLittleEndian(ptr, end, c);
+            characters[i] = c;
+        }
+#endif
+        return true;
+    }
+
+    bool readStringData(CachedStringRef& cachedString)
+    {
+        bool scratch;
+        return readStringData(cachedString, scratch);
+    }
+
+    bool readStringData(CachedStringRef& cachedString, bool& wasTerminator)
+    {
+        if (m_failed)
+            return false;
+        uint32_t length = 0;
+        if (!read(length))
+            return false;
+        if (length == TerminatorTag) {
+            wasTerminator = true;
+            return false;
+        }
+        if (length == StringPoolTag) {
+            unsigned index = 0;
+            if (!readStringIndex(index)) {
+                fail();
+                return false;
+            }
+            if (index >= m_constantPool.size()) {
+                fail();
+                return false;
+            }
+            cachedString = CachedStringRef(&m_constantPool, index);
+            return true;
+        }
+        bool is8Bit = length & StringDataIs8BitFlag;
+        length &= ~StringDataIs8BitFlag;
+        String str;
+        if (!readString(m_ptr, m_end, str, length, is8Bit)) {
+            fail();
+            return false;
+        }
+        m_constantPool.append(str);
+        cachedString = CachedStringRef(&m_constantPool, m_constantPool.size() - 1);
+        return true;
+    }
+
+    SerializationTag readTag()
+    {
+        if (m_ptr >= m_end)
+            return ErrorTag;
+        return static_cast<SerializationTag>(*m_ptr++);
+    }
+
+    bool readArrayBufferViewSubtag(ArrayBufferViewSubtag& tag)
+    {
+        if (m_ptr >= m_end)
+            return false;
+        tag = static_cast<ArrayBufferViewSubtag>(*m_ptr++);
+        return true;
+    }
+
+    void putProperty(JSObject* object, unsigned index, JSValue value)
+    {
+        object->putDirectIndex(m_lexicalGlobalObject, index, value);
+    }
+
+    void putProperty(JSObject* object, const Identifier& property, JSValue value)
+    {
+        object->putDirectMayBeIndex(m_lexicalGlobalObject, property, value);
+    }
+
+    // bool readFile(RefPtr<File>& file)
+    // {
+    //     CachedStringRef path;
+    //     if (!readStringData(path))
+    //         return false;
+    //     CachedStringRef url;
+    //     if (!readStringData(url))
+    //         return false;
+    //     CachedStringRef type;
+    //     if (!readStringData(type))
+    //         return false;
+    //     CachedStringRef name;
+    //     if (!readStringData(name))
+    //         return false;
+    //     std::optional<int64_t> optionalLastModified;
+    //     if (m_version > 6) {
+    //         double lastModified;
+    //         if (!read(lastModified))
+    //             return false;
+    //         if (lastModified >= 0)
+    //             optionalLastModified = lastModified;
+    //     }
+
+    //     // If the blob URL for this file has an associated blob file path, prefer that one over the "built-in" path.
+    //     String filePath = blobFilePathForBlobURL(url->string());
+    //     if (filePath.isEmpty())
+    //         filePath = path->string();
+
+    //     if (!m_canCreateDOMObject)
+    //         return true;
+
+    //     file = File::deserialize(executionContext(m_lexicalGlobalObject), filePath, URL { url->string() }, type->string(), name->string(), optionalLastModified);
+    //     return true;
+    // }
+
+    template<typename LengthType>
+    bool readArrayBufferImpl(RefPtr<ArrayBuffer>& arrayBuffer)
+    {
+        LengthType length;
+        if (!read(length))
+            return false;
+        if (m_ptr + length > m_end)
+            return false;
+        arrayBuffer = ArrayBuffer::tryCreate(m_ptr, length);
+        if (!arrayBuffer)
+            return false;
+        m_ptr += length;
+        return true;
+    }
+
+    bool readArrayBuffer(RefPtr<ArrayBuffer>& arrayBuffer)
+    {
+        if (m_version < 10)
+            return readArrayBufferImpl<uint32_t>(arrayBuffer);
+        return readArrayBufferImpl<uint64_t>(arrayBuffer);
+    }
+
+    bool readResizableNonSharedArrayBuffer(RefPtr<ArrayBuffer>& arrayBuffer)
+    {
+        uint64_t byteLength;
+        if (!read(byteLength))
+            return false;
+        uint64_t maxByteLength;
+        if (!read(maxByteLength))
+            return false;
+        if (m_ptr + byteLength > m_end)
+            return false;
+        arrayBuffer = ArrayBuffer::tryCreate(byteLength, 1, maxByteLength);
+        if (!arrayBuffer)
+            return false;
+        ASSERT(arrayBuffer->isResizableNonShared());
+        memcpy(arrayBuffer->data(), m_ptr, byteLength);
+        m_ptr += byteLength;
+        return true;
+    }
+
+    template<typename LengthType>
+    bool readArrayBufferViewImpl(VM& vm, JSValue& arrayBufferView)
+    {
+        ArrayBufferViewSubtag arrayBufferViewSubtag;
+        if (!readArrayBufferViewSubtag(arrayBufferViewSubtag))
+            return false;
+        LengthType byteOffset;
+        if (!read(byteOffset))
+            return false;
+        LengthType byteLength;
+        if (!read(byteLength))
+            return false;
+        JSValue arrayBufferValue = readTerminal();
+        if (!arrayBufferValue || !arrayBufferValue.inherits<JSArrayBuffer>())
+            return false;
+        JSObject* arrayBufferObj = asObject(arrayBufferValue);
+
+        unsigned elementSize = typedArrayElementSize(arrayBufferViewSubtag);
+        if (!elementSize)
+            return false;
+
+        RefPtr<ArrayBuffer> arrayBuffer = toPossiblySharedArrayBuffer(vm, arrayBufferObj);
+        if (!arrayBuffer) {
+            arrayBufferView = jsNull();
+            return true;
+        }
+
+        std::optional<size_t> length;
+        if (byteLength != autoLengthMarker) {
+            LengthType computedLength = byteLength / elementSize;
+            if (computedLength * elementSize != byteLength)
+                return false;
+            length = computedLength;
+        } else {
+            if (!arrayBuffer->isResizableOrGrowableShared())
+                return false;
+        }
+
+        switch (arrayBufferViewSubtag) {
+        case DataViewTag:
+            arrayBufferView = toJS(m_lexicalGlobalObject, m_globalObject, DataView::wrappedAs(arrayBuffer.releaseNonNull(), byteOffset, length).get());
+            return true;
+        case Int8ArrayTag:
+            arrayBufferView = toJS(m_lexicalGlobalObject, m_globalObject, Int8Array::wrappedAs(arrayBuffer.releaseNonNull(), byteOffset, length).get());
+            return true;
+        case Uint8ArrayTag:
+            arrayBufferView = toJS(m_lexicalGlobalObject, m_globalObject, Uint8Array::wrappedAs(arrayBuffer.releaseNonNull(), byteOffset, length).get());
+            return true;
+        case Uint8ClampedArrayTag:
+            arrayBufferView = toJS(m_lexicalGlobalObject, m_globalObject, Uint8ClampedArray::wrappedAs(arrayBuffer.releaseNonNull(), byteOffset, length).get());
+            return true;
+        case Int16ArrayTag:
+            arrayBufferView = toJS(m_lexicalGlobalObject, m_globalObject, Int16Array::wrappedAs(arrayBuffer.releaseNonNull(), byteOffset, length).get());
+            return true;
+        case Uint16ArrayTag:
+            arrayBufferView = toJS(m_lexicalGlobalObject, m_globalObject, Uint16Array::wrappedAs(arrayBuffer.releaseNonNull(), byteOffset, length).get());
+            return true;
+        case Int32ArrayTag:
+            arrayBufferView = toJS(m_lexicalGlobalObject, m_globalObject, Int32Array::wrappedAs(arrayBuffer.releaseNonNull(), byteOffset, length).get());
+            return true;
+        case Uint32ArrayTag:
+            arrayBufferView = toJS(m_lexicalGlobalObject, m_globalObject, Uint32Array::wrappedAs(arrayBuffer.releaseNonNull(), byteOffset, length).get());
+            return true;
+        case Float32ArrayTag:
+            arrayBufferView = toJS(m_lexicalGlobalObject, m_globalObject, Float32Array::wrappedAs(arrayBuffer.releaseNonNull(), byteOffset, length).get());
+            return true;
+        case Float64ArrayTag:
+            arrayBufferView = toJS(m_lexicalGlobalObject, m_globalObject, Float64Array::wrappedAs(arrayBuffer.releaseNonNull(), byteOffset, length).get());
+            return true;
+        case BigInt64ArrayTag:
+            arrayBufferView = toJS(m_lexicalGlobalObject, m_globalObject, BigInt64Array::wrappedAs(arrayBuffer.releaseNonNull(), byteOffset, length).get());
+            return true;
+        case BigUint64ArrayTag:
+            arrayBufferView = toJS(m_lexicalGlobalObject, m_globalObject, BigUint64Array::wrappedAs(arrayBuffer.releaseNonNull(), byteOffset, length).get());
+            return true;
+        default:
+            return false;
+        }
+    }
+
+    bool readArrayBufferView(VM& vm, JSValue& arrayBufferView)
+    {
+        if (m_version < 10)
+            return readArrayBufferViewImpl<uint32_t>(vm, arrayBufferView);
+        return readArrayBufferViewImpl<uint64_t>(vm, arrayBufferView);
+    }
+
+    bool read(Vector<uint8_t>& result)
+    {
+        ASSERT(result.isEmpty());
+        uint32_t size;
+        if (!read(size))
+            return false;
+        if (m_ptr + size > m_end)
+            return false;
+        result.append(m_ptr, size);
+        m_ptr += size;
+        return true;
+    }
+
+    //     bool read(PredefinedColorSpace& result)
+    //     {
+    //         uint8_t tag;
+    //         if (!read(tag))
+    //             return false;
+
+    //         switch (static_cast<PredefinedColorSpaceTag>(tag)) {
+    //         case PredefinedColorSpaceTag::SRGB:
+    //             result = PredefinedColorSpace::SRGB;
+    //             return true;
+    // #if ENABLE(PREDEFINED_COLOR_SPACE_DISPLAY_P3)
+    //         case PredefinedColorSpaceTag::DisplayP3:
+    //             result = PredefinedColorSpace::DisplayP3;
+    //             return true;
+    // #endif
+    //         default:
+    //             return false;
+    //         }
+    //     }
+
+    // bool read(DestinationColorSpaceTag& tag)
+    // {
+    //     if (m_ptr >= m_end)
+    //         return false;
+    //     tag = static_cast<DestinationColorSpaceTag>(*m_ptr++);
+    //     return true;
+    // }
+
+#if PLATFORM(COCOA)
+    bool read(RetainPtr<CFDataRef>& data)
+    {
+        uint32_t dataLength;
+        if (!read(dataLength) || static_cast<uint32_t>(m_end - m_ptr) < dataLength)
+            return false;
+
+        data = adoptCF(CFDataCreateWithBytesNoCopy(nullptr, m_ptr, dataLength, kCFAllocatorNull));
+        if (!data)
+            return false;
+
+        m_ptr += dataLength;
+        return true;
+    }
+#endif
+
+    //     bool read(DestinationColorSpace& destinationColorSpace)
+    //     {
+    //         DestinationColorSpaceTag tag;
+    //         if (!read(tag))
+    //             return false;
+
+    //         switch (tag) {
+    //         case DestinationColorSpaceSRGBTag:
+    //             destinationColorSpace = DestinationColorSpace::SRGB();
+    //             return true;
+    // #if ENABLE(DESTINATION_COLOR_SPACE_LINEAR_SRGB)
+    //         case DestinationColorSpaceLinearSRGBTag:
+    //             destinationColorSpace = DestinationColorSpace::LinearSRGB();
+    //             return true;
+    // #endif
+    // #if ENABLE(DESTINATION_COLOR_SPACE_DISPLAY_P3)
+    //         case DestinationColorSpaceDisplayP3Tag:
+    //             destinationColorSpace = DestinationColorSpace::DisplayP3();
+    //             return true;
+    // #endif
+    // #if PLATFORM(COCOA)
+    //         case DestinationColorSpaceCGColorSpaceNameTag: {
+    //             RetainPtr<CFDataRef> data;
+    //             if (!read(data))
+    //                 return false;
+
+    //             auto name = adoptCF(CFStringCreateFromExternalRepresentation(nullptr, data.get(), kCFStringEncodingUTF8));
+    //             if (!name)
+    //                 return false;
+
+    //             auto colorSpace = adoptCF(CGColorSpaceCreateWithName(name.get()));
+    //             if (!colorSpace)
+    //                 return false;
+
+    //             destinationColorSpace = DestinationColorSpace(colorSpace.get());
+    //             return true;
+    //         }
+    //         case DestinationColorSpaceCGColorSpacePropertyListTag: {
+    //             RetainPtr<CFDataRef> data;
+    //             if (!read(data))
+    //                 return false;
+
+    //             auto propertyList = adoptCF(CFPropertyListCreateWithData(nullptr, data.get(), kCFPropertyListImmutable, nullptr, nullptr));
+    //             if (!propertyList)
+    //                 return false;
+
+    //             auto colorSpace = adoptCF(CGColorSpaceCreateWithPropertyList(propertyList.get()));
+    //             if (!colorSpace)
+    //                 return false;
+
+    //             destinationColorSpace = DestinationColorSpace(colorSpace.get());
+    //             return true;
+    //         }
+    // #endif
+    //         }
+
+    //         ASSERT_NOT_REACHED();
+    //         return false;
+    //     }
+
+#if ENABLE(WEB_CRYPTO)
+    bool read(CryptoKeyOKP::NamedCurve& result)
+    {
+        uint8_t nameTag;
+        if (!read(nameTag))
+            return false;
+        if (nameTag > cryptoKeyOKPOpNameTagMaximumValue)
+            return false;
+
+        switch (static_cast<CryptoKeyOKPOpNameTag>(nameTag)) {
+        case CryptoKeyOKPOpNameTag::X25519:
+            result = CryptoKeyOKP::NamedCurve::X25519;
+            break;
+        case CryptoKeyOKPOpNameTag::ED25519:
+            result = CryptoKeyOKP::NamedCurve::Ed25519;
+            break;
+        }
+
+        return true;
+    }
+
+    bool read(CryptoAlgorithmIdentifier& result)
+    {
+        uint8_t algorithmTag;
+        if (!read(algorithmTag))
+            return false;
+        if (algorithmTag > cryptoAlgorithmIdentifierTagMaximumValue)
+            return false;
+        switch (static_cast<CryptoAlgorithmIdentifierTag>(algorithmTag)) {
+        case CryptoAlgorithmIdentifierTag::RSAES_PKCS1_v1_5:
+            result = CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5;
+            break;
+        case CryptoAlgorithmIdentifierTag::RSASSA_PKCS1_v1_5:
+            result = CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5;
+            break;
+        case CryptoAlgorithmIdentifierTag::RSA_PSS:
+            result = CryptoAlgorithmIdentifier::RSA_PSS;
+            break;
+        case CryptoAlgorithmIdentifierTag::RSA_OAEP:
+            result = CryptoAlgorithmIdentifier::RSA_OAEP;
+            break;
+        case CryptoAlgorithmIdentifierTag::ECDSA:
+            result = CryptoAlgorithmIdentifier::ECDSA;
+            break;
+        case CryptoAlgorithmIdentifierTag::ECDH:
+            result = CryptoAlgorithmIdentifier::ECDH;
+            break;
+        case CryptoAlgorithmIdentifierTag::AES_CTR:
+            result = CryptoAlgorithmIdentifier::AES_CTR;
+            break;
+        case CryptoAlgorithmIdentifierTag::AES_CBC:
+            result = CryptoAlgorithmIdentifier::AES_CBC;
+            break;
+        case CryptoAlgorithmIdentifierTag::AES_GCM:
+            result = CryptoAlgorithmIdentifier::AES_GCM;
+            break;
+        case CryptoAlgorithmIdentifierTag::AES_CFB:
+            result = CryptoAlgorithmIdentifier::AES_CFB;
+            break;
+        case CryptoAlgorithmIdentifierTag::AES_KW:
+            result = CryptoAlgorithmIdentifier::AES_KW;
+            break;
+        case CryptoAlgorithmIdentifierTag::HMAC:
+            result = CryptoAlgorithmIdentifier::HMAC;
+            break;
+        case CryptoAlgorithmIdentifierTag::SHA_1:
+            result = CryptoAlgorithmIdentifier::SHA_1;
+            break;
+        case CryptoAlgorithmIdentifierTag::SHA_224:
+            result = CryptoAlgorithmIdentifier::SHA_224;
+            break;
+        case CryptoAlgorithmIdentifierTag::SHA_256:
+            result = CryptoAlgorithmIdentifier::SHA_256;
+            break;
+        case CryptoAlgorithmIdentifierTag::SHA_384:
+            result = CryptoAlgorithmIdentifier::SHA_384;
+            break;
+        case CryptoAlgorithmIdentifierTag::SHA_512:
+            result = CryptoAlgorithmIdentifier::SHA_512;
+            break;
+        case CryptoAlgorithmIdentifierTag::HKDF:
+            result = CryptoAlgorithmIdentifier::HKDF;
+            break;
+        case CryptoAlgorithmIdentifierTag::PBKDF2:
+            result = CryptoAlgorithmIdentifier::PBKDF2;
+            break;
+        case CryptoAlgorithmIdentifierTag::ED25519:
+            result = CryptoAlgorithmIdentifier::Ed25519;
+            break;
+        }
+        return true;
+    }
+
+    bool read(CryptoKeyClassSubtag& result)
+    {
+        uint8_t tag;
+        if (!read(tag))
+            return false;
+        if (tag > cryptoKeyClassSubtagMaximumValue)
+            return false;
+        result = static_cast<CryptoKeyClassSubtag>(tag);
+        return true;
+    }
+
+    bool read(CryptoKeyUsageTag& result)
+    {
+        uint8_t tag;
+        if (!read(tag))
+            return false;
+        if (tag > cryptoKeyUsageTagMaximumValue)
+            return false;
+        result = static_cast<CryptoKeyUsageTag>(tag);
+        return true;
+    }
+
+    bool read(CryptoKeyAsymmetricTypeSubtag& result)
+    {
+        uint8_t tag;
+        if (!read(tag))
+            return false;
+        if (tag > cryptoKeyAsymmetricTypeSubtagMaximumValue)
+            return false;
+        result = static_cast<CryptoKeyAsymmetricTypeSubtag>(tag);
+        return true;
+    }
+
+    bool readHMACKey(bool extractable, CryptoKeyUsageBitmap usages, RefPtr<CryptoKey>& result)
+    {
+        Vector<uint8_t> keyData;
+        if (!read(keyData))
+            return false;
+        CryptoAlgorithmIdentifier hash;
+        if (!read(hash))
+            return false;
+        result = CryptoKeyHMAC::importRaw(0, hash, WTFMove(keyData), extractable, usages);
+        return true;
+    }
+
+    bool readAESKey(bool extractable, CryptoKeyUsageBitmap usages, RefPtr<CryptoKey>& result)
+    {
+        CryptoAlgorithmIdentifier algorithm;
+        if (!read(algorithm))
+            return false;
+        if (!CryptoKeyAES::isValidAESAlgorithm(algorithm))
+            return false;
+        Vector<uint8_t> keyData;
+        if (!read(keyData))
+            return false;
+        result = CryptoKeyAES::importRaw(algorithm, WTFMove(keyData), extractable, usages);
+        return true;
+    }
+
+    bool readRSAKey(bool extractable, CryptoKeyUsageBitmap usages, RefPtr<CryptoKey>& result)
+    {
+        CryptoAlgorithmIdentifier algorithm;
+        if (!read(algorithm))
+            return false;
+
+        int32_t isRestrictedToHash;
+        CryptoAlgorithmIdentifier hash = CryptoAlgorithmIdentifier::SHA_1;
+        if (!read(isRestrictedToHash))
+            return false;
+        if (isRestrictedToHash && !read(hash))
+            return false;
+
+        CryptoKeyAsymmetricTypeSubtag type;
+        if (!read(type))
+            return false;
+
+        Vector<uint8_t> modulus;
+        if (!read(modulus))
+            return false;
+        Vector<uint8_t> exponent;
+        if (!read(exponent))
+            return false;
+
+        if (type == CryptoKeyAsymmetricTypeSubtag::Public) {
+            auto keyData = CryptoKeyRSAComponents::createPublic(modulus, exponent);
+            auto key = CryptoKeyRSA::create(algorithm, hash, isRestrictedToHash, *keyData, extractable, usages);
+            result = WTFMove(key);
+            return true;
+        }
+
+        Vector<uint8_t> privateExponent;
+        if (!read(privateExponent))
+            return false;
+
+        uint32_t primeCount;
+        if (!read(primeCount))
+            return false;
+
+        if (!primeCount) {
+            auto keyData = CryptoKeyRSAComponents::createPrivate(modulus, exponent, privateExponent);
+            auto key = CryptoKeyRSA::create(algorithm, hash, isRestrictedToHash, *keyData, extractable, usages);
+            result = WTFMove(key);
+            return true;
+        }
+
+        if (primeCount < 2)
+            return false;
+
+        CryptoKeyRSAComponents::PrimeInfo firstPrimeInfo;
+        CryptoKeyRSAComponents::PrimeInfo secondPrimeInfo;
+        Vector<CryptoKeyRSAComponents::PrimeInfo> otherPrimeInfos(primeCount - 2);
+
+        if (!read(firstPrimeInfo.primeFactor))
+            return false;
+        if (!read(firstPrimeInfo.factorCRTExponent))
+            return false;
+        if (!read(secondPrimeInfo.primeFactor))
+            return false;
+        if (!read(secondPrimeInfo.factorCRTExponent))
+            return false;
+        if (!read(secondPrimeInfo.factorCRTCoefficient))
+            return false;
+        for (unsigned i = 2; i < primeCount; ++i) {
+            if (!read(otherPrimeInfos[i].primeFactor))
+                return false;
+            if (!read(otherPrimeInfos[i].factorCRTExponent))
+                return false;
+            if (!read(otherPrimeInfos[i].factorCRTCoefficient))
+                return false;
+        }
+
+        auto keyData = CryptoKeyRSAComponents::createPrivateWithAdditionalData(modulus, exponent, privateExponent, firstPrimeInfo, secondPrimeInfo, otherPrimeInfos);
+        auto key = CryptoKeyRSA::create(algorithm, hash, isRestrictedToHash, *keyData, extractable, usages);
+        result = WTFMove(key);
+        return true;
+    }
+
+    bool readECKey(bool extractable, CryptoKeyUsageBitmap usages, RefPtr<CryptoKey>& result)
+    {
+        CryptoAlgorithmIdentifier algorithm;
+        if (!read(algorithm))
+            return false;
+        if (!CryptoKeyEC::isValidECAlgorithm(algorithm))
+            return false;
+        CachedStringRef curve;
+        if (!readStringData(curve))
+            return false;
+        CryptoKeyAsymmetricTypeSubtag type;
+        if (!read(type))
+            return false;
+        Vector<uint8_t> keyData;
+        if (!read(keyData))
+            return false;
+
+        switch (type) {
+        case CryptoKeyAsymmetricTypeSubtag::Public:
+            result = CryptoKeyEC::importRaw(algorithm, curve->string(), WTFMove(keyData), extractable, usages);
+            break;
+        case CryptoKeyAsymmetricTypeSubtag::Private:
+            result = CryptoKeyEC::importPkcs8(algorithm, curve->string(), WTFMove(keyData), extractable, usages);
+            break;
+        }
+
+        return true;
+    }
+
+    bool readOKPKey(bool extractable, CryptoKeyUsageBitmap usages, RefPtr<CryptoKey>& result)
+    {
+        CryptoAlgorithmIdentifier algorithm;
+        if (!read(algorithm))
+            return false;
+        if (!CryptoKeyOKP::isValidOKPAlgorithm(algorithm))
+            return false;
+        CryptoKeyOKP::NamedCurve namedCurve;
+        if (!read(namedCurve))
+            return false;
+        Vector<uint8_t> keyData;
+        if (!read(keyData))
+            return false;
+
+        result = CryptoKeyOKP::importRaw(algorithm, namedCurve, WTFMove(keyData), extractable, usages);
+        return true;
+    }
+
+    bool readRawKey(CryptoKeyUsageBitmap usages, RefPtr<CryptoKey>& result)
+    {
+        CryptoAlgorithmIdentifier algorithm;
+        if (!read(algorithm))
+            return false;
+        Vector<uint8_t> keyData;
+        if (!read(keyData))
+            return false;
+        result = CryptoKeyRaw::create(algorithm, WTFMove(keyData), usages);
+        return true;
+    }
+
+    bool readCryptoKey(JSValue& cryptoKey)
+    {
+        uint32_t keyFormatVersion;
+        if (!read(keyFormatVersion) || keyFormatVersion > currentKeyFormatVersion)
+            return false;
+
+        int32_t extractable;
+        if (!read(extractable))
+            return false;
+
+        uint32_t usagesCount;
+        if (!read(usagesCount))
+            return false;
+
+        CryptoKeyUsageBitmap usages = 0;
+        for (uint32_t i = 0; i < usagesCount; ++i) {
+            CryptoKeyUsageTag usage;
+            if (!read(usage))
+                return false;
+            switch (usage) {
+            case CryptoKeyUsageTag::Encrypt:
+                usages |= CryptoKeyUsageEncrypt;
+                break;
+            case CryptoKeyUsageTag::Decrypt:
+                usages |= CryptoKeyUsageDecrypt;
+                break;
+            case CryptoKeyUsageTag::Sign:
+                usages |= CryptoKeyUsageSign;
+                break;
+            case CryptoKeyUsageTag::Verify:
+                usages |= CryptoKeyUsageVerify;
+                break;
+            case CryptoKeyUsageTag::DeriveKey:
+                usages |= CryptoKeyUsageDeriveKey;
+                break;
+            case CryptoKeyUsageTag::DeriveBits:
+                usages |= CryptoKeyUsageDeriveBits;
+                break;
+            case CryptoKeyUsageTag::WrapKey:
+                usages |= CryptoKeyUsageWrapKey;
+                break;
+            case CryptoKeyUsageTag::UnwrapKey:
+                usages |= CryptoKeyUsageUnwrapKey;
+                break;
+            }
+        }
+
+        CryptoKeyClassSubtag cryptoKeyClass;
+        if (!read(cryptoKeyClass))
+            return false;
+        RefPtr<CryptoKey> result;
+        switch (cryptoKeyClass) {
+        case CryptoKeyClassSubtag::HMAC:
+            if (!readHMACKey(extractable, usages, result))
+                return false;
+            break;
+        case CryptoKeyClassSubtag::AES:
+            if (!readAESKey(extractable, usages, result))
+                return false;
+            break;
+        case CryptoKeyClassSubtag::RSA:
+            if (!readRSAKey(extractable, usages, result))
+                return false;
+            break;
+        case CryptoKeyClassSubtag::EC:
+            if (!readECKey(extractable, usages, result))
+                return false;
+            break;
+        case CryptoKeyClassSubtag::Raw:
+            if (!readRawKey(usages, result))
+                return false;
+            break;
+        case CryptoKeyClassSubtag::OKP:
+            if (!readOKPKey(extractable, usages, result))
+                return false;
+            break;
+        }
+        cryptoKey = getJSValue(result.get());
+        return true;
+    }
+#endif
+
+    template<class T>
+    JSValue getJSValue(T&& nativeObj)
+    {
+        return toJS(m_lexicalGlobalObject, jsCast<JSDOMGlobalObject*>(m_globalObject), std::forward<T>(nativeObj));
+    }
+
+    // template<class T>
+    // JSValue readDOMPoint()
+    // {
+    //     double x;
+    //     if (!read(x))
+    //         return {};
+    //     double y;
+    //     if (!read(y))
+    //         return {};
+    //     double z;
+    //     if (!read(z))
+    //         return {};
+    //     double w;
+    //     if (!read(w))
+    //         return {};
+
+    //     return toJSNewlyCreated(m_lexicalGlobalObject, jsCast<JSDOMGlobalObject*>(m_globalObject), T::create(x, y, z, w));
+    // }
+
+    // template<class T>
+    // JSValue readDOMMatrix()
+    // {
+    //     uint8_t is2D;
+    //     if (!read(is2D))
+    //         return {};
+
+    //     if (is2D) {
+    //         double m11;
+    //         if (!read(m11))
+    //             return {};
+    //         double m12;
+    //         if (!read(m12))
+    //             return {};
+    //         double m21;
+    //         if (!read(m21))
+    //             return {};
+    //         double m22;
+    //         if (!read(m22))
+    //             return {};
+    //         double m41;
+    //         if (!read(m41))
+    //             return {};
+    //         double m42;
+    //         if (!read(m42))
+    //             return {};
+
+    //         TransformationMatrix matrix(m11, m12, m21, m22, m41, m42);
+    //         return toJSNewlyCreated(m_lexicalGlobalObject, jsCast<JSDOMGlobalObject*>(m_globalObject), T::create(WTFMove(matrix), DOMMatrixReadOnly::Is2D::Yes));
+    //     } else {
+    //         double m11;
+    //         if (!read(m11))
+    //             return {};
+    //         double m12;
+    //         if (!read(m12))
+    //             return {};
+    //         double m13;
+    //         if (!read(m13))
+    //             return {};
+    //         double m14;
+    //         if (!read(m14))
+    //             return {};
+    //         double m21;
+    //         if (!read(m21))
+    //             return {};
+    //         double m22;
+    //         if (!read(m22))
+    //             return {};
+    //         double m23;
+    //         if (!read(m23))
+    //             return {};
+    //         double m24;
+    //         if (!read(m24))
+    //             return {};
+    //         double m31;
+    //         if (!read(m31))
+    //             return {};
+    //         double m32;
+    //         if (!read(m32))
+    //             return {};
+    //         double m33;
+    //         if (!read(m33))
+    //             return {};
+    //         double m34;
+    //         if (!read(m34))
+    //             return {};
+    //         double m41;
+    //         if (!read(m41))
+    //             return {};
+    //         double m42;
+    //         if (!read(m42))
+    //             return {};
+    //         double m43;
+    //         if (!read(m43))
+    //             return {};
+    //         double m44;
+    //         if (!read(m44))
+    //             return {};
+
+    //         TransformationMatrix matrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+    //         return toJSNewlyCreated(m_lexicalGlobalObject, jsCast<JSDOMGlobalObject*>(m_globalObject), T::create(WTFMove(matrix), DOMMatrixReadOnly::Is2D::No));
+    //     }
+    // }
+
+    // template<class T>
+    // JSValue readDOMRect()
+    // {
+    //     double x;
+    //     if (!read(x))
+    //         return {};
+    //     double y;
+    //     if (!read(y))
+    //         return {};
+    //     double width;
+    //     if (!read(width))
+    //         return {};
+    //     double height;
+    //     if (!read(height))
+    //         return {};
+
+    //     return toJSNewlyCreated(m_lexicalGlobalObject, jsCast<JSDOMGlobalObject*>(m_globalObject), T::create(x, y, width, height));
+    // }
+
+    // std::optional<DOMPointInit> readDOMPointInit()
+    // {
+    //     DOMPointInit point;
+    //     if (!read(point.x))
+    //         return std::nullopt;
+    //     if (!read(point.y))
+    //         return std::nullopt;
+    //     if (!read(point.z))
+    //         return std::nullopt;
+    //     if (!read(point.w))
+    //         return std::nullopt;
+
+    //     return point;
+    // }
+
+    // JSValue readDOMQuad()
+    // {
+    //     auto p1 = readDOMPointInit();
+    //     if (!p1)
+    //         return JSValue();
+    //     auto p2 = readDOMPointInit();
+    //     if (!p2)
+    //         return JSValue();
+    //     auto p3 = readDOMPointInit();
+    //     if (!p3)
+    //         return JSValue();
+    //     auto p4 = readDOMPointInit();
+    //     if (!p4)
+    //         return JSValue();
+
+    //     return toJSNewlyCreated(m_lexicalGlobalObject, jsCast<JSDOMGlobalObject*>(m_globalObject), DOMQuad::create(p1.value(), p2.value(), p3.value(), p4.value()));
+    // }
+
+    // JSValue readTransferredImageBitmap()
+    // {
+    //     uint32_t index;
+    //     bool indexSuccessfullyRead = read(index);
+    //     if (!indexSuccessfullyRead || index >= m_backingStores.size()) {
+    //         fail();
+    //         return JSValue();
+    //     }
+
+    //     if (!m_imageBitmaps[index]) {
+    //         m_backingStores.at(index)->connect(*executionContext(m_lexicalGlobalObject));
+    //         m_imageBitmaps[index] = ImageBitmap::create(WTFMove(m_backingStores.at(index)));
+    //     }
+
+    //     auto bitmap = m_imageBitmaps[index].get();
+    //     return getJSValue(bitmap);
+    // }
+
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    JSValue readOffscreenCanvas()
+    {
+        uint32_t index;
+        bool indexSuccessfullyRead = read(index);
+        if (!indexSuccessfullyRead || index >= m_detachedOffscreenCanvases.size()) {
+            fail();
+            return JSValue();
+        }
+
+        if (!m_offscreenCanvases[index])
+            m_offscreenCanvases[index] = OffscreenCanvas::create(*executionContext(m_lexicalGlobalObject), WTFMove(m_detachedOffscreenCanvases.at(index)));
+
+        auto offscreenCanvas = m_offscreenCanvases[index].get();
+        return getJSValue(offscreenCanvas);
+    }
+#endif
+
+#if ENABLE(WEB_RTC)
+    JSValue readRTCCertificate()
+    {
+        double expires;
+        if (!read(expires)) {
+            fail();
+            return JSValue();
+        }
+        CachedStringRef certificate;
+        if (!readStringData(certificate)) {
+            fail();
+            return JSValue();
+        }
+        CachedStringRef origin;
+        if (!readStringData(origin)) {
+            fail();
+            return JSValue();
+        }
+        CachedStringRef keyedMaterial;
+        if (!readStringData(keyedMaterial)) {
+            fail();
+            return JSValue();
+        }
+        unsigned size = 0;
+        if (!read(size))
+            return JSValue();
+
+        Vector<RTCCertificate::DtlsFingerprint> fingerprints;
+        fingerprints.reserveInitialCapacity(size);
+        for (unsigned i = 0; i < size; i++) {
+            CachedStringRef algorithm;
+            if (!readStringData(algorithm))
+                return JSValue();
+            CachedStringRef value;
+            if (!readStringData(value))
+                return JSValue();
+            fingerprints.uncheckedAppend(RTCCertificate::DtlsFingerprint { algorithm->string(), value->string() });
+        }
+
+        if (!m_canCreateDOMObject)
+            return constructEmptyObject(m_lexicalGlobalObject, m_globalObject->objectPrototype());
+
+        auto rtcCertificate = RTCCertificate::create(SecurityOrigin::createFromString(origin->string()), expires, WTFMove(fingerprints), certificate->takeString(), keyedMaterial->takeString());
+        return toJSNewlyCreated(m_lexicalGlobalObject, jsCast<JSDOMGlobalObject*>(m_globalObject), WTFMove(rtcCertificate));
+    }
+
+    JSValue readRTCDataChannel()
+    {
+        uint32_t index;
+        bool indexSuccessfullyRead = read(index);
+        if (!indexSuccessfullyRead || index >= m_detachedRTCDataChannels.size()) {
+            fail();
+            return JSValue();
+        }
+
+        if (!m_rtcDataChannels[index]) {
+            auto detachedChannel = WTFMove(m_detachedRTCDataChannels.at(index));
+            m_rtcDataChannels[index] = RTCDataChannel::create(*executionContext(m_lexicalGlobalObject), detachedChannel->identifier, WTFMove(detachedChannel->label), WTFMove(detachedChannel->options), detachedChannel->state);
+        }
+
+        return getJSValue(m_rtcDataChannels[index].get());
+    }
+#endif
+
+#if ENABLE(WEB_CODECS)
+    JSValue readWebCodecsEncodedVideoChunk()
+    {
+        uint32_t index;
+        bool indexSuccessfullyRead = read(index);
+        if (!indexSuccessfullyRead || index >= m_serializedVideoChunks.size()) {
+            fail();
+            return JSValue();
+        }
+
+        if (!m_videoChunks[index])
+            m_videoChunks[index] = WebCodecsEncodedVideoChunk::create(m_serializedVideoChunks.at(index).releaseNonNull());
+
+        return getJSValue(m_videoChunks[index].get());
+    }
+    JSValue readWebCodecsVideoFrame()
+    {
+        uint32_t index;
+        bool indexSuccessfullyRead = read(index);
+        if (!indexSuccessfullyRead || index >= m_serializedVideoFrames.size()) {
+            fail();
+            return JSValue();
+        }
+
+        if (!m_videoFrames[index])
+            m_videoFrames[index] = WebCodecsVideoFrame::create(*executionContext(m_lexicalGlobalObject), WTFMove(m_serializedVideoFrames.at(index)));
+
+        return getJSValue(m_videoFrames[index].get());
+    }
+#endif
+
+    // JSValue readImageBitmap()
+    // {
+    //     uint8_t serializationState;
+    //     int32_t logicalWidth;
+    //     int32_t logicalHeight;
+    //     double resolutionScale;
+    //     auto colorSpace = DestinationColorSpace::SRGB();
+    //     RefPtr<ArrayBuffer> arrayBuffer;
+
+    //     if (!read(serializationState) || !read(logicalWidth) || !read(logicalHeight) || !read(resolutionScale) || (m_version > 8 && !read(colorSpace)) || !readArrayBufferImpl<uint32_t>(arrayBuffer)) {
+    //         fail();
+    //         return JSValue();
+    //     }
+
+    //     auto logicalSize = IntSize(logicalWidth, logicalHeight);
+    //     auto imageDataSize = logicalSize;
+    //     imageDataSize.scale(resolutionScale);
+
+    //     auto buffer = ImageBitmap::createImageBuffer(*executionContext(m_lexicalGlobalObject), logicalSize, RenderingMode::Unaccelerated, colorSpace, resolutionScale);
+    //     if (!buffer) {
+    //         fail();
+    //         return JSValue();
+    //     }
+
+    //     PixelBufferFormat format { AlphaPremultiplication::Premultiplied, PixelFormat::RGBA8, colorSpace };
+    //     auto pixelBuffer = ByteArrayPixelBuffer::tryCreate(format, imageDataSize, arrayBuffer.releaseNonNull());
+    //     if (!pixelBuffer) {
+    //         fail();
+    //         return JSValue();
+    //     }
+
+    //     buffer->putPixelBuffer(*pixelBuffer, { IntPoint::zero(), logicalSize });
+
+    //     auto bitmap = ImageBitmap::create(ImageBitmapBacking(WTFMove(buffer), OptionSet<SerializationState>::fromRaw(serializationState)));
+    //     return getJSValue(bitmap);
+    // }
+
+    JSValue readDOMException()
+    {
+        CachedStringRef message;
+        if (!readStringData(message))
+            return JSValue();
+        CachedStringRef name;
+        if (!readStringData(name))
+            return JSValue();
+        auto exception = DOMException::create(message->string(), name->string());
+        return getJSValue(exception);
+    }
+
+    JSValue readBigInt()
+    {
+        uint8_t sign = 0;
+        if (!read(sign))
+            return JSValue();
+        uint32_t lengthInUint64 = 0;
+        if (!read(lengthInUint64))
+            return JSValue();
+
+        if (!lengthInUint64) {
+#if USE(BIGINT32)
+            return jsBigInt32(0);
+#else
+            JSBigInt* bigInt = JSBigInt::tryCreateZero(m_lexicalGlobalObject->vm());
+            if (UNLIKELY(!bigInt)) {
+                fail();
+                return JSValue();
+            }
+            m_gcBuffer.appendWithCrashOnOverflow(bigInt);
+            return bigInt;
+#endif
+        }
+
+#if USE(BIGINT32)
+        static_assert(sizeof(JSBigInt::Digit) == sizeof(uint64_t));
+        if (lengthInUint64 == 1) {
+            uint64_t digit64 = 0;
+            if (!read(digit64))
+                return JSValue();
+            if (sign) {
+                if (digit64 <= static_cast<uint64_t>(-static_cast<int64_t>(INT32_MIN)))
+                    return jsBigInt32(static_cast<int32_t>(-static_cast<int64_t>(digit64)));
+            } else {
+                if (digit64 <= INT32_MAX)
+                    return jsBigInt32(static_cast<int32_t>(digit64));
+            }
+            ASSERT(digit64 != 0);
+            JSBigInt* bigInt = JSBigInt::tryCreateWithLength(m_lexicalGlobalObject->vm(), 1);
+            if (!bigInt) {
+                fail();
+                return JSValue();
+            }
+            bigInt->setDigit(0, digit64);
+            bigInt->setSign(sign);
+            bigInt = bigInt->tryRightTrim(m_lexicalGlobalObject->vm());
+            if (!bigInt) {
+                fail();
+                return JSValue();
+            }
+            m_gcBuffer.appendWithCrashOnOverflow(bigInt);
+            return tryConvertToBigInt32(bigInt);
+        }
+#endif
+        JSBigInt* bigInt = nullptr;
+        if constexpr (sizeof(JSBigInt::Digit) == sizeof(uint64_t)) {
+            bigInt = JSBigInt::tryCreateWithLength(m_lexicalGlobalObject->vm(), lengthInUint64);
+            if (!bigInt) {
+                fail();
+                return JSValue();
+            }
+            for (uint32_t index = 0; index < lengthInUint64; ++index) {
+                uint64_t digit64 = 0;
+                if (!read(digit64))
+                    return JSValue();
+                bigInt->setDigit(index, digit64);
+            }
+        } else {
+            ASSERT(sizeof(JSBigInt::Digit) == sizeof(uint32_t));
+            bigInt = JSBigInt::tryCreateWithLength(m_lexicalGlobalObject->vm(), lengthInUint64 * 2);
+            if (!bigInt) {
+                fail();
+                return JSValue();
+            }
+            for (uint32_t index = 0; index < lengthInUint64; ++index) {
+                uint64_t digit64 = 0;
+                if (!read(digit64))
+                    return JSValue();
+                bigInt->setDigit(index * 2, static_cast<uint32_t>(digit64));
+                bigInt->setDigit(index * 2 + 1, static_cast<uint32_t>(digit64 >> 32));
+            }
+        }
+        bigInt->setSign(sign);
+        bigInt = bigInt->tryRightTrim(m_lexicalGlobalObject->vm());
+        if (!bigInt) {
+            fail();
+            return JSValue();
+        }
+        m_gcBuffer.appendWithCrashOnOverflow(bigInt);
+        return tryConvertToBigInt32(bigInt);
+    }
+
+    JSValue readTerminal()
+    {
+        SerializationTag tag = readTag();
+
+        // read bun types
+        if (auto value = StructuredCloneableDeserialize::fromTagDeserialize(tag, m_lexicalGlobalObject, m_ptr, m_end)) {
+            JSValue deserialized = JSValue::decode(value.value());
+            if (deserialized.isEmpty()) {
+                fail();
+                return JSValue();
+            }
+            return deserialized;
+        }
+
+        switch (tag) {
+        case UndefinedTag:
+            return jsUndefined();
+        case NullTag:
+            return jsNull();
+        case IntTag: {
+            int32_t i;
+            if (!read(i))
+                return JSValue();
+            return jsNumber(i);
+        }
+        case ZeroTag:
+            return jsNumber(0);
+        case OneTag:
+            return jsNumber(1);
+        case FalseTag:
+            return jsBoolean(false);
+        case TrueTag:
+            return jsBoolean(true);
+        case FalseObjectTag: {
+            BooleanObject* obj = BooleanObject::create(m_lexicalGlobalObject->vm(), m_globalObject->booleanObjectStructure());
+            obj->setInternalValue(m_lexicalGlobalObject->vm(), jsBoolean(false));
+            m_gcBuffer.appendWithCrashOnOverflow(obj);
+            return obj;
+        }
+        case TrueObjectTag: {
+            BooleanObject* obj = BooleanObject::create(m_lexicalGlobalObject->vm(), m_globalObject->booleanObjectStructure());
+            obj->setInternalValue(m_lexicalGlobalObject->vm(), jsBoolean(true));
+            m_gcBuffer.appendWithCrashOnOverflow(obj);
+            return obj;
+        }
+        case DoubleTag: {
+            double d;
+            if (!read(d))
+                return JSValue();
+            return jsNumber(purifyNaN(d));
+        }
+        case BigIntTag:
+            return readBigInt();
+        case NumberObjectTag: {
+            double d;
+            if (!read(d))
+                return JSValue();
+            NumberObject* obj = constructNumber(m_globalObject, jsNumber(purifyNaN(d)));
+            m_gcBuffer.appendWithCrashOnOverflow(obj);
+            return obj;
+        }
+        case BigIntObjectTag: {
+            JSValue bigInt = readBigInt();
+            if (!bigInt)
+                return JSValue();
+            ASSERT(bigInt.isBigInt());
+            BigIntObject* obj = BigIntObject::create(m_lexicalGlobalObject->vm(), m_globalObject, bigInt);
+            m_gcBuffer.appendWithCrashOnOverflow(obj);
+            return obj;
+        }
+        case DateTag: {
+            double d;
+            if (!read(d))
+                return JSValue();
+            return DateInstance::create(m_lexicalGlobalObject->vm(), m_globalObject->dateStructure(), d);
+        }
+        // case FileTag: {
+        //     RefPtr<File> file;
+        //     if (!readFile(file))
+        //         return JSValue();
+        //     if (!m_canCreateDOMObject)
+        //         return jsNull();
+        //     return toJS(m_lexicalGlobalObject, jsCast<JSDOMGlobalObject*>(m_globalObject), file.get());
+        // }
+        // case FileListTag: {
+        //     unsigned length = 0;
+        //     if (!read(length))
+        //         return JSValue();
+        //     ASSERT(m_globalObject->inherits<JSDOMGlobalObject>());
+        //     Vector<Ref<File>> files;
+        //     for (unsigned i = 0; i < length; i++) {
+        //         RefPtr<File> file;
+        //         if (!readFile(file))
+        //             return JSValue();
+        //         if (m_canCreateDOMObject)
+        //             files.append(file.releaseNonNull());
+        //     }
+        //     if (!m_canCreateDOMObject)
+        //         return jsNull();
+        //     return getJSValue(FileList::create(WTFMove(files)).get());
+        // }
+        // case ImageDataTag: {
+        //     uint32_t width;
+        //     if (!read(width))
+        //         return JSValue();
+        //     uint32_t height;
+        //     if (!read(height))
+        //         return JSValue();
+        //     uint32_t length;
+        //     if (!read(length))
+        //         return JSValue();
+        //     if (static_cast<uint32_t>(m_end - m_ptr) < length) {
+        //         fail();
+        //         return JSValue();
+        //     }
+        //     auto bufferStart = m_ptr;
+        //     m_ptr += length;
+
+        //     auto resultColorSpace = PredefinedColorSpace::SRGB;
+        //     if (m_version > 7) {
+        //         if (!read(resultColorSpace))
+        //             return JSValue();
+        //     }
+
+        //     if (length && (IntSize(width, height).area() * 4) != length) {
+        //         fail();
+        //         return JSValue();
+        //     }
+
+        //     if (!m_isDOMGlobalObject)
+        //         return jsNull();
+
+        //     auto result = ImageData::createUninitialized(width, height, resultColorSpace);
+        //     if (result.hasException()) {
+        //         fail();
+        //         return JSValue();
+        //     }
+        //     if (length)
+        //         memcpy(result.returnValue()->data().data(), bufferStart, length);
+        //     else
+        //         result.returnValue()->data().zeroFill();
+        //     return getJSValue(result.releaseReturnValue());
+        // }
+        // case BlobTag: {
+        //     CachedStringRef url;
+        //     if (!readStringData(url))
+        //         return JSValue();
+        //     CachedStringRef type;
+        //     if (!readStringData(type))
+        //         return JSValue();
+        //     uint64_t size = 0;
+        //     if (!read(size))
+        //         return JSValue();
+        //     uint64_t memoryCost = 0;
+        //     if (m_version >= 11 && !read(memoryCost))
+        //         return JSValue();
+        //     if (!m_canCreateDOMObject)
+        //         return jsNull();
+        //     return getJSValue(Blob::deserialize(executionContext(m_lexicalGlobalObject), URL { url->string() }, type->string(), size, memoryCost, blobFilePathForBlobURL(url->string())).get());
+        // }
+        case StringTag: {
+            CachedStringRef cachedString;
+            if (!readStringData(cachedString))
+                return JSValue();
+            return cachedString->jsString(m_lexicalGlobalObject);
+        }
+        case EmptyStringTag:
+            return jsEmptyString(m_lexicalGlobalObject->vm());
+        case StringObjectTag: {
+            CachedStringRef cachedString;
+            if (!readStringData(cachedString))
+                return JSValue();
+            StringObject* obj = constructString(m_lexicalGlobalObject->vm(), m_globalObject, cachedString->jsString(m_lexicalGlobalObject));
+            m_gcBuffer.appendWithCrashOnOverflow(obj);
+            return obj;
+        }
+        case EmptyStringObjectTag: {
+            VM& vm = m_lexicalGlobalObject->vm();
+            StringObject* obj = constructString(vm, m_globalObject, jsEmptyString(vm));
+            m_gcBuffer.appendWithCrashOnOverflow(obj);
+            return obj;
+        }
+        case RegExpTag: {
+            CachedStringRef pattern;
+            if (!readStringData(pattern))
+                return JSValue();
+            CachedStringRef flags;
+            if (!readStringData(flags))
+                return JSValue();
+            auto reFlags = Yarr::parseFlags(flags->string());
+            ASSERT(reFlags.has_value());
+            VM& vm = m_lexicalGlobalObject->vm();
+            RegExp* regExp = RegExp::create(vm, pattern->string(), reFlags.value());
+            return RegExpObject::create(vm, m_globalObject->regExpStructure(), regExp);
+        }
+        case ObjectReferenceTag: {
+            unsigned index = 0;
+            if (!readConstantPoolIndex(m_gcBuffer, index)) {
+                fail();
+                return JSValue();
+            }
+            return m_gcBuffer.at(index);
+        }
+        // case MessagePortReferenceTag: {
+        //     uint32_t index;
+        //     bool indexSuccessfullyRead = read(index);
+        //     if (!indexSuccessfullyRead || index >= m_messagePorts.size()) {
+        //         fail();
+        //         return JSValue();
+        //     }
+        //     return getJSValue(m_messagePorts[index].get());
+        // }
+#if ENABLE(WEBASSEMBLY)
+        case WasmModuleTag: {
+            if (m_version >= 12) {
+                // https://webassembly.github.io/spec/web-api/index.html#serialization
+                CachedStringRef agentClusterID;
+                bool agentClusterIDSuccessfullyRead = readStringData(agentClusterID);
+                if (!agentClusterIDSuccessfullyRead || agentClusterID->string() != agentClusterIDFromGlobalObject(*m_globalObject)) {
+                    fail();
+                    return JSValue();
+                }
+            }
+            uint32_t index;
+            bool indexSuccessfullyRead = read(index);
+            if (!indexSuccessfullyRead || !m_wasmModules || index >= m_wasmModules->size()) {
+                fail();
+                return JSValue();
+            }
+            auto scope = DECLARE_THROW_SCOPE(m_lexicalGlobalObject->vm());
+            JSValue result = JSC::JSWebAssemblyModule::createStub(m_lexicalGlobalObject->vm(), m_lexicalGlobalObject, m_globalObject->webAssemblyModuleStructure(), m_wasmModules->at(index));
+            // Since we are cloning a JSWebAssemblyModule, it's impossible for that
+            // module to not have been a valid module. Therefore, createStub should
+            // not throw.
+            scope.releaseAssertNoException();
+            m_gcBuffer.appendWithCrashOnOverflow(result);
+            return result;
+        }
+        case WasmMemoryTag: {
+            if (m_version >= 12) {
+                CachedStringRef agentClusterID;
+                bool agentClusterIDSuccessfullyRead = readStringData(agentClusterID);
+                if (!agentClusterIDSuccessfullyRead || agentClusterID->string() != agentClusterIDFromGlobalObject(*m_globalObject)) {
+                    fail();
+                    return JSValue();
+                }
+            }
+            uint32_t index;
+            bool indexSuccessfullyRead = read(index);
+            if (!indexSuccessfullyRead || !m_wasmMemoryHandles || index >= m_wasmMemoryHandles->size() || !JSC::Options::useSharedArrayBuffer()) {
+                fail();
+                return JSValue();
+            }
+
+            auto& vm = m_lexicalGlobalObject->vm();
+            auto scope = DECLARE_THROW_SCOPE(vm);
+            JSWebAssemblyMemory* result = JSC::JSWebAssemblyMemory::tryCreate(m_lexicalGlobalObject, vm, m_globalObject->webAssemblyMemoryStructure());
+            // Since we are cloning a JSWebAssemblyMemory, it's impossible for that
+            // module to not have been a valid module. Therefore, createStub should
+            // not throw.
+            scope.releaseAssertNoException();
+
+            RefPtr<Wasm::Memory> memory;
+            auto handler = [&vm, result](Wasm::Memory::GrowSuccess, PageCount oldPageCount, PageCount newPageCount) { result->growSuccessCallback(vm, oldPageCount, newPageCount); };
+            if (RefPtr<SharedArrayBufferContents> contents = m_wasmMemoryHandles->at(index)) {
+                if (!contents->memoryHandle()) {
+                    fail();
+                    return JSValue();
+                }
+                memory = Wasm::Memory::create(contents.releaseNonNull(), WTFMove(handler));
+            } else {
+                // zero size & max-size.
+                memory = Wasm::Memory::createZeroSized(JSC::MemorySharingMode::Shared, WTFMove(handler));
+            }
+
+            result->adopt(memory.releaseNonNull());
+            m_gcBuffer.appendWithCrashOnOverflow(result);
+            return result;
+        }
+#endif
+        case ArrayBufferTag: {
+            RefPtr<ArrayBuffer> arrayBuffer;
+            if (!readArrayBuffer(arrayBuffer)) {
+                fail();
+                return JSValue();
+            }
+            Structure* structure = m_globalObject->arrayBufferStructure(arrayBuffer->sharingMode());
+            // A crazy RuntimeFlags mismatch could mean that we are not equipped to handle shared
+            // array buffers while the sender is. In that case, we would see a null structure here.
+            if (UNLIKELY(!structure)) {
+                fail();
+                return JSValue();
+            }
+            JSValue result = JSArrayBuffer::create(m_lexicalGlobalObject->vm(), structure, WTFMove(arrayBuffer));
+            m_gcBuffer.appendWithCrashOnOverflow(result);
+            return result;
+        }
+        case ResizableArrayBufferTag: {
+            RefPtr<ArrayBuffer> arrayBuffer;
+            if (!readResizableNonSharedArrayBuffer(arrayBuffer)) {
+                fail();
+                return JSValue();
+            }
+            Structure* structure = m_globalObject->arrayBufferStructure(arrayBuffer->sharingMode());
+            // A crazy RuntimeFlags mismatch could mean that we are not equipped to handle shared
+            // array buffers while the sender is. In that case, we would see a null structure here.
+            if (UNLIKELY(!structure)) {
+                fail();
+                return JSValue();
+            }
+            JSValue result = JSArrayBuffer::create(m_lexicalGlobalObject->vm(), structure, WTFMove(arrayBuffer));
+            m_gcBuffer.appendWithCrashOnOverflow(result);
+            return result;
+        }
+        case ArrayBufferTransferTag: {
+            uint32_t index;
+            bool indexSuccessfullyRead = read(index);
+            if (!indexSuccessfullyRead || index >= m_arrayBuffers.size()) {
+                fail();
+                return JSValue();
+            }
+
+            if (!m_arrayBuffers[index])
+                m_arrayBuffers[index] = ArrayBuffer::create(WTFMove(m_arrayBufferContents->at(index)));
+
+            return getJSValue(m_arrayBuffers[index].get());
+        }
+        case SharedArrayBufferTag: {
+            // https://html.spec.whatwg.org/multipage/structured-data.html#structureddeserialize
+            uint32_t index = UINT_MAX;
+            bool indexSuccessfullyRead = read(index);
+            if (!indexSuccessfullyRead || !m_sharedBuffers || index >= m_sharedBuffers->size() || !JSC::Options::useSharedArrayBuffer()) {
+                fail();
+                return JSValue();
+            }
+
+            RELEASE_ASSERT(m_sharedBuffers->at(index));
+            auto buffer = ArrayBuffer::create(WTFMove(m_sharedBuffers->at(index)));
+            JSValue result = getJSValue(buffer.get());
+            m_gcBuffer.appendWithCrashOnOverflow(result);
+            return result;
+        }
+        case ArrayBufferViewTag: {
+            JSValue arrayBufferView;
+            if (!readArrayBufferView(m_lexicalGlobalObject->vm(), arrayBufferView)) {
+                fail();
+                return JSValue();
+            }
+            m_gcBuffer.appendWithCrashOnOverflow(arrayBufferView);
+            return arrayBufferView;
+        }
+#if ENABLE(WEB_CRYPTO)
+        case CryptoKeyTag: {
+            Vector<uint8_t> wrappedKey;
+            if (!read(wrappedKey)) {
+                fail();
+                return JSValue();
+            }
+            Vector<uint8_t> serializedKey;
+            if (!unwrapCryptoKey(m_lexicalGlobalObject, wrappedKey, serializedKey)) {
+                fail();
+                return JSValue();
+            }
+            JSValue cryptoKey;
+            // Vector<RefPtr<MessagePort>> dummyMessagePorts;
+            // CloneDeserializer rawKeyDeserializer(m_lexicalGlobalObject, m_globalObject, dummyMessagePorts, nullptr, {}, serializedKey);
+            CloneDeserializer rawKeyDeserializer(m_lexicalGlobalObject, m_globalObject, nullptr, serializedKey);
+            if (!rawKeyDeserializer.readCryptoKey(cryptoKey)) {
+                fail();
+                return JSValue();
+            }
+            m_gcBuffer.appendWithCrashOnOverflow(cryptoKey);
+            return cryptoKey;
+        }
+#endif
+        // case DOMPointReadOnlyTag:
+        //     return readDOMPoint<DOMPointReadOnly>();
+        // case DOMPointTag:
+        //     return readDOMPoint<DOMPoint>();
+        // case DOMRectReadOnlyTag:
+        //     return readDOMRect<DOMRectReadOnly>();
+        // case DOMRectTag:
+        //     return readDOMRect<DOMRect>();
+        // case DOMMatrixReadOnlyTag:
+        //     return readDOMMatrix<DOMMatrixReadOnly>();
+        // case DOMMatrixTag:
+        //     return readDOMMatrix<DOMMatrix>();
+        // case DOMQuadTag:
+        //     return readDOMQuad();
+        // case ImageBitmapTransferTag:
+        //     return readTransferredImageBitmap();
+#if ENABLE(WEB_RTC)
+        case RTCCertificateTag:
+            return readRTCCertificate();
+
+#endif
+            // case ImageBitmapTag:
+            //     return readImageBitmap();
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+        case OffscreenCanvasTransferTag:
+            return readOffscreenCanvas();
+#endif
+#if ENABLE(WEB_RTC)
+        case RTCDataChannelTransferTag:
+            return readRTCDataChannel();
+#endif
+#if ENABLE(WEB_CODECS)
+        case WebCodecsEncodedVideoChunkTag:
+            return readWebCodecsEncodedVideoChunk();
+        case WebCodecsVideoFrameTag:
+            return readWebCodecsVideoFrame();
+#endif
+        case DOMExceptionTag:
+            return readDOMException();
+
+        default:
+            m_ptr--; // Push the tag back
+            return JSValue();
+        }
+    }
+
+    template<SerializationTag Tag>
+    bool consumeCollectionDataTerminationIfPossible()
+    {
+        if (readTag() == Tag)
+            return true;
+        m_ptr--;
+        return false;
+    }
+
+    JSGlobalObject* const m_globalObject;
+    const bool m_isDOMGlobalObject;
+    const bool m_canCreateDOMObject;
+    const uint8_t* m_ptr;
+    const uint8_t* const m_end;
+    unsigned m_version;
+    Vector<CachedString> m_constantPool;
+    // const Vector<RefPtr<MessagePort>>& m_messagePorts;
+    ArrayBufferContentsArray* m_arrayBufferContents;
+    Vector<RefPtr<JSC::ArrayBuffer>> m_arrayBuffers;
+    Vector<String> m_blobURLs;
+    Vector<String> m_blobFilePaths;
+    ArrayBufferContentsArray* m_sharedBuffers;
+    // Vector<std::optional<ImageBitmapBacking>> m_backingStores;
+    // Vector<RefPtr<ImageBitmap>> m_imageBitmaps;
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    Vector<std::unique_ptr<DetachedOffscreenCanvas>> m_detachedOffscreenCanvases;
+    Vector<RefPtr<OffscreenCanvas>> m_offscreenCanvases;
+#endif
+#if ENABLE(WEB_RTC)
+    Vector<std::unique_ptr<DetachedRTCDataChannel>> m_detachedRTCDataChannels;
+    Vector<RefPtr<RTCDataChannel>> m_rtcDataChannels;
+#endif
+#if ENABLE(WEBASSEMBLY)
+    WasmModuleArray* const m_wasmModules;
+    WasmMemoryHandleArray* const m_wasmMemoryHandles;
+#endif
+#if ENABLE(WEB_CODECS)
+    Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>> m_serializedVideoChunks;
+    Vector<RefPtr<WebCodecsEncodedVideoChunk>> m_videoChunks;
+    Vector<WebCodecsVideoFrameData> m_serializedVideoFrames;
+    Vector<RefPtr<WebCodecsVideoFrame>> m_videoFrames;
+#endif
+
+    String blobFilePathForBlobURL(const String& blobURL)
+    {
+        size_t i = 0;
+        for (; i < m_blobURLs.size(); ++i) {
+            if (m_blobURLs[i] == blobURL)
+                break;
+        }
+
+        return i < m_blobURLs.size() ? m_blobFilePaths[i] : String();
+    }
+};
+
+DeserializationResult CloneDeserializer::deserialize()
+{
+    VM& vm = m_lexicalGlobalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    Vector<uint32_t, 16> indexStack;
+    Vector<Identifier, 16> propertyNameStack;
+    MarkedVector<JSObject*, 32> outputObjectStack;
+    MarkedVector<JSValue, 4> mapKeyStack;
+    MarkedVector<JSMap*, 4> mapStack;
+    MarkedVector<JSSet*, 4> setStack;
+    Vector<WalkerState, 16> stateStack;
+    WalkerState state = StateUnknown;
+    JSValue outValue;
+
+    while (1) {
+        switch (state) {
+        arrayStartState:
+        case ArrayStartState: {
+            uint32_t length;
+            if (!read(length)) {
+                fail();
+                goto error;
+            }
+            JSArray* outArray = constructEmptyArray(m_globalObject, static_cast<JSC::ArrayAllocationProfile*>(nullptr), length);
+            if (UNLIKELY(scope.exception()))
+                goto error;
+            m_gcBuffer.appendWithCrashOnOverflow(outArray);
+            outputObjectStack.append(outArray);
+        }
+        arrayStartVisitMember:
+            FALLTHROUGH;
+        case ArrayStartVisitMember: {
+            uint32_t index;
+            if (!read(index)) {
+                fail();
+                goto error;
+            }
+            if (index == TerminatorTag) {
+                JSObject* outArray = outputObjectStack.last();
+                outValue = outArray;
+                outputObjectStack.removeLast();
+                break;
+            } else if (index == NonIndexPropertiesTag) {
+                goto objectStartVisitMember;
+            }
+
+            if (JSValue terminal = readTerminal()) {
+                putProperty(outputObjectStack.last(), index, terminal);
+                goto arrayStartVisitMember;
+            }
+            if (m_failed)
+                goto error;
+            indexStack.append(index);
+            stateStack.append(ArrayEndVisitMember);
+            goto stateUnknown;
+        }
+        case ArrayEndVisitMember: {
+            JSObject* outArray = outputObjectStack.last();
+            putProperty(outArray, indexStack.last(), outValue);
+            indexStack.removeLast();
+            goto arrayStartVisitMember;
+        }
+        objectStartState:
+        case ObjectStartState: {
+            if (outputObjectStack.size() > maximumFilterRecursion)
+                return std::make_pair(JSValue(), SerializationReturnCode::StackOverflowError);
+            JSObject* outObject = constructEmptyObject(m_lexicalGlobalObject, m_globalObject->objectPrototype());
+            m_gcBuffer.appendWithCrashOnOverflow(outObject);
+            outputObjectStack.append(outObject);
+        }
+        objectStartVisitMember:
+            FALLTHROUGH;
+        case ObjectStartVisitMember: {
+            CachedStringRef cachedString;
+            bool wasTerminator = false;
+            if (!readStringData(cachedString, wasTerminator)) {
+                if (!wasTerminator)
+                    goto error;
+
+                JSObject* outObject = outputObjectStack.last();
+                outValue = outObject;
+                outputObjectStack.removeLast();
+                break;
+            }
+
+            if (JSValue terminal = readTerminal()) {
+                putProperty(outputObjectStack.last(), Identifier::fromString(vm, cachedString->string()), terminal);
+                goto objectStartVisitMember;
+            }
+            stateStack.append(ObjectEndVisitMember);
+            propertyNameStack.append(Identifier::fromString(vm, cachedString->string()));
+            goto stateUnknown;
+        }
+        case ObjectEndVisitMember: {
+            putProperty(outputObjectStack.last(), propertyNameStack.last(), outValue);
+            propertyNameStack.removeLast();
+            goto objectStartVisitMember;
+        }
+        mapObjectStartState : {
+            if (outputObjectStack.size() > maximumFilterRecursion)
+                return std::make_pair(JSValue(), SerializationReturnCode::StackOverflowError);
+            JSMap* map = JSMap::create(m_lexicalGlobalObject->vm(), m_globalObject->mapStructure());
+            m_gcBuffer.appendWithCrashOnOverflow(map);
+            outputObjectStack.append(map);
+            mapStack.append(map);
+            goto mapDataStartVisitEntry;
+        }
+        mapDataStartVisitEntry:
+        case MapDataStartVisitEntry: {
+            if (consumeCollectionDataTerminationIfPossible<NonMapPropertiesTag>()) {
+                mapStack.removeLast();
+                goto objectStartVisitMember;
+            }
+            stateStack.append(MapDataEndVisitKey);
+            goto stateUnknown;
+        }
+        case MapDataEndVisitKey: {
+            mapKeyStack.append(outValue);
+            stateStack.append(MapDataEndVisitValue);
+            goto stateUnknown;
+        }
+        case MapDataEndVisitValue: {
+            mapStack.last()->set(m_lexicalGlobalObject, mapKeyStack.last(), outValue);
+            mapKeyStack.removeLast();
+            goto mapDataStartVisitEntry;
+        }
+
+        setObjectStartState : {
+            if (outputObjectStack.size() > maximumFilterRecursion)
+                return std::make_pair(JSValue(), SerializationReturnCode::StackOverflowError);
+            JSSet* set = JSSet::create(m_lexicalGlobalObject->vm(), m_globalObject->setStructure());
+            m_gcBuffer.appendWithCrashOnOverflow(set);
+            outputObjectStack.append(set);
+            setStack.append(set);
+            goto setDataStartVisitEntry;
+        }
+        setDataStartVisitEntry:
+        case SetDataStartVisitEntry: {
+            if (consumeCollectionDataTerminationIfPossible<NonSetPropertiesTag>()) {
+                setStack.removeLast();
+                goto objectStartVisitMember;
+            }
+            stateStack.append(SetDataEndVisitKey);
+            goto stateUnknown;
+        }
+        case SetDataEndVisitKey: {
+            JSSet* set = setStack.last();
+            set->add(m_lexicalGlobalObject, outValue);
+            goto setDataStartVisitEntry;
+        }
+
+        stateUnknown:
+        case StateUnknown:
+            if (JSValue terminal = readTerminal()) {
+                outValue = terminal;
+                break;
+            }
+            SerializationTag tag = readTag();
+            if (tag == ArrayTag)
+                goto arrayStartState;
+            if (tag == ObjectTag)
+                goto objectStartState;
+            if (tag == MapObjectTag)
+                goto mapObjectStartState;
+            if (tag == SetObjectTag)
+                goto setObjectStartState;
+            goto error;
+        }
+        if (stateStack.isEmpty())
+            break;
+
+        state = stateStack.last();
+        stateStack.removeLast();
+    }
+    ASSERT(outValue);
+    ASSERT(!m_failed);
+    return std::make_pair(outValue, SerializationReturnCode::SuccessfullyCompleted);
+error:
+    fail();
+    return std::make_pair(JSValue(), SerializationReturnCode::ValidationError);
+}
+
+SerializedScriptValue::~SerializedScriptValue() = default;
+
+SerializedScriptValue::SerializedScriptValue(Vector<uint8_t>&& buffer, std::unique_ptr<ArrayBufferContentsArray>&& arrayBufferContentsArray
+#if ENABLE(WEB_RTC)
+    ,
+    Vector<std::unique_ptr<DetachedRTCDataChannel>>&& detachedRTCDataChannels
+#endif
+#if ENABLE(WEB_CODECS)
+    ,
+    Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>&& serializedVideoChunks, Vector<WebCodecsVideoFrameData>&& serializedVideoFrames
+#endif
+    )
+    : m_data(WTFMove(buffer))
+    , m_arrayBufferContentsArray(WTFMove(arrayBufferContentsArray))
+#if ENABLE(WEB_RTC)
+    , m_detachedRTCDataChannels(WTFMove(detachedRTCDataChannels))
+#endif
+#if ENABLE(WEB_CODECS)
+    , m_serializedVideoChunks(WTFMove(serializedVideoChunks))
+    , m_serializedVideoFrames(WTFMove(serializedVideoFrames))
+#endif
+{
+    m_memoryCost = computeMemoryCost();
+}
+
+// SerializedScriptValue::SerializedScriptValue(Vector<uint8_t>&& buffer, Vector<URLKeepingBlobAlive>&& blobHandles, std::unique_ptr<ArrayBufferContentsArray> arrayBufferContentsArray, std::unique_ptr<ArrayBufferContentsArray> sharedBufferContentsArray, Vector<std::optional<ImageBitmapBacking>>&& backingStores
+// #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+//     ,
+//     Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& detachedOffscreenCanvases
+// #endif
+// #if ENABLE(WEB_RTC)
+//     ,
+//     Vector<std::unique_ptr<DetachedRTCDataChannel>>&& detachedRTCDataChannels
+// #endif
+// #if ENABLE(WEBASSEMBLY)
+//     ,
+//     std::unique_ptr<WasmModuleArray> wasmModulesArray, std::unique_ptr<WasmMemoryHandleArray> wasmMemoryHandlesArray
+// #endif
+// #if ENABLE(WEB_CODECS)
+//     ,
+//     Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>&& serializedVideoChunks, Vector<WebCodecsVideoFrameData>&& serializedVideoFrames
+// #endif
+//     )
+//     : m_data(WTFMove(buffer))
+//     , m_arrayBufferContentsArray(WTFMove(arrayBufferContentsArray))
+//     , m_sharedBufferContentsArray(WTFMove(sharedBufferContentsArray))
+//     , m_backingStores(WTFMove(backingStores))
+// #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+//     , m_detachedOffscreenCanvases(WTFMove(detachedOffscreenCanvases))
+// #endif
+// #if ENABLE(WEB_RTC)
+//     , m_detachedRTCDataChannels(WTFMove(detachedRTCDataChannels))
+// #endif
+// #if ENABLE(WEBASSEMBLY)
+//     , m_wasmModulesArray(WTFMove(wasmModulesArray))
+//     , m_wasmMemoryHandlesArray(WTFMove(wasmMemoryHandlesArray))
+// #endif
+// #if ENABLE(WEB_CODECS)
+//     , m_serializedVideoChunks(WTFMove(serializedVideoChunks))
+//     , m_serializedVideoFrames(WTFMove(serializedVideoFrames))
+// #endif
+//     , m_blobHandles(crossThreadCopy(WTFMove(blobHandles)))
+// {
+//     m_memoryCost = computeMemoryCost();
+// }
+
+SerializedScriptValue::SerializedScriptValue(Vector<uint8_t>&& buffer, std::unique_ptr<ArrayBufferContentsArray> arrayBufferContentsArray, std::unique_ptr<ArrayBufferContentsArray> sharedBufferContentsArray
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    ,
+    Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& detachedOffscreenCanvases
+#endif
+#if ENABLE(WEB_RTC)
+    ,
+    Vector<std::unique_ptr<DetachedRTCDataChannel>>&& detachedRTCDataChannels
+#endif
+#if ENABLE(WEBASSEMBLY)
+    ,
+    std::unique_ptr<WasmModuleArray> wasmModulesArray, std::unique_ptr<WasmMemoryHandleArray> wasmMemoryHandlesArray
+#endif
+#if ENABLE(WEB_CODECS)
+    ,
+    Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>&& serializedVideoChunks, Vector<WebCodecsVideoFrameData>&& serializedVideoFrames
+#endif
+    )
+    : m_data(WTFMove(buffer))
+    , m_arrayBufferContentsArray(WTFMove(arrayBufferContentsArray))
+    , m_sharedBufferContentsArray(WTFMove(sharedBufferContentsArray))
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    , m_detachedOffscreenCanvases(WTFMove(detachedOffscreenCanvases))
+#endif
+#if ENABLE(WEB_RTC)
+    , m_detachedRTCDataChannels(WTFMove(detachedRTCDataChannels))
+#endif
+#if ENABLE(WEBASSEMBLY)
+    , m_wasmModulesArray(WTFMove(wasmModulesArray))
+    , m_wasmMemoryHandlesArray(WTFMove(wasmMemoryHandlesArray))
+#endif
+#if ENABLE(WEB_CODECS)
+    , m_serializedVideoChunks(WTFMove(serializedVideoChunks))
+    , m_serializedVideoFrames(WTFMove(serializedVideoFrames))
+#endif
+{
+    m_memoryCost = computeMemoryCost();
+}
+
+size_t SerializedScriptValue::computeMemoryCost() const
+{
+    size_t cost = m_data.size();
+
+    if (m_arrayBufferContentsArray) {
+        for (auto& content : *m_arrayBufferContentsArray)
+            cost += content.sizeInBytes();
+    }
+
+    if (m_sharedBufferContentsArray) {
+        for (auto& content : *m_sharedBufferContentsArray)
+            cost += content.sizeInBytes();
+    }
+
+    // for (auto& backingStore : m_backingStores) {
+    //     if (auto buffer = backingStore ? backingStore->buffer() : nullptr)
+    //         cost += buffer->memoryCost();
+    // }
+
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    for (auto& canvas : m_detachedOffscreenCanvases) {
+        if (canvas)
+            cost += canvas->memoryCost();
+    }
+#endif
+#if ENABLE(WEB_RTC)
+    for (auto& channel : m_detachedRTCDataChannels) {
+        if (channel)
+            cost += channel->memoryCost();
+    }
+#endif
+#if ENABLE(WEBASSEMBLY)
+    // We are not supporting WebAssembly Module memory estimation yet.
+    if (m_wasmMemoryHandlesArray) {
+        for (auto& content : *m_wasmMemoryHandlesArray)
+            cost += content->sizeInBytes(std::memory_order_relaxed);
+    }
+#endif
+#if ENABLE(WEB_CODECS)
+    for (auto& chunk : m_serializedVideoChunks) {
+        if (chunk)
+            cost += chunk->memoryCost();
+    }
+    for (auto& frame : m_serializedVideoFrames)
+        cost += frame.memoryCost();
+#endif
+
+    // for (auto& handle : m_blobHandles)
+    //     cost += handle.url().string().sizeInBytes();
+
+    return cost;
+}
+
+static ExceptionOr<std::unique_ptr<ArrayBufferContentsArray>> transferArrayBuffers(VM& vm, const Vector<RefPtr<JSC::ArrayBuffer>>& arrayBuffers)
+{
+    if (arrayBuffers.isEmpty())
+        return nullptr;
+
+    auto contents = makeUnique<ArrayBufferContentsArray>(arrayBuffers.size());
+
+    HashSet<JSC::ArrayBuffer*> visited;
+    for (size_t arrayBufferIndex = 0; arrayBufferIndex < arrayBuffers.size(); arrayBufferIndex++) {
+        if (visited.contains(arrayBuffers[arrayBufferIndex].get()))
+            continue;
+        visited.add(arrayBuffers[arrayBufferIndex].get());
+
+        bool result = arrayBuffers[arrayBufferIndex]->transferTo(vm, contents->at(arrayBufferIndex));
+        if (!result)
+            return Exception { TypeError };
+    }
+
+    return contents;
+}
+
+static void maybeThrowExceptionIfSerializationFailed(JSGlobalObject& lexicalGlobalObject, SerializationReturnCode code)
+{
+    auto& vm = lexicalGlobalObject.vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    switch (code) {
+    case SerializationReturnCode::SuccessfullyCompleted:
+        break;
+    case SerializationReturnCode::StackOverflowError:
+        throwException(&lexicalGlobalObject, scope, createStackOverflowError(&lexicalGlobalObject));
+        break;
+    case SerializationReturnCode::ValidationError:
+        throwTypeError(&lexicalGlobalObject, scope, "Unable to deserialize data."_s);
+        break;
+    case SerializationReturnCode::DataCloneError:
+        throwDataCloneError(lexicalGlobalObject, scope);
+        break;
+    case SerializationReturnCode::ExistingExceptionError:
+    case SerializationReturnCode::UnspecifiedError:
+        break;
+    case SerializationReturnCode::InterruptedExecutionError:
+        ASSERT_NOT_REACHED();
+    }
+}
+
+static Exception exceptionForSerializationFailure(SerializationReturnCode code)
+{
+    ASSERT(code != SerializationReturnCode::SuccessfullyCompleted);
+
+    switch (code) {
+    case SerializationReturnCode::StackOverflowError:
+        return Exception { StackOverflowError };
+    case SerializationReturnCode::ValidationError:
+        return Exception { TypeError };
+    case SerializationReturnCode::DataCloneError:
+        return Exception { DataCloneError };
+    case SerializationReturnCode::ExistingExceptionError:
+        return Exception { ExistingExceptionError };
+    case SerializationReturnCode::UnspecifiedError:
+        return Exception { TypeError };
+    case SerializationReturnCode::SuccessfullyCompleted:
+    case SerializationReturnCode::InterruptedExecutionError:
+        ASSERT_NOT_REACHED();
+        return Exception { TypeError };
+    }
+    ASSERT_NOT_REACHED();
+    return Exception { TypeError };
+}
+
+// static bool containsDuplicates(const Vector<RefPtr<ImageBitmap>>& imageBitmaps)
+// {
+//     HashSet<ImageBitmap*> visited;
+//     for (auto& imageBitmap : imageBitmaps) {
+//         if (!visited.add(imageBitmap.get()))
+//             return true;
+//     }
+//     return false;
+// }
+
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+static bool canOffscreenCanvasesDetach(const Vector<RefPtr<OffscreenCanvas>>& offscreenCanvases)
+{
+    HashSet<OffscreenCanvas*> visited;
+    for (auto& offscreenCanvas : offscreenCanvases) {
+        if (!offscreenCanvas->canDetach())
+            return false;
+        // Check the return value of add, we should not encounter duplicates.
+        if (!visited.add(offscreenCanvas.get()))
+            return false;
+    }
+    return true;
+}
+#endif
+
+#if ENABLE(WEB_RTC)
+static bool canDetachRTCDataChannels(const Vector<Ref<RTCDataChannel>>& channels)
+{
+    HashSet<RTCDataChannel*> visited;
+    for (auto& channel : channels) {
+        if (!channel->canDetach())
+            return false;
+        // Check the return value of add, we should not encounter duplicates.
+        if (!visited.add(channel.ptr()))
+            return false;
+    }
+    return true;
+}
+#endif
+
+RefPtr<SerializedScriptValue> SerializedScriptValue::create(JSC::JSGlobalObject& globalObject, JSC::JSValue value, SerializationForStorage forStorage, SerializationErrorMode throwExceptions, SerializationContext serializationContext)
+{
+    // Vector<RefPtr<MessagePort>> dummyPorts;
+    // auto result = create(globalObject, value, {}, dummyPorts, forStorage, throwExceptions, serializationContext);
+    auto result = create(globalObject, value, {}, forStorage, throwExceptions, serializationContext);
+    if (result.hasException())
+        return nullptr;
+    return result.releaseReturnValue();
+}
+
+// ExceptionOr<Ref<SerializedScriptValue>> SerializedScriptValue::create(JSGlobalObject& globalObject, JSValue value, Vector<JSC::Strong<JSC::JSObject>>&& transferList, Vector<RefPtr<MessagePort>>& messagePorts, SerializationForStorage forStorage, SerializationContext serializationContext)
+// {
+//     return create(globalObject, value, WTFMove(transferList), messagePorts, forStorage, SerializationErrorMode::NonThrowing, serializationContext);
+// }
+
+ExceptionOr<Ref<SerializedScriptValue>> SerializedScriptValue::create(JSGlobalObject& globalObject, JSValue value, Vector<JSC::Strong<JSC::JSObject>>&& transferList, SerializationForStorage forStorage, SerializationContext serializationContext)
+{
+    return create(globalObject, value, WTFMove(transferList), forStorage, SerializationErrorMode::Throwing, serializationContext);
+}
+
+// ExceptionOr<Ref<SerializedScriptValue>> SerializedScriptValue::create(JSGlobalObject& lexicalGlobalObject, JSValue value, Vector<JSC::Strong<JSC::JSObject>>&& transferList, Vector<RefPtr<MessagePort>>& messagePorts, SerializationForStorage forStorage, SerializationErrorMode throwExceptions, SerializationContext context)
+ExceptionOr<Ref<SerializedScriptValue>> SerializedScriptValue::create(JSGlobalObject& lexicalGlobalObject, JSValue value, Vector<JSC::Strong<JSC::JSObject>>&& transferList, SerializationForStorage forStorage, SerializationErrorMode throwExceptions, SerializationContext context)
+{
+    VM& vm = lexicalGlobalObject.vm();
+    Vector<RefPtr<JSC::ArrayBuffer>> arrayBuffers;
+    // Vector<RefPtr<ImageBitmap>> imageBitmaps;
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    Vector<RefPtr<OffscreenCanvas>> offscreenCanvases;
+#endif
+#if ENABLE(WEB_RTC)
+    Vector<Ref<RTCDataChannel>> dataChannels;
+#endif
+#if ENABLE(WEB_CODECS)
+    Vector<Ref<WebCodecsVideoFrame>> transferredVideoFrames;
+#endif
+    HashSet<JSC::JSObject*> uniqueTransferables;
+    for (auto& transferable : transferList) {
+        if (!uniqueTransferables.add(transferable.get()).isNewEntry)
+            return Exception { DataCloneError, "Duplicate transferable for structured clone"_s };
+
+        if (auto arrayBuffer = toPossiblySharedArrayBuffer(vm, transferable.get())) {
+            if (arrayBuffer->isDetached() || arrayBuffer->isShared())
+                return Exception { DataCloneError };
+            if (arrayBuffer->isLocked()) {
+                auto scope = DECLARE_THROW_SCOPE(vm);
+                throwVMTypeError(&lexicalGlobalObject, scope, errorMessageForTransfer(arrayBuffer));
+                return Exception { ExistingExceptionError };
+            }
+            arrayBuffers.append(WTFMove(arrayBuffer));
+            continue;
+        }
+        // if (auto port = JSMessagePort::toWrapped(vm, transferable.get())) {
+        //     if (port->isDetached())
+        //         return Exception { DataCloneError, "MessagePort is detached"_s };
+        //     messagePorts.append(WTFMove(port));
+        //     continue;
+        // }
+
+        // if (auto imageBitmap = JSImageBitmap::toWrapped(vm, transferable.get())) {
+        //     if (imageBitmap->isDetached())
+        //         return Exception { DataCloneError };
+        //     if (!imageBitmap->originClean())
+        //         return Exception { DataCloneError };
+
+        //     imageBitmaps.append(WTFMove(imageBitmap));
+        //     continue;
+        // }
+
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+        if (auto offscreenCanvas = JSOffscreenCanvas::toWrapped(vm, transferable.get())) {
+            offscreenCanvases.append(WTFMove(offscreenCanvas));
+            continue;
+        }
+#endif
+
+#if ENABLE(WEB_RTC)
+        if (auto channel = JSRTCDataChannel::toWrapped(vm, transferable.get())) {
+            dataChannels.append(*channel);
+            continue;
+        }
+#endif
+
+#if ENABLE(WEB_CODECS)
+        if (auto videoFrame = JSWebCodecsVideoFrame::toWrapped(vm, transferable.get())) {
+            if (videoFrame->isDetached())
+                return Exception { DataCloneError };
+            transferredVideoFrames.append(*videoFrame);
+            continue;
+        }
+#endif
+        return Exception { DataCloneError };
+    }
+
+    // if (containsDuplicates(imageBitmaps))
+    //     return Exception { DataCloneError };
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    if (!canOffscreenCanvasesDetach(offscreenCanvases))
+        return Exception { InvalidStateError };
+#endif
+#if ENABLE(WEB_RTC)
+    if (!canDetachRTCDataChannels(dataChannels))
+        return Exception { DataCloneError };
+#endif
+
+    Vector<uint8_t> buffer;
+    // Vector<URLKeepingBlobAlive> blobHandles;
+#if ENABLE(WEBASSEMBLY)
+    WasmModuleArray wasmModules;
+    WasmMemoryHandleArray wasmMemoryHandles;
+#endif
+    std::unique_ptr<ArrayBufferContentsArray> sharedBuffers = makeUnique<ArrayBufferContentsArray>();
+#if ENABLE(WEB_CODECS)
+    Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>> serializedVideoChunks;
+    Vector<RefPtr<WebCodecsVideoFrame>> serializedVideoFrames;
+#endif
+    //     auto code = CloneSerializer::serialize(&lexicalGlobalObject, value, messagePorts, arrayBuffers, imageBitmaps,
+    // #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    //         offscreenCanvases,
+    // #endif
+    // #if ENABLE(WEB_RTC)
+    //         dataChannels,
+    // #endif
+    // #if ENABLE(WEB_CODECS)
+    //         serializedVideoChunks,
+    //         serializedVideoFrames,
+    // #endif
+    // #if ENABLE(WEBASSEMBLY)
+    //         wasmModules,
+    //         wasmMemoryHandles,
+    // #endif
+    //         blobHandles, buffer, context, *sharedBuffers, forStorage);
+
+    auto code = CloneSerializer::serialize(&lexicalGlobalObject, value, arrayBuffers,
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+        offscreenCanvases,
+#endif
+#if ENABLE(WEB_RTC)
+        dataChannels,
+#endif
+#if ENABLE(WEB_CODECS)
+        serializedVideoChunks,
+        serializedVideoFrames,
+#endif
+#if ENABLE(WEBASSEMBLY)
+        wasmModules,
+        wasmMemoryHandles,
+#endif
+        buffer, context, *sharedBuffers, forStorage);
+
+    if (throwExceptions == SerializationErrorMode::Throwing)
+        maybeThrowExceptionIfSerializationFailed(lexicalGlobalObject, code);
+
+    if (code != SerializationReturnCode::SuccessfullyCompleted)
+        return exceptionForSerializationFailure(code);
+
+    auto arrayBufferContentsArray = transferArrayBuffers(vm, arrayBuffers);
+    if (arrayBufferContentsArray.hasException())
+        return arrayBufferContentsArray.releaseException();
+
+        // auto backingStores = ImageBitmap::detachBitmaps(WTFMove(imageBitmaps));
+
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    Vector<std::unique_ptr<DetachedOffscreenCanvas>> detachedCanvases;
+    for (auto offscreenCanvas : offscreenCanvases)
+        detachedCanvases.append(offscreenCanvas->detach());
+#endif
+#if ENABLE(WEB_RTC)
+    Vector<std::unique_ptr<DetachedRTCDataChannel>> detachedRTCDataChannels;
+    for (auto& channel : dataChannels)
+        detachedRTCDataChannels.append(channel->detach());
+#endif
+
+#if ENABLE(WEB_CODECS)
+    auto serializedVideoFrameData = map(serializedVideoFrames, [](auto& frame) -> WebCodecsVideoFrameData { return frame->data(); });
+#endif
+#if ENABLE(WEB_CODECS)
+    for (auto& videoFrame : transferredVideoFrames)
+        videoFrame->close();
+#endif
+
+    //     return adoptRef(*new SerializedScriptValue(WTFMove(buffer), WTFMove(blobHandles), arrayBufferContentsArray.releaseReturnValue(), context == SerializationContext::WorkerPostMessage ? WTFMove(sharedBuffers) : nullptr, WTFMove(backingStores)
+    // #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    //                                                                                                                                                                                                                                 ,
+    //         WTFMove(detachedCanvases)
+    // #endif
+    // #if ENABLE(WEB_RTC)
+    //             ,
+    //         WTFMove(detachedRTCDataChannels)
+    // #endif
+    // #if ENABLE(WEBASSEMBLY)
+    //             ,
+    //         makeUnique<WasmModuleArray>(wasmModules), context == SerializationContext::WorkerPostMessage ? makeUnique<WasmMemoryHandleArray>(wasmMemoryHandles) : nullptr
+    // #endif
+    // #if ENABLE(WEB_CODECS)
+    //         ,
+    //         WTFMove(serializedVideoChunks), WTFMove(serializedVideoFrameData)
+    // #endif
+    //             ));
+    return adoptRef(*new SerializedScriptValue(WTFMove(buffer), arrayBufferContentsArray.releaseReturnValue(), context == SerializationContext::WorkerPostMessage ? WTFMove(sharedBuffers) : nullptr
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+        ,
+        WTFMove(detachedCanvases)
+#endif
+#if ENABLE(WEB_RTC)
+            ,
+        WTFMove(detachedRTCDataChannels)
+#endif
+#if ENABLE(WEBASSEMBLY)
+            ,
+        makeUnique<WasmModuleArray>(wasmModules), context == SerializationContext::WorkerPostMessage ? makeUnique<WasmMemoryHandleArray>(wasmMemoryHandles) : nullptr
+#endif
+#if ENABLE(WEB_CODECS)
+        ,
+        WTFMove(serializedVideoChunks), WTFMove(serializedVideoFrameData)
+#endif
+            ));
+}
+
+RefPtr<SerializedScriptValue> SerializedScriptValue::create(StringView string)
+{
+    Vector<uint8_t> buffer;
+    if (!CloneSerializer::serialize(string, buffer))
+        return nullptr;
+    return adoptRef(*new SerializedScriptValue(WTFMove(buffer)));
+}
+
+RefPtr<SerializedScriptValue> SerializedScriptValue::create(JSContextRef originContext, JSValueRef apiValue, JSValueRef* exception)
+{
+    JSGlobalObject* lexicalGlobalObject = toJS(originContext);
+    VM& vm = lexicalGlobalObject->vm();
+    JSLockHolder locker(vm);
+    auto scope = DECLARE_CATCH_SCOPE(vm);
+
+    JSValue value = toJS(lexicalGlobalObject, apiValue);
+    auto serializedValue = SerializedScriptValue::create(*lexicalGlobalObject, value);
+    if (UNLIKELY(scope.exception())) {
+        if (exception)
+            *exception = toRef(lexicalGlobalObject, scope.exception()->value());
+        scope.clearException();
+        return nullptr;
+    }
+    ASSERT(serializedValue);
+    return serializedValue;
+}
+
+String SerializedScriptValue::toString() const
+{
+    return CloneDeserializer::deserializeString(m_data);
+}
+
+// JSValue SerializedScriptValue::deserialize(JSGlobalObject& lexicalGlobalObject, JSGlobalObject* globalObject, SerializationErrorMode throwExceptions, bool* didFail)
+// {
+//     return deserialize(lexicalGlobalObject, globalObject, {}, throwExceptions, didFail);
+// }
+
+// JSValue SerializedScriptValue::deserialize(JSGlobalObject& lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, SerializationErrorMode throwExceptions, bool* didFail)
+// {
+//     Vector<String> dummyBlobs;
+//     Vector<String> dummyPaths;
+//     return deserialize(lexicalGlobalObject, globalObject, messagePorts, dummyBlobs, dummyPaths, throwExceptions, didFail);
+// }
+
+JSValue SerializedScriptValue::deserialize(JSGlobalObject& lexicalGlobalObject, JSGlobalObject* globalObject, SerializationErrorMode throwExceptions, bool* didFail)
+{
+    Vector<String> dummyBlobs;
+    Vector<String> dummyPaths;
+    return deserialize(lexicalGlobalObject, globalObject, dummyBlobs, dummyPaths, throwExceptions, didFail);
+}
+
+// JSValue SerializedScriptValue::deserialize(JSGlobalObject& lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, const Vector<String>& blobURLs, const Vector<String>& blobFilePaths, SerializationErrorMode throwExceptions, bool* didFail)
+// {
+//     DeserializationResult result = CloneDeserializer::deserialize(&lexicalGlobalObject, globalObject, messagePorts, WTFMove(m_backingStores)
+// #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+//                                                                                                                         ,
+//         WTFMove(m_detachedOffscreenCanvases)
+// #endif
+// #if ENABLE(WEB_RTC)
+//             ,
+//         WTFMove(m_detachedRTCDataChannels)
+// #endif
+//             ,
+//         m_arrayBufferContentsArray.get(), m_data, blobURLs, blobFilePaths, m_sharedBufferContentsArray.get()
+// #if ENABLE(WEBASSEMBLY)
+//                                                                                ,
+//         m_wasmModulesArray.get(), m_wasmMemoryHandlesArray.get()
+// #endif
+// #if ENABLE(WEB_CODECS)
+//                                       ,
+//         WTFMove(m_serializedVideoChunks), WTFMove(m_serializedVideoFrames)
+// #endif
+//     );
+//     if (didFail)
+//         *didFail = result.second != SerializationReturnCode::SuccessfullyCompleted;
+//     if (throwExceptions == SerializationErrorMode::Throwing)
+//         maybeThrowExceptionIfSerializationFailed(lexicalGlobalObject, result.second);
+//     return result.first ? result.first : jsNull();
+// }
+JSValue SerializedScriptValue::deserialize(JSGlobalObject& lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<String>& blobURLs, const Vector<String>& blobFilePaths, SerializationErrorMode throwExceptions, bool* didFail)
+{
+    //     DeserializationResult result = CloneDeserializer::deserialize(&lexicalGlobalObject, globalObject, messagePorts, WTFMove(m_backingStores)
+    // #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    //                                                                                                                         ,
+    //         WTFMove(m_detachedOffscreenCanvases)
+    // #endif
+    // #if ENABLE(WEB_RTC)
+    //             ,
+    //         WTFMove(m_detachedRTCDataChannels)
+    // #endif
+    //             ,
+    //         m_arrayBufferContentsArray.get(), m_data, blobURLs, blobFilePaths, m_sharedBufferContentsArray.get()
+    // #if ENABLE(WEBASSEMBLY)
+    //                                                                                ,
+    //         m_wasmModulesArray.get(), m_wasmMemoryHandlesArray.get()
+    // #endif
+    // #if ENABLE(WEB_CODECS)
+    //                                       ,
+    //         WTFMove(m_serializedVideoChunks), WTFMove(m_serializedVideoFrames)
+    // #endif
+    //     );
+    DeserializationResult result = CloneDeserializer::deserialize(&lexicalGlobalObject, globalObject
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+        ,
+        WTFMove(m_detachedOffscreenCanvases)
+#endif
+#if ENABLE(WEB_RTC)
+            ,
+        WTFMove(m_detachedRTCDataChannels)
+#endif
+            ,
+        m_arrayBufferContentsArray.get(), m_data, blobURLs, blobFilePaths, m_sharedBufferContentsArray.get()
+#if ENABLE(WEBASSEMBLY)
+                                                                               ,
+        m_wasmModulesArray.get(), m_wasmMemoryHandlesArray.get()
+#endif
+#if ENABLE(WEB_CODECS)
+                                      ,
+        WTFMove(m_serializedVideoChunks), WTFMove(m_serializedVideoFrames)
+#endif
+    );
+    if (didFail)
+        *didFail = result.second != SerializationReturnCode::SuccessfullyCompleted;
+    if (throwExceptions == SerializationErrorMode::Throwing)
+        maybeThrowExceptionIfSerializationFailed(lexicalGlobalObject, result.second);
+    return result.first ? result.first : jsNull();
+}
+
+JSValueRef SerializedScriptValue::deserialize(JSContextRef destinationContext, JSValueRef* exception)
+{
+    JSGlobalObject* lexicalGlobalObject = toJS(destinationContext);
+    VM& vm = lexicalGlobalObject->vm();
+    JSLockHolder locker(vm);
+    auto scope = DECLARE_CATCH_SCOPE(vm);
+
+    JSValue value = deserialize(*lexicalGlobalObject, lexicalGlobalObject);
+    if (UNLIKELY(scope.exception())) {
+        if (exception)
+            *exception = toRef(lexicalGlobalObject, scope.exception()->value());
+        scope.clearException();
+        return nullptr;
+    }
+    ASSERT(value);
+    return toRef(lexicalGlobalObject, value);
+}
+
+Ref<SerializedScriptValue> SerializedScriptValue::nullValue()
+{
+    return adoptRef(*new SerializedScriptValue(Vector<uint8_t>()));
+}
+
+uint32_t SerializedScriptValue::wireFormatVersion()
+{
+    return CurrentVersion;
+}
+
+// Vector<String> SerializedScriptValue::blobURLs() const
+// {
+//     return m_blobHandles.map([](auto& handle) {
+//         return handle.url().string().isolatedCopy();
+//     });
+// }
+
+// void SerializedScriptValue::writeBlobsToDiskForIndexedDB(CompletionHandler<void(IDBValue&&)>&& completionHandler)
+// {
+//     ASSERT(isMainThread());
+//     ASSERT(hasBlobURLs());
+
+//     blobRegistry().writeBlobsToTemporaryFilesForIndexedDB(blobURLs(), [completionHandler = WTFMove(completionHandler), this, protectedThis = Ref { *this }](auto&& blobFilePaths) mutable {
+//         ASSERT(isMainThread());
+
+//         if (blobFilePaths.isEmpty()) {
+//             // We should have successfully written blobs to temporary files.
+//             // If we failed, then we can't successfully store this record.
+//             completionHandler({});
+//             return;
+//         }
+
+//         ASSERT(m_blobHandles.size() == blobFilePaths.size());
+
+//         completionHandler({ *this, blobURLs(), blobFilePaths });
+//     });
+// }
+
+// IDBValue SerializedScriptValue::writeBlobsToDiskForIndexedDBSynchronously()
+// {
+//     ASSERT(!isMainThread());
+
+//     BinarySemaphore semaphore;
+//     IDBValue value;
+//     callOnMainThread([this, &semaphore, &value] {
+//         writeBlobsToDiskForIndexedDB([&semaphore, &value](IDBValue&& result) {
+//             ASSERT(isMainThread());
+//             value.setAsIsolatedCopy(result);
+
+//             semaphore.signal();
+//         });
+//     });
+//     semaphore.wait();
+
+//     return value;
+// }
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/SerializedScriptValue.h b/src/bun.js/bindings/webcore/SerializedScriptValue.h
new file mode 100644
index 000000000..6e2cbae86
--- /dev/null
+++ b/src/bun.js/bindings/webcore/SerializedScriptValue.h
@@ -0,0 +1,330 @@
+/*
+ * Copyright (C) 2009, 2013, 2016 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#pragma once
+
+// #include "Blob.h"
+// #include "DetachedRTCDataChannel.h"
+#include "ExceptionOr.h"
+#include <JavaScriptCore/ArrayBuffer.h>
+#include <JavaScriptCore/JSCJSValue.h>
+#include <JavaScriptCore/Strong.h>
+#include <wtf/Forward.h>
+#include <wtf/Function.h>
+#include <wtf/Gigacage.h>
+#include <wtf/text/WTFString.h>
+
+#if ENABLE(WEB_CODECS)
+#include "WebCodecsEncodedVideoChunk.h"
+#include "WebCodecsVideoFrame.h"
+#endif
+
+typedef const struct OpaqueJSContext* JSContextRef;
+typedef const struct OpaqueJSValue* JSValueRef;
+
+#if ENABLE(WEBASSEMBLY)
+namespace JSC {
+namespace Wasm {
+class Module;
+class MemoryHandle;
+}
+}
+#endif
+
+namespace WebCore {
+
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+class DetachedOffscreenCanvas;
+#endif
+// class IDBValue;
+// class MessagePort;
+// class ImageBitmapBacking;
+class CloneSerializer;
+class FragmentedSharedBuffer;
+enum class SerializationReturnCode;
+
+enum class SerializationErrorMode { NonThrowing,
+    Throwing };
+enum class SerializationContext { Default,
+    WorkerPostMessage,
+    WindowPostMessage };
+enum class SerializationForStorage : bool { No,
+    Yes };
+
+using ArrayBufferContentsArray = Vector<JSC::ArrayBufferContents>;
+#if ENABLE(WEBASSEMBLY)
+using WasmModuleArray = Vector<RefPtr<JSC::Wasm::Module>>;
+using WasmMemoryHandleArray = Vector<RefPtr<JSC::SharedArrayBufferContents>>;
+#endif
+
+DECLARE_ALLOCATOR_WITH_HEAP_IDENTIFIER(SerializedScriptValue);
+class SerializedScriptValue : public ThreadSafeRefCounted<SerializedScriptValue> {
+    WTF_MAKE_FAST_ALLOCATED_WITH_HEAP_IDENTIFIER(SerializedScriptValue);
+
+public:
+    static void writeBytesForBun(CloneSerializer*, const uint8_t*, uint32_t);
+
+    // WEBCORE_EXPORT static ExceptionOr<Ref<SerializedScriptValue>> create(JSC::JSGlobalObject&, JSC::JSValue, Vector<JSC::Strong<JSC::JSObject>>&& transfer, Vector<RefPtr<MessagePort>>&, SerializationForStorage = SerializationForStorage::No, SerializationContext = SerializationContext::Default);
+    WEBCORE_EXPORT static ExceptionOr<Ref<SerializedScriptValue>> create(JSC::JSGlobalObject&, JSC::JSValue, Vector<JSC::Strong<JSC::JSObject>>&& transfer, SerializationForStorage = SerializationForStorage::No, SerializationContext = SerializationContext::Default);
+
+    WEBCORE_EXPORT static RefPtr<SerializedScriptValue> create(JSC::JSGlobalObject&, JSC::JSValue, SerializationForStorage = SerializationForStorage::No, SerializationErrorMode = SerializationErrorMode::Throwing, SerializationContext = SerializationContext::Default);
+
+    static RefPtr<SerializedScriptValue> convert(JSC::JSGlobalObject& globalObject, JSC::JSValue value) { return create(globalObject, value, SerializationForStorage::Yes); }
+
+    WEBCORE_EXPORT static RefPtr<SerializedScriptValue> create(StringView);
+
+    static Ref<SerializedScriptValue> nullValue();
+
+    WEBCORE_EXPORT JSC::JSValue deserialize(JSC::JSGlobalObject&, JSC::JSGlobalObject*, SerializationErrorMode = SerializationErrorMode::Throwing, bool* didFail = nullptr);
+    // WEBCORE_EXPORT JSC::JSValue deserialize(JSC::JSGlobalObject&, JSC::JSGlobalObject*, const Vector<RefPtr<MessagePort>>&, SerializationErrorMode = SerializationErrorMode::Throwing, bool* didFail = nullptr);
+
+    // JSC::JSValue deserialize(JSC::JSGlobalObject&, JSC::JSGlobalObject*, const Vector<RefPtr<MessagePort>>&, const Vector<String>& blobURLs, const Vector<String>& blobFilePaths, SerializationErrorMode = SerializationErrorMode::Throwing, bool* didFail = nullptr);
+    JSC::JSValue deserialize(JSC::JSGlobalObject&, JSC::JSGlobalObject*, const Vector<String>& blobURLs, const Vector<String>& blobFilePaths, SerializationErrorMode = SerializationErrorMode::Throwing, bool* didFail = nullptr);
+
+    static uint32_t wireFormatVersion();
+
+    WEBCORE_EXPORT String toString() const;
+
+    // API implementation helpers. These don't expose special behavior for ArrayBuffers or MessagePorts.
+    WEBCORE_EXPORT static RefPtr<SerializedScriptValue> create(JSContextRef, JSValueRef, JSValueRef* exception);
+    WEBCORE_EXPORT JSValueRef deserialize(JSContextRef, JSValueRef* exception);
+
+    // bool hasBlobURLs() const { return !m_blobHandles.isEmpty(); }
+
+    // Vector<String> blobURLs() const;
+    // Vector<URLKeepingBlobAlive> blobHandles() const { return crossThreadCopy(m_blobHandles); }
+    // void writeBlobsToDiskForIndexedDB(CompletionHandler<void(IDBValue&&)>&&);
+    // IDBValue writeBlobsToDiskForIndexedDBSynchronously();
+    static Ref<SerializedScriptValue> createFromWireBytes(Vector<uint8_t>&& data)
+    {
+        return adoptRef(*new SerializedScriptValue(WTFMove(data)));
+    }
+    const Vector<uint8_t>& wireBytes() const { return m_data; }
+
+    template<class Encoder> void encode(Encoder&) const;
+    template<class Decoder> static RefPtr<SerializedScriptValue> decode(Decoder&);
+
+    size_t memoryCost() const { return m_memoryCost; }
+
+    WEBCORE_EXPORT ~SerializedScriptValue();
+
+private:
+    //     static ExceptionOr<Ref<SerializedScriptValue>> create(JSC::JSGlobalObject&, JSC::JSValue, Vector<JSC::Strong<JSC::JSObject>>&& transfer, Vector<RefPtr<MessagePort>>&, SerializationForStorage, SerializationErrorMode, SerializationContext);
+    //     WEBCORE_EXPORT SerializedScriptValue(Vector<unsigned char>&&, std::unique_ptr<ArrayBufferContentsArray>&& = nullptr
+    // #if ENABLE(WEB_RTC)
+    //         ,
+    //         Vector<std::unique_ptr<DetachedRTCDataChannel>>&& = {}
+    // #endif
+    // #if ENABLE(WEB_CODECS)
+    //         ,
+    //         Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>&& = {}, Vector<WebCodecsVideoFrameData>&& = {}
+    // #endif
+    //     );
+    static ExceptionOr<Ref<SerializedScriptValue>> create(JSC::JSGlobalObject&, JSC::JSValue, Vector<JSC::Strong<JSC::JSObject>>&& transfer, SerializationForStorage, SerializationErrorMode, SerializationContext);
+    WEBCORE_EXPORT SerializedScriptValue(Vector<unsigned char>&&, std::unique_ptr<ArrayBufferContentsArray>&& = nullptr
+#if ENABLE(WEB_RTC)
+        ,
+        Vector<std::unique_ptr<DetachedRTCDataChannel>>&& = {}
+#endif
+#if ENABLE(WEB_CODECS)
+        ,
+        Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>&& = {}, Vector<WebCodecsVideoFrameData>&& = {}
+#endif
+    );
+
+    //     SerializedScriptValue(Vector<unsigned char>&&, Vector<URLKeepingBlobAlive>&& blobHandles, std::unique_ptr<ArrayBufferContentsArray>, std::unique_ptr<ArrayBufferContentsArray> sharedBuffers, Vector<std::optional<ImageBitmapBacking>>&& backingStores
+    // #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    //         ,
+    //         Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& = {}
+    // #endif
+    // #if ENABLE(WEB_RTC)
+    //         ,
+    //         Vector<std::unique_ptr<DetachedRTCDataChannel>>&& = {}
+    // #endif
+    // #if ENABLE(WEBASSEMBLY)
+    //         ,
+    //         std::unique_ptr<WasmModuleArray> = nullptr, std::unique_ptr<WasmMemoryHandleArray> = nullptr
+    // #endif
+    // #if ENABLE(WEB_CODECS)
+    //         ,
+    //         Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>&& = {}, Vector<WebCodecsVideoFrameData>&& = {}
+    // #endif
+    //     );
+    SerializedScriptValue(Vector<unsigned char>&&, std::unique_ptr<ArrayBufferContentsArray>, std::unique_ptr<ArrayBufferContentsArray> sharedBuffers
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+        ,
+        Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& = {}
+#endif
+#if ENABLE(WEB_RTC)
+        ,
+        Vector<std::unique_ptr<DetachedRTCDataChannel>>&& = {}
+#endif
+#if ENABLE(WEBASSEMBLY)
+        ,
+        std::unique_ptr<WasmModuleArray> = nullptr, std::unique_ptr<WasmMemoryHandleArray> = nullptr
+#endif
+#if ENABLE(WEB_CODECS)
+        ,
+        Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>&& = {}, Vector<WebCodecsVideoFrameData>&& = {}
+#endif
+    );
+
+    size_t computeMemoryCost() const;
+
+    Vector<unsigned char> m_data;
+    std::unique_ptr<ArrayBufferContentsArray> m_arrayBufferContentsArray;
+    std::unique_ptr<ArrayBufferContentsArray> m_sharedBufferContentsArray;
+    // Vector<std::optional<ImageBitmapBacking>> m_backingStores;
+#if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+    Vector<std::unique_ptr<DetachedOffscreenCanvas>> m_detachedOffscreenCanvases;
+#endif
+#if ENABLE(WEB_RTC)
+    Vector<std::unique_ptr<DetachedRTCDataChannel>> m_detachedRTCDataChannels;
+#endif
+#if ENABLE(WEBASSEMBLY)
+    std::unique_ptr<WasmModuleArray> m_wasmModulesArray;
+    std::unique_ptr<WasmMemoryHandleArray> m_wasmMemoryHandlesArray;
+#endif
+#if ENABLE(WEB_CODECS)
+    Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>> m_serializedVideoChunks;
+    Vector<WebCodecsVideoFrameData> m_serializedVideoFrames;
+#endif
+    // Vector<URLKeepingBlobAlive> m_blobHandles;
+    size_t m_memoryCost { 0 };
+};
+
+template<class Encoder>
+void SerializedScriptValue::encode(Encoder& encoder) const
+{
+    encoder << m_data;
+
+    auto hasArray = m_arrayBufferContentsArray && m_arrayBufferContentsArray->size();
+    encoder << hasArray;
+
+    if (hasArray) {
+        encoder << static_cast<uint64_t>(m_arrayBufferContentsArray->size());
+        for (const auto& arrayBufferContents : *m_arrayBufferContentsArray)
+            encoder << std::span(reinterpret_cast<const uint8_t*>(arrayBufferContents.data()), arrayBufferContents.sizeInBytes());
+    }
+
+#if ENABLE(WEB_RTC)
+    encoder << static_cast<uint64_t>(m_detachedRTCDataChannels.size());
+    for (const auto& channel : m_detachedRTCDataChannels)
+        encoder << *channel;
+#endif
+
+#if ENABLE(WEB_CODECS)
+    encoder << static_cast<uint64_t>(m_serializedVideoChunks.size());
+    for (const auto& videoChunk : m_serializedVideoChunks)
+        encoder << videoChunk->data();
+
+        // FIXME: encode video frames
+#endif
+}
+
+template<class Decoder>
+RefPtr<SerializedScriptValue> SerializedScriptValue::decode(Decoder& decoder)
+{
+    Vector<uint8_t> data;
+    if (!decoder.decode(data))
+        return nullptr;
+
+    bool hasArray;
+    if (!decoder.decode(hasArray))
+        return nullptr;
+
+    std::unique_ptr<ArrayBufferContentsArray> arrayBufferContentsArray;
+    if (hasArray) {
+        uint64_t arrayLength;
+        if (!decoder.decode(arrayLength))
+            return nullptr;
+        ASSERT(arrayLength);
+
+        arrayBufferContentsArray = makeUnique<ArrayBufferContentsArray>();
+        while (arrayLength--) {
+            std::span<const uint8_t> data;
+            if (!decoder.decode(data))
+                return nullptr;
+
+            auto buffer = Gigacage::tryMalloc(Gigacage::Primitive, data.size_bytes());
+            if (!buffer)
+                return nullptr;
+
+            static_assert(sizeof(std::span<const uint8_t>::element_type) == 1);
+            memcpy(buffer, data.data(), data.size_bytes());
+            JSC::ArrayBufferDestructorFunction destructor = ArrayBuffer::primitiveGigacageDestructor();
+            arrayBufferContentsArray->append({ buffer, data.size_bytes(), std::nullopt, WTFMove(destructor) });
+        }
+    }
+
+#if ENABLE(WEB_RTC)
+    uint64_t detachedRTCDataChannelsSize;
+    if (!decoder.decode(detachedRTCDataChannelsSize))
+        return nullptr;
+
+    Vector<std::unique_ptr<DetachedRTCDataChannel>> detachedRTCDataChannels;
+    while (detachedRTCDataChannelsSize--) {
+        std::optional<DetachedRTCDataChannel> detachedRTCDataChannel;
+        decoder >> detachedRTCDataChannel;
+        if (!detachedRTCDataChannel)
+            return nullptr;
+        detachedRTCDataChannels.append(makeUnique<DetachedRTCDataChannel>(WTFMove(*detachedRTCDataChannel)));
+    }
+#endif
+#if ENABLE(WEB_CODECS)
+    uint64_t serializedVideoChunksSize;
+    if (!decoder.decode(serializedVideoChunksSize))
+        return nullptr;
+
+    Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>> serializedVideoChunks;
+    while (serializedVideoChunksSize--) {
+        std::optional<WebCodecsEncodedVideoChunkData> videoChunkData;
+        decoder >> videoChunkData;
+        if (!videoChunkData)
+            return nullptr;
+        serializedVideoChunks.append(WebCodecsEncodedVideoChunkStorage::create(WTFMove(*videoChunkData)));
+    }
+    // FIXME: decode video frames
+    Vector<WebCodecsVideoFrameData> serializedVideoFrames;
+#endif
+
+    return adoptRef(*new SerializedScriptValue(WTFMove(data), WTFMove(arrayBufferContentsArray)
+#if ENABLE(WEB_RTC)
+                                                                  ,
+        WTFMove(detachedRTCDataChannels)
+#endif
+#if ENABLE(WEB_CODECS)
+            ,
+        WTFMove(serializedVideoChunks)
+#endif
+#if ENABLE(WEB_CODECS)
+            ,
+        WTFMove(serializedVideoFrames)
+#endif
+            ));
+}
+
+}
diff --git a/src/bun.js/node/types.zig b/src/bun.js/node/types.zig
index 642039ba5..64bd04e94 100644
--- a/src/bun.js/node/types.zig
+++ b/src/bun.js/node/types.zig
@@ -1024,6 +1024,8 @@ pub const PathOrFileDescriptor = union(Tag) {
 
     pub const Tag = enum { fd, path };
 
+    pub const SerializeTag = enum(u8) { fd, path };
+
     /// This will unref() the path string if it is a PathLike.
     /// Does nothing for file descriptors, **does not** close file descriptors.
     pub fn deinit(this: PathOrFileDescriptor) void {
diff --git a/src/bun.js/scripts/class-definitions.ts b/src/bun.js/scripts/class-definitions.ts
index 59b8f6f05..281cd62c5 100644
--- a/src/bun.js/scripts/class-definitions.ts
+++ b/src/bun.js/scripts/class-definitions.ts
@@ -41,6 +41,7 @@ export interface ClassDefinition {
 
   configurable?: boolean;
   enumerable?: boolean;
+  structuredClone?: boolean | { transferrable: boolean; tag: number };
 }
 
 export interface CustomField {
@@ -58,6 +59,7 @@ export function define(
     estimatedSize = false,
     call = false,
     construct = false,
+    structuredClone = false,
     ...rest
   } = {} as ClassDefinition,
 ): ClassDefinition {
@@ -66,6 +68,7 @@ export function define(
     call,
     construct,
     estimatedSize,
+    structuredClone,
     values,
     klass: Object.fromEntries(Object.entries(klass).sort(([a], [b]) => a.localeCompare(b))),
     proto: Object.fromEntries(Object.entries(proto).sort(([a], [b]) => a.localeCompare(b))),
diff --git a/src/bun.js/scripts/generate-classes.ts b/src/bun.js/scripts/generate-classes.ts
index ff6954753..fb4419642 100644
--- a/src/bun.js/scripts/generate-classes.ts
+++ b/src/bun.js/scripts/generate-classes.ts
@@ -345,6 +345,25 @@ ${
 JSC_DECLARE_CUSTOM_GETTER(js${typeName}Constructor);`
     : ""
 }
+
+${
+  obj.structuredClone
+    ? `extern "C" void ${symbolName(
+        typeName,
+        "onStructuredCloneSerialize",
+      )}(void*, JSC::JSGlobalObject*, void*, void (*) (CloneSerializer*, const uint8_t*, uint32_t));`
+    : ""
+}
+
+${
+  obj.structuredClone
+    ? `extern "C" JSC::EncodedJSValue ${symbolName(
+        typeName,
+        "onStructuredCloneDeserialize",
+      )}(JSC::JSGlobalObject*, const uint8_t*, const uint8_t*);`
+    : ""
+}
+
 ${"finalize" in obj ? `extern "C" void ${classSymbolName(typeName, "finalize")}(void*);` : ""}
 ${obj.call ? `extern "C" JSC_DECLARE_HOST_FUNCTION(${classSymbolName(typeName, "call")});` : ""}
 
@@ -1200,6 +1219,7 @@ function generateZig(
     call = false,
     values = [],
     hasPendingActivity = false,
+    structuredClone = false,
   } = {} as ClassDefinition,
 ) {
   const exports = new Map<string, string>();
@@ -1226,6 +1246,16 @@ function generateZig(
   Object.values(klass).map(a => appendSymbols(exports, name => classSymbolName(typeName, name), a));
   Object.values(proto).map(a => appendSymbols(exports, name => protoSymbolName(typeName, name), a));
 
+  if (structuredClone) {
+    exports.set("onStructuredCloneSerialize", symbolName(typeName, "onStructuredCloneSerialize"));
+
+    if (structuredClone === "transferrable") {
+      exports.set("onStructuredCloneTransfer", symbolName(typeName, "onStructuredCloneTransfer"));
+    }
+
+    exports.set("onStructuredCloneDeserialize", symbolName(typeName, "onStructuredCloneDeserialize"));
+  }
+
   const externs = Object.entries({
     ...proto,
     ...Object.fromEntries((values || []).map(a => [a, { internal: true }])),
@@ -1269,6 +1299,29 @@ function generateZig(
       `;
     }
 
+    if (structuredClone) {
+      output += `
+      if (@TypeOf(${typeName}.onStructuredCloneSerialize) != (fn(*${typeName}, globalThis: *JSC.JSGlobalObject, ctx: *anyopaque, writeBytes: *const fn(*anyopaque, ptr: [*]const u8, len: u32) callconv(.C) void) callconv(.C) void)) {
+        @compileLog("${typeName}.onStructuredCloneSerialize is not a structured clone serialize function");
+      }
+      `;
+
+      if (structuredClone === "transferrable") {
+        exports.set("structuredClone", symbolName(typeName, "onTransferrableStructuredClone"));
+        output += `
+        if (@TypeOf(${typeName}.onStructuredCloneTransfer) != (fn(*${typeName}, globalThis: *JSC.JSGlobalObject, ctx: *anyopaque, write: *const fn(*anyopaque, ptr: [*]const u8, len: usize) callconv(.C) void) callconv(.C) void)) {
+          @compileLog("${typeName}.onStructuredCloneTransfer is not a structured clone transfer function");
+        }
+        `;
+      }
+
+      output += `
+      if (@TypeOf(${typeName}.onStructuredCloneDeserialize) != (fn(globalThis: *JSC.JSGlobalObject, ptr: [*]u8, end: [*]u8) callconv(.C) JSC.JSValue)) {
+        @compileLog("${typeName}.onStructuredCloneDeserialize is not a structured clone deserialize function");
+      }
+      `;
+    }
+
     if (construct && !noConstructor) {
       output += `
         if (@TypeOf(${typeName}.constructor) != (fn(*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*${typeName})) {
@@ -1532,6 +1585,7 @@ namespace Zig {
 
 #include "JSDOMWrapper.h"
 #include <wtf/NeverDestroyed.h>
+#include "SerializedScriptValue.h"
 `,
 
   `
@@ -1543,11 +1597,6 @@ using namespace JSC;
 `,
 ];
 
-const GENERATED_CLASSES_FOOTER = `
-}
-
-`;
-
 const GENERATED_CLASSES_IMPL_HEADER = `
 // GENERATED CODE - DO NOT MODIFY BY HAND
 // Generated by make codegen
@@ -1676,6 +1725,84 @@ function writeAndUnlink(path, content) {
   return Bun.write(path, content);
 }
 
+const GENERATED_CLASSES_FOOTER = `
+
+class StructuredCloneableSerialize {
+  public:
+
+    void (*cppWriteBytes)(CloneSerializer*, const uint8_t*, uint32_t);
+
+    std::function<void(void*, JSC::JSGlobalObject*, void*, void (*)(CloneSerializer*, const uint8_t*, uint32_t))> zigFunction;
+
+    uint8_t tag;
+
+    // the type from zig
+    void* impl;
+
+    static std::optional<StructuredCloneableSerialize> fromJS(JSC::JSValue);
+    void write(CloneSerializer* serializer, JSC::JSGlobalObject* globalObject)
+    {
+      zigFunction(impl, globalObject, serializer, cppWriteBytes);
+    }
+};
+
+class StructuredCloneableDeserialize {
+  public:
+    static std::optional<JSC::EncodedJSValue> fromTagDeserialize(uint8_t tag, JSC::JSGlobalObject*, const uint8_t*, const uint8_t*);
+};
+
+}
+
+`;
+
+function writeCppSerializers() {
+  var output = ``;
+
+  var structuredClonable = classes
+    .filter(a => a.structuredClone)
+    .sort((a, b) => a.structuredClone.tag < b.structuredClone.tag);
+
+  function fromJSForEachClass(klass) {
+    return `
+    if (auto* result = jsDynamicCast<${className(klass.name)}*>(value)) {
+      return StructuredCloneableSerialize { .cppWriteBytes = SerializedScriptValue::writeBytesForBun, .zigFunction = ${symbolName(
+        klass.name,
+        "onStructuredCloneSerialize",
+      )}, .tag = ${klass.structuredClone.tag}, .impl = result->wrapped() };
+    }
+    `;
+  }
+
+  function fromTagDeserializeForEachClass(klass) {
+    return `
+    if (tag == ${klass.structuredClone.tag}) {
+      return ${symbolName(klass.name, "onStructuredCloneDeserialize")}(globalObject, ptr, end);
+    }
+    `;
+  }
+
+  output += `  
+  std::optional<StructuredCloneableSerialize> StructuredCloneableSerialize::fromJS(JSC::JSValue value)
+  {
+    ${structuredClonable.map(fromJSForEachClass).join("\n").trim()}
+    return std::nullopt;
+  }
+  `;
+
+  output += `
+  std::optional<JSC::EncodedJSValue> StructuredCloneableDeserialize::fromTagDeserialize(uint8_t tag, JSC::JSGlobalObject* globalObject, const uint8_t* ptr, const uint8_t* end)
+  {
+    ${structuredClonable.map(fromTagDeserializeForEachClass).join("\n").trim()}
+    return std::nullopt;
+  }
+  `;
+
+  for (let klass of classes) {
+  }
+
+  return output;
+}
+
 await writeAndUnlink(`${import.meta.dir}/../bindings/generated_classes.zig`, [
   ZIG_GENERATED_CLASSES_HEADER,
 
@@ -1699,6 +1826,7 @@ await writeAndUnlink(`${import.meta.dir}/../bindings/ZigGeneratedClasses.h`, [
 await writeAndUnlink(`${import.meta.dir}/../bindings/ZigGeneratedClasses.cpp`, [
   GENERATED_CLASSES_IMPL_HEADER,
   ...classes.map(a => generateImpl(a.name, a)),
+  writeCppSerializers(classes),
   GENERATED_CLASSES_IMPL_FOOTER,
 ]);
 await writeAndUnlink(
diff --git a/src/bun.js/test/expect.zig b/src/bun.js/test/expect.zig
index e0833f8ed..12f7011fb 100644
--- a/src/bun.js/test/expect.zig
+++ b/src/bun.js/test/expect.zig
@@ -312,9 +312,6 @@ pub const Expect = struct {
 
         const not = this.flags.not;
         var pass = right.isSameValue(left, globalObject);
-        if (comptime Environment.allow_assert) {
-            std.debug.assert(pass == JSC.C.JSValueIsStrictEqual(globalObject, right.asObjectRef(), left.asObjectRef()));
-        }
 
         if (not) pass = !pass;
         if (pass) return thisValue;
diff --git a/src/bun.js/webcore/blob.zig b/src/bun.js/webcore/blob.zig
index ef2520049..0d6dcbc26 100644
--- a/src/bun.js/webcore/blob.zig
+++ b/src/bun.js/webcore/blob.zig
@@ -105,6 +105,9 @@ pub const Blob = struct {
     pub const JSTimeType = u52;
     pub const init_timestamp = std.math.maxInt(JSTimeType);
 
+    const serialization_version: u8 = 1;
+    const reserved_space_for_serialization: u32 = 128;
+
     pub fn getFormDataEncoding(this: *Blob) ?*bun.FormData.AsyncFormData {
         var content_type_slice: ZigString.Slice = this.getContentType() orelse return null;
         defer content_type_slice.deinit();
@@ -208,6 +211,192 @@ pub const Blob = struct {
         return null;
     }
 
+    const StructuredCloneWriter = struct {
+        ctx: *anyopaque,
+        impl: *const fn (*anyopaque, ptr: [*]const u8, len: u32) callconv(.C) void,
+
+        pub const WriteError = error{};
+        pub fn write(this: StructuredCloneWriter, bytes: []const u8) WriteError!usize {
+            this.impl(this.ctx, bytes.ptr, @truncate(u32, bytes.len));
+            return bytes.len;
+        }
+    };
+
+    fn _onStructuredCloneSerialize(
+        this: *Blob,
+        comptime Writer: type,
+        writer: Writer,
+    ) !void {
+        try writer.writeIntNative(u8, serialization_version);
+
+        try writer.writeIntNative(u64, @intCast(u64, this.offset));
+
+        try writer.writeIntNative(u32, @truncate(u32, this.content_type.len));
+        _ = try writer.write(this.content_type);
+        try writer.writeIntNative(u8, @intFromBool(this.content_type_was_set));
+
+        const store_tag: Store.SerializeTag = if (this.store) |store|
+            if (store.data == .file) .file else .bytes
+        else
+            .empty;
+
+        try writer.writeIntNative(u8, @intFromEnum(store_tag));
+
+        this.resolveSize();
+        if (this.store) |store| {
+            try store.serialize(Writer, writer);
+        }
+
+        // reserved space for future use
+        _ = try writer.write(&[_]u8{0} ** reserved_space_for_serialization);
+    }
+
+    pub fn onStructuredCloneSerialize(
+        this: *Blob,
+        globalThis: *JSC.JSGlobalObject,
+        ctx: *anyopaque,
+        writeBytes: *const fn (*anyopaque, ptr: [*]const u8, len: u32) callconv(.C) void,
+    ) callconv(.C) void {
+        _ = globalThis;
+
+        const Writer = std.io.Writer(StructuredCloneWriter, StructuredCloneWriter.WriteError, StructuredCloneWriter.write);
+        var writer = Writer{
+            .context = .{
+                .ctx = ctx,
+                .impl = writeBytes,
+            },
+        };
+
+        _onStructuredCloneSerialize(this, Writer, writer) catch return .zero;
+    }
+
+    pub fn onStructuredCloneTransfer(
+        this: *Blob,
+        globalThis: *JSC.JSGlobalObject,
+        ctx: *anyopaque,
+        write: *const fn (*anyopaque, ptr: [*]const u8, len: usize) callconv(.C) void,
+    ) callconv(.C) void {
+        _ = write;
+        _ = ctx;
+        _ = this;
+        _ = globalThis;
+    }
+
+    fn readSlice(
+        reader: anytype,
+        len: usize,
+        allocator: std.mem.Allocator,
+    ) ![]u8 {
+        var slice = try allocator.alloc(u8, len);
+        slice = slice[0..try reader.read(slice)];
+        if (slice.len != len) return error.TooSmall;
+        return slice;
+    }
+
+    fn _onStructuredCloneDeserialize(
+        globalThis: *JSC.JSGlobalObject,
+        comptime Reader: type,
+        reader: Reader,
+    ) !JSValue {
+        const allocator = globalThis.allocator();
+
+        const version = try reader.readIntNative(u8);
+        _ = version;
+
+        const offset = try reader.readIntNative(u64);
+
+        const content_type_len = try reader.readIntNative(u32);
+
+        const content_type = try readSlice(reader, content_type_len, allocator);
+
+        const content_type_was_set: bool = try reader.readIntNative(u8) != 0;
+
+        const store_tag = try reader.readEnum(Store.SerializeTag, .Little);
+
+        const blob: *Blob = switch (store_tag) {
+            .bytes => brk: {
+                const bytes_len = try reader.readIntNative(u32);
+                const bytes = try readSlice(reader, bytes_len, allocator);
+
+                var blob = Blob.init(bytes, allocator, globalThis);
+                var blob_ = try allocator.create(Blob);
+                blob_.* = blob;
+
+                break :brk blob_;
+            },
+            .file => brk: {
+                const pathlike_tag = try reader.readEnum(JSC.Node.PathOrFileDescriptor.SerializeTag, .Little);
+
+                switch (pathlike_tag) {
+                    .fd => {
+                        const fd = @intCast(i32, try reader.readIntNative(u32));
+
+                        var blob = try allocator.create(Blob);
+                        blob.* = Blob.findOrCreateFileFromPath(
+                            JSC.Node.PathOrFileDescriptor{
+                                .fd = fd,
+                            },
+                            globalThis,
+                        );
+
+                        break :brk blob;
+                    },
+                    .path => {
+                        const path_len = try reader.readIntNative(u32);
+
+                        const path = try readSlice(reader, path_len, default_allocator);
+
+                        var blob = try allocator.create(Blob);
+                        blob.* = Blob.findOrCreateFileFromPath(
+                            JSC.Node.PathOrFileDescriptor{
+                                .path = .{
+                                    .string = bun.PathString.init(path),
+                                },
+                            },
+                            globalThis,
+                        );
+
+                        break :brk blob;
+                    },
+                }
+
+                return .zero;
+            },
+            .empty => brk: {
+                var blob = try allocator.create(Blob);
+                blob.* = Blob.initEmpty(globalThis);
+                break :brk blob;
+            },
+        };
+        blob.allocator = allocator;
+        blob.offset = @intCast(u52, offset);
+        if (content_type.len > 0) {
+            blob.content_type = content_type;
+            blob.content_type_allocated = true;
+            blob.content_type_was_set = content_type_was_set;
+        }
+
+        return blob.toJS(globalThis);
+    }
+
+    pub fn onStructuredCloneDeserialize(
+        globalThis: *JSC.JSGlobalObject,
+        ptr: [*]u8,
+        end: [*]u8,
+    ) callconv(.C) JSValue {
+        const total_length: usize = @intFromPtr(end) - @intFromPtr(ptr);
+        var buffer_stream = std.io.fixedBufferStream(ptr[0..total_length]);
+        var reader = buffer_stream.reader();
+
+        const blob = _onStructuredCloneDeserialize(globalThis, @TypeOf(reader), reader) catch return .zero;
+
+        if (Environment.allow_assert) {
+            std.debug.assert(total_length - reader.context.pos == reserved_space_for_serialization);
+        }
+
+        return blob;
+    }
+
     const URLSearchParamsConverter = struct {
         allocator: std.mem.Allocator,
         buf: []u8 = "",
@@ -1095,6 +1284,37 @@ pub const Blob = struct {
             allocator.destroy(this);
         }
 
+        const SerializeTag = enum(u8) {
+            file = 0,
+            bytes = 1,
+            empty = 2,
+        };
+
+        pub fn serialize(this: *Store, comptime Writer: type, writer: Writer) !void {
+            switch (this.data) {
+                .file => |file| {
+                    const pathlike_tag: JSC.Node.PathOrFileDescriptor.SerializeTag = if (file.pathlike == .fd) .fd else .path;
+                    try writer.writeIntNative(u8, @intFromEnum(pathlike_tag));
+
+                    switch (file.pathlike) {
+                        .fd => |fd| {
+                            try writer.writeIntNative(u32, @intCast(u32, fd));
+                        },
+                        .path => |path| {
+                            const path_slice = path.slice();
+                            try writer.writeIntNative(u32, @truncate(u32, path_slice.len));
+                            _ = try writer.write(path_slice);
+                        },
+                    }
+                },
+                .bytes => |bytes| {
+                    const slice = bytes.slice();
+                    try writer.writeIntNative(u32, @truncate(u32, slice.len));
+                    _ = try writer.write(slice);
+                },
+            }
+        }
+
         pub fn fromArrayList(list: std.ArrayListUnmanaged(u8), allocator: std.mem.Allocator) !*Blob.Store {
             return try Blob.Store.init(list.items, allocator);
         }
diff --git a/src/bun.js/webcore/response.classes.ts b/src/bun.js/webcore/response.classes.ts
index c11cb10b2..f0d6e1451 100644
--- a/src/bun.js/webcore/response.classes.ts
+++ b/src/bun.js/webcore/response.classes.ts
@@ -125,6 +125,7 @@ export default [
     JSType: "0b11101110",
     klass: {},
     configurable: false,
+    structuredClone: { transferrable: false, tag: 254 },
     proto: {
       text: { fn: "getText" },
       json: { fn: "getJSON" },