test(core): add tests for cloneable resource registry

Tests cover:
- structuredClone with a cloneable object
- serialize/deserialize round-trip with cloneable object
- cloneable object nested inside a plain object
- duplicate registration throws

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: bartlomieju

libs/core_testing/unit/serialize_deserialize_test.ts

@@ -1,5 +1,11 @@
 // Copyright 2018-2026 the Deno authors. MIT license.
-import { assertArrayEquals, assertEquals, test } from "checkin:testing";
+import {
+  assert,
+  assertArrayEquals,
+  assertEquals,
+  assertThrows,
+  test,
+} from "checkin:testing";
 
 test(function testIssue20727() {
   // https://github.com/denoland/deno/issues/20727
@@ -109,3 +115,103 @@ test(function structuredClone() {
   assertEquals(cloned.test2, circularObject.test2);
   assertEquals(cloned.test3, circularObject.test3);
 });
+
+test(function cloneableResourceStructuredClone() {
+  // Create a class that supports structured cloning via hostObjectBrand
+  class MyCloneable {
+    value: string;
+    constructor(value: string) {
+      this.value = value;
+      // deno-lint-ignore no-this-alias
+      const self = this;
+      this[Deno.core.hostObjectBrand] = () => ({
+        type: "MyCloneable",
+        value: self.value,
+      });
+    }
+  }
+
+  Deno.core.registerCloneableResource(
+    "MyCloneable",
+    (data: { value: string }) => new MyCloneable(data.value),
+  );
+
+  const original = new MyCloneable("hello");
+  const cloned = Deno.core.structuredClone(original);
+
+  assert(cloned instanceof MyCloneable);
+  assertEquals(cloned.value, "hello");
+  assert(cloned !== original);
+});
+
+test(function cloneableResourceSerializeDeserialize() {
+  // Use a different name to avoid duplicate registration
+  class AnotherCloneable {
+    data: number;
+    constructor(data: number) {
+      this.data = data;
+      // deno-lint-ignore no-this-alias
+      const self = this;
+      this[Deno.core.hostObjectBrand] = () => ({
+        type: "AnotherCloneable",
+        data: self.data,
+      });
+    }
+  }
+
+  Deno.core.registerCloneableResource(
+    "AnotherCloneable",
+    (d: { data: number }) => new AnotherCloneable(d.data),
+  );
+
+  const original = new AnotherCloneable(42);
+  const serialized = Deno.core.serialize(original);
+  const deserialized = Deno.core.deserialize(serialized, {
+    deserializers: Deno.core.getCloneableDeserializers(),
+  });
+
+  assert(deserialized instanceof AnotherCloneable);
+  assertEquals(deserialized.data, 42);
+});
+
+test(function cloneableResourceNestedInObject() {
+  class NestedCloneable {
+    name: string;
+    constructor(name: string) {
+      this.name = name;
+      // deno-lint-ignore no-this-alias
+      const self = this;
+      this[Deno.core.hostObjectBrand] = () => ({
+        type: "NestedCloneable",
+        name: self.name,
+      });
+    }
+  }
+
+  Deno.core.registerCloneableResource(
+    "NestedCloneable",
+    (d: { name: string }) => new NestedCloneable(d.name),
+  );
+
+  const obj = {
+    foo: "bar",
+    nested: new NestedCloneable("test"),
+    num: 123,
+  };
+
+  const cloned = Deno.core.structuredClone(obj);
+
+  assertEquals(cloned.foo, "bar");
+  assertEquals(cloned.num, 123);
+  assert(cloned.nested instanceof NestedCloneable);
+  assertEquals(cloned.nested.name, "test");
+});
+
+test(function cloneableResourceDuplicateRegistrationThrows() {
+  Deno.core.registerCloneableResource("DuplicateTest", () => {});
+  assertThrows(
+    () => Deno.core.registerCloneableResource("DuplicateTest", () => {}),
+    Error,
+    "already registered",
+  );
+});