@@ -0,0 +1,5 @@
+---
+"effect": patch
+---
+
+Fix `Equal.equals` and `Hash.hash` treating any two same-length `ArrayBuffer`s as equal. `ArrayBuffer` and `SharedArrayBuffer` are now compared and hashed by their bytes.
@@ -12,7 +12,7 @@
  */
 import type { Equivalence } from "./Equivalence.ts"
 import * as Hash from "./Hash.ts"
-import { byReferenceInstances, getAllObjectKeys, viewBytes } from "./internal/equal.ts"
+import { bufferBytes, byReferenceInstances, getAllObjectKeys, isArrayBufferLike, viewBytes } from "./internal/equal.ts"
 import { hasProperty } from "./Predicate.ts"
 
 /**
@@ -257,6 +257,13 @@ function compareStructure(self: object, that: object): boolean {
       return false
     }
     return compareArrays(self, that)
+  } else if (isArrayBufferLike(self)) {
+    if (!isArrayBufferLike(that) || (self instanceof ArrayBuffer) !== (that instanceof ArrayBuffer)) {
+      return false
+    }
+    const selfBytes = bufferBytes(self)
+    const thatBytes = bufferBytes(that)
+    return selfBytes !== undefined && thatBytes !== undefined && compareTypedArrays(selfBytes, thatBytes)
   } else if (ArrayBuffer.isView(self)) {
     const selfIsDataView = self instanceof DataView
     if (
 
@@ -11,7 +11,7 @@
  * @since 2.0.0
  */
 import { dual } from "./Function.ts"
-import { byReferenceInstances, getAllObjectKeys, viewBytes } from "./internal/equal.ts"
+import { bufferBytes, byReferenceInstances, getAllObjectKeys, isArrayBufferLike, viewBytes } from "./internal/equal.ts"
 import { addBackEdge, backEdges } from "./internal/hash.ts"
 import { hasProperty } from "./Predicate.ts"
 
@@ -144,6 +144,9 @@ export const hash: <A>(self: A) => number = <A>(self: A) => {
             h = (self as Hash)[symbol]()
           } else if (typeof self === "function") {
             h = random(self)
+          } else if (isArrayBufferLike(self)) {
+            const bytes = bufferBytes(self)
+            h = bytes === undefined ? random(self) : array(bytes)
           } else if (self instanceof DataView) {
             h = array(viewBytes(self))
           } else if (Array.isArray(self) || ArrayBuffer.isView(self)) {
 
@@ -29,3 +29,20 @@ export const byReferenceInstances = new WeakSet<object>()
 
 /** @internal */
 export const viewBytes = (view: DataView): Uint8Array => new Uint8Array(view.buffer, view.byteOffset, view.byteLength)
+
+/** @internal */
+export const isArrayBufferLike = (u: unknown): u is ArrayBufferLike =>
+  u instanceof ArrayBuffer || (typeof SharedArrayBuffer !== "undefined" && u instanceof SharedArrayBuffer)
+
+/**
+ * Returns `undefined` for detached buffers, which can no longer be read.
+ *
+ * @internal
+ */
+export const bufferBytes = (buffer: ArrayBufferLike): Uint8Array | undefined => {
+  try {
+    return new Uint8Array(buffer)
+  } catch {
+    return undefined
+  }
+}
@@ -416,6 +416,37 @@ describe("Equal.equals", () => {
     })
   })
 
+  describe("ArrayBuffer objects", () => {
+    const make = (Buffer: typeof ArrayBuffer | typeof SharedArrayBuffer, bytes: ReadonlyArray<number>) => {
+      const buffer = new Buffer(bytes.length)
+      new Uint8Array(buffer).set(bytes)
+      return buffer
+    }
+
+    it("should compare bytes", () => {
+      for (const Buffer of [ArrayBuffer, SharedArrayBuffer]) {
+        expect(Equal.equals(make(Buffer, [1, 2]), make(Buffer, [1, 2]))).toBe(true)
+        expect(Equal.equals(make(Buffer, [1, 2]), make(Buffer, [9, 9]))).toBe(false)
+      }
+    })
+
+    it("should not equal views or other buffer kinds with the same bytes", () => {
+      const buffer = make(ArrayBuffer, [1, 2])
+      for (const other of [new Uint8Array(buffer), make(SharedArrayBuffer, [1, 2])]) {
+        expect(Equal.equals(buffer, other)).toBe(false)
+        expect(Equal.equals(other, buffer)).toBe(false)
+      }
+    })
+
+    it("should compare detached buffers by reference", () => {
+      const self = new ArrayBuffer(2)
+      const that = new ArrayBuffer(2)
+      structuredClone(self, { transfer: [self] })
+      structuredClone(that, { transfer: [that] })
+      expect(Equal.equals(self, that)).toBe(false)
+    })
+  })
+
   describe("DataView objects", () => {
     it("should compare viewed bytes", () => {
       const self = new DataView(Uint8Array.of(1).buffer)
 
@@ -137,6 +137,10 @@ describe("Hash", () => {
     it("does not collide for 10k multiples of 0.001", () => {
       assertNoHashCollisions(range(10_000).map((i) => i * 0.001))
     })
+
+    it("does not collide for ArrayBuffers with different bytes", () => {
+      assert.notStrictEqual(Hash.hash(Uint8Array.of(1, 2).buffer), Hash.hash(Uint8Array.of(9, 9).buffer))
+    })
   })
 
   describe("floats", () => {
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"effect": patch
 +---
++
 +Fix `Equal.equals` and `Hash.hash` treating any two same-length `ArrayBuffer`s as equal. `ArrayBuffer` and `SharedArrayBuffer` are now compared and hashed by their bytes.