lib/src/main/java/io/ably/lib/object/instance/types/BinaryInstance.java (1)

24-24: ⚡ Quick win

Inconsistent annotation style with other primitive instances.

All other primitive instance types (BooleanInstance, StringInstance, NumberInstance, JsonArrayInstance, JsonObjectInstance) place @NotNull on a separate line before the return type, but BinaryInstance uses inline type-use syntax byte @NotNull []. While both are valid, consistency improves maintainability.

♻️ Align with the annotation style used by other primitive instances

     /**
      * Returns the wrapped binary value.
      *
      * <p>Spec: RTINS4 / RTTS10c
      *
      * `@return` the wrapped bytes
      */
-    byte `@NotNull` [] value();
+    `@NotNull`
+    byte[] value();

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@lib/src/main/java/io/ably/lib/object/instance/types/BinaryInstance.java` at
line 24, The annotation placement in BinaryInstance's value() method is
inconsistent—change the type-use form `byte `@NotNull` [] value()` to the same
style used by other primitives by placing `@NotNull` on its own line above the
return type so the signature reads with `@NotNull` on a separate line prior to
`byte[]` in the BinaryInstance interface's value() method to match
BooleanInstance, StringInstance, NumberInstance, JsonArrayInstance, and
JsonObjectInstance.

lib/src/main/java/io/ably/lib/object/message/ObjectData.java (1)

53-60: ⚡ Quick win

Clarify defensive-copy semantics for binary payloads.

Line 60 returns a mutable byte[]; without a copy/immutability contract, callers can mutate shared state if implementations return backing storage.

♻️ Suggested contract hardening

     /**
      * Returns the binary value.
      *
      * <p>Spec: OD2c
      *
-     * `@return` the binary value, or {`@code` null} if not applicable
+     * <p>Implementations should return a defensive copy (or otherwise guarantee
+     * immutability) so callers cannot mutate internal state.
+     *
+     * `@return` the binary value, or {`@code` null} if not applicable
      */
     byte `@Nullable` [] getBytes();

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@lib/src/main/java/io/ably/lib/object/message/ObjectData.java` around lines 53
- 60, The Javadoc for ObjectData.getBytes() is ambiguous about whether the
returned byte[] is a live backing array or a defensive copy; update the contract
in the getBytes() Javadoc of class ObjectData to state explicitly whether
callers may mutate the returned array or not and what implementations must do
(preferably: implementations must return a defensive copy of internal storage
and callers may freely modify the returned array), and mention performance
implications so implementers can optimize (e.g., offer an alternative method
like getBytesView() returning an unmodifiable/readonly view if needed);
reference the getBytes() method and ensure the Javadoc mentions nullability,
copy semantics, and responsibilities for callers and implementers.

lib/src/main/java/io/ably/lib/object/value/LiveMapValue.java (1)

289-306: ⚡ Quick win

Binary array stored and returned without defensive copies.

BinaryValue stores the byte[] reference directly (line 293) and returns it directly (line 305), allowing external code to mutate the array after construction or after calling getAsBinary(). This can lead to unexpected state changes in the LiveMapValue after it has been created or retrieved.

🛡️ Recommended fix: add defensive copies

 BinaryValue(byte `@NotNull` [] value) {
-    this.value = value;
+    this.value = value.clone();
 }

 `@Override`
 public byte `@NotNull` [] getAsBinary() { 
-    return value; 
+    return value.clone(); 
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@lib/src/main/java/io/ably/lib/object/value/LiveMapValue.java` around lines
289 - 306, BinaryValue stores and exposes the mutable byte[] directly; to
prevent external mutation, make defensive copies: in the BinaryValue(byte[]
value) constructor copy the incoming array (e.g., Arrays.copyOf) into the
private field, and in both getValue() and getAsBinary() return a copy of the
internal array rather than the raw reference; update imports if needed and keep
the field final and type byte[].

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes