Fix #6059 (#6061)

Author: cowtowncoder

release-notes/VERSION

@@ -25,6 +25,9 @@ No changes since 3.2
   using creator-based instantiation (such as `record`)
  (reported by Théo S)
  (fix by @seonwooj0810)
+#6059: `ObjectMapper.valueToTree()` with `byte[]` does not produce `BinaryNode`
+ (reported by @sebastien-leveque)
+ (fix by @cowtowncoder, w/ Claude code)
 #6060: `@JsonView` by-passed for `@JsonUnwrapped` Field/Setter properties
 
 3.2.0 (08-Jun-2026)

src/main/java/tools/jackson/databind/node/TreeBuildingGenerator.java

@@ -463,8 +463,13 @@ public JsonGenerator writePOJO(Object value)
         //    but for now let's follow what `TokenBuffer` does and by default
         //    fully serialize given Java value... unless it's one of a small
         //    number of "well-known" types to preserve.
-        final Class<?> raw = value.getClass();
-        if (raw == byte[].class || (value instanceof RawValue)) {
+        // 26-Jun-2026, tatu: [databind#6059] `byte[]` must become `BinaryNode`,
+        //    not `POJONode`, to match the `writeBinary()` path
+        if (value instanceof byte[] bytes) {
+            _tokenWriteContext.writeBinary(bytes);
+            return this;
+        }
+        if (value instanceof RawValue) {
             _tokenWriteContext.writePOJO(value);
             return this;
         }
@@ -498,7 +503,9 @@ public JsonGenerator writeBinary(Base64Variant b64variant, byte[] data, int offs
         // 12-Jan-2021, tatu: Should we try to preserve the variant? Depends a
         //   lot on whether this during read (no need to retain probably) or
         //   write (probably important)
-        return writePOJO(Arrays.copyOfRange(data, offset, offset + len));
+        // 26-Jun-2026, tatu: [databind#6059] Must create `BinaryNode`, not `POJONode`
+        _tokenWriteContext.writeBinary(Arrays.copyOfRange(data, offset, offset + len));
+        return this;
     }
 
     /**
@@ -542,6 +549,11 @@ public JsonGenerator writeObjectId(Object id) {
     public JsonGenerator writeEmbeddedObject(Object object) {
         // 02-Mar-2021, tatu: Bit tricky, this one; should we try to
         //   auto-detect types or something?
+        // 26-Jun-2026, tatu: [databind#6059] Preserve `byte[]` as `BinaryNode`
+        if (object instanceof byte[] bytes) {
+            _tokenWriteContext.writeBinary(bytes);
+            return this;
+        }
         _tokenWriteContext.writePOJO(object);
         return this;
     }

src/test/java/tools/jackson/databind/node/JsonNodeConversionsTest.java

@@ -447,4 +447,58 @@ public void treeToValueWithMissingNode4932() throws Exception {
         assertNull(r.treeToValue(MAPPER.nullNode(), Object.class));
         assertNull(r.treeToValue(MAPPER.missingNode(), Object.class));
     }
+
+    // [databind#6059]: `byte[]` should convert to `BinaryNode`, not `POJONode`
+    @Test
+    public void byteArrayToTree6059() {
+        final byte[] bytes = { 1, 2, 3 };
+        JsonNode node = MAPPER.valueToTree(bytes);
+
+        // Must be a `BinaryNode` (not `POJONode`, as it was prior to fix)...
+        assertInstanceOf(BinaryNode.class, node);
+        assertTrue(node.isBinary());
+        // ... with contents preserved...
+        assertArrayEquals(bytes, node.binaryValue());
+
+        // ... and, the actual regression reported, equal to a node built
+        // from a separate-but-equal array (`BinaryNode` compares by content,
+        // `POJONode` only by identity):
+        JsonNode node2 = MAPPER.valueToTree(new byte[] { 1, 2, 3 });
+        assertEquals(node, node2);
+
+        // Empty array, too (from the original report):
+        assertEquals(MAPPER.valueToTree(new byte[0]),
+                MAPPER.valueToTree(new byte[0]));
+    }
+
+    // [databind#6059]: also when `byte[]` is nested within Object/Array contexts
+    @Test
+    public void nestedByteArrayToTree6059() {
+        final byte[] bytes = { 4, 5, 6 };
+
+        // As a value within an Object (Map):
+        JsonNode objNode = MAPPER.valueToTree(Collections.singletonMap("b", bytes));
+        JsonNode objBinary = objNode.get("b");
+        assertInstanceOf(BinaryNode.class, objBinary);
+        assertArrayEquals(bytes, objBinary.binaryValue());
+
+        // As an element within an Array (List):
+        JsonNode arrNode = MAPPER.valueToTree(Collections.singletonList(bytes));
+        JsonNode arrBinary = arrNode.get(0);
+        assertInstanceOf(BinaryNode.class, arrBinary);
+        assertArrayEquals(bytes, arrBinary.binaryValue());
+    }
+
+    // [databind#6059]: also when `byte[]` reaches the tree via `TokenBuffer`
+    // replay (`writeEmbeddedObject()` path), not just the direct `writeBinary()`
+    @Test
+    public void byteArrayViaTokenBufferToTree6059() {
+        final byte[] bytes = { 7, 8, 9 };
+        TokenBuffer buf = TokenBuffer.forGeneration();
+        buf.writeBinary(bytes);
+
+        JsonNode node = MAPPER.valueToTree(buf);
+        assertInstanceOf(BinaryNode.class, node);
+        assertArrayEquals(bytes, node.binaryValue());
+    }
 }