From e133f21dcbc4c6a3a962de2a1f710fcfa1ab9734 Mon Sep 17 00:00:00 2001
From: akirilyuk <45361199+akirilyuk@users.noreply.github.com>
Date: Mon, 15 Jun 2026 10:02:51 +0200
Subject: [PATCH 1/2] chore(ci): sync package-lock after release 0.5.3

---
 package-lock.json | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 64eaca1..2370b96 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -609,7 +609,6 @@
       "version": "8.60.0",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "8.60.0",
         "@typescript-eslint/types": "8.60.0",
@@ -926,7 +925,6 @@
       "version": "8.16.0",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -1172,7 +1170,6 @@
       "version": "9.39.4",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.8.0",
         "@eslint-community/regexpp": "^4.12.1",
@@ -1714,7 +1711,6 @@
       "version": "4.0.4",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -2057,7 +2053,6 @@
       "version": "5.9.3",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -2105,7 +2100,6 @@
       "version": "5.4.21",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "esbuild": "^0.21.3",
         "postcss": "^8.4.43",

From 5d83fba45c956aaa6904db920b02a935e7bd42b0 Mon Sep 17 00:00:00 2001
From: akirilyuk <alexander.kiri.aa@gmail.com>
Date: Tue, 16 Jun 2026 11:07:42 +0700
Subject: [PATCH 2/2] feat(sdk): ArrayBuffer DataChannel support and
 dual-channel sync

Optimize native binary receive, honor binaryType in SDK, add voicethere-sync
helpers, binary examples (roundtrip + mesh), and browser-cosine-chat game sync.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 docs/webrtc-api-parity.md                     |   4 +-
 examples/README.md                            |   4 +
 examples/browser-cosine-chat/public/client.js | 120 ++++++++-
 .../browser-cosine-chat/public/index.html     |  11 +-
 .../browser-cosine-chat/public/styles.css     |  21 ++
 examples/peer-connection/package.json         |   2 +
 examples/peer-connection/src/binary-mesh.ts   | 242 ++++++++++++++++++
 .../peer-connection/src/binary-roundtrip.ts   | 111 ++++++++
 examples/shared/game-state-sync.js            |  34 +++
 examples/shared/game-state-sync.ts            |  62 +++++
 packages/bindings/src/data_channel.rs         |   9 +-
 packages/helpers/src/index.ts                 |   2 +-
 packages/helpers/src/session-pod.ts           |   5 +-
 .../helpers/src/voice-agent-session-host.ts   |  90 ++++++-
 packages/helpers/src/voice-session-handler.ts |  14 +
 packages/sdk/src/RTCDataChannel.ts            |  31 ++-
 packages/sdk/src/types.ts                     |   2 +-
 packages/sdk/src/voice/index.ts               |   1 +
 packages/sdk/src/voice/speech-event-bridge.ts |  33 ++-
 packages/sdk/tests/e2e.test.ts                |  53 ++++
 20 files changed, 816 insertions(+), 35 deletions(-)
 create mode 100644 examples/peer-connection/src/binary-mesh.ts
 create mode 100644 examples/peer-connection/src/binary-roundtrip.ts
 create mode 100644 examples/shared/game-state-sync.js
 create mode 100644 examples/shared/game-state-sync.ts

diff --git a/docs/webrtc-api-parity.md b/docs/webrtc-api-parity.md
index 53fd591..e9a8492 100644
--- a/docs/webrtc-api-parity.md
+++ b/docs/webrtc-api-parity.md
@@ -209,9 +209,9 @@ Browser: `ontrack` → attach to `<audio>` or WebAudio.
 | `maxPacketLifeTime` / `maxRetransmits`         | 🟡     | In init type; verify native SCTP mapping                        |
 | `negotiated`                                   | 🟡     |                                                                 |
 | `readyState`                                   | ✅     |                                                                 |
-| `send(string \| Buffer)`                       | ✅     | `ArrayBuffer` / `Uint8Array` coerced                            |
+| `send(string \| Buffer \| ArrayBuffer \| Uint8Array)` | ✅     | `Buffer` passed through on send when already a Buffer           |
 | `close()`                                      | ✅     |                                                                 |
-| `binaryType`                                   | 🟡     | Property only; incoming binary as `Buffer`                      |
+| `binaryType`                                   | ✅     | `'arraybuffer'` returns `ArrayBuffer` on receive; default `Buffer` |
 | `bufferedAmount`                               | ✅     | Cached property synced from native after send and on low events |
 | `bufferedAmountLowThreshold`                   | ✅     | Forwarded to SCTP stack                                         |
 | `onopen` / `onmessage` / `onclose` / `onerror` | ✅     |                                                                 |
diff --git a/examples/README.md b/examples/README.md
index 92a3fef..2791895 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -13,6 +13,8 @@ Each example is an npm workspace package under this directory, authored in **Typ
 | Package                                   | Type                    | Default port     | Description                                                                                                                                                                                                                                                                                       |
 | ----------------------------------------- | ----------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | **peer-connection**                       | CLI (exits on success)  | 8080 (signaling) | Two Node peers, DataChannel over WebSocket signaling                                                                                                                                                                                                                                              |
+| **peer-connection** `start:binary`        | CLI (exits on success)  | 8080             | Binary ArrayBuffer round-trip (20-byte game state frame)                                                                                                                                                                                                                                          |
+| **peer-connection** `start:binary-mesh`   | CLI (exits on success)  | 8080             | Three Node peers mesh-sync binary state over `game-sync` DataChannels                                                                                                                                                                                                                             |
 | **peer-connection** `start:parity`        | CLI (exits on success)  | 8080             | Transceivers, `getStats`, `setConfiguration`, `replaceTrack`, `readSample` tour                                                                                                                                                                                                                   |
 | **audio-cosine**                          | CLI (runs ~5s)          | 8080 (signaling) | Local audio track streaming a 440 Hz cosine tone in PCM                                                                                                                                                                                                                                           |
 | **audio-cosine** `start:replace-track`    | CLI (runs ~4s)          | 8080             | `replaceTrack` + `RemoteAudioTrack.readSample` with 440→880 Hz swap                                                                                                                                                                                                                               |
@@ -79,6 +81,8 @@ WEBRTC_DEBUG=1 npm run start --workspace=@node-webrtc-rust/example-conference-ro
 | Example                          | Command                                                                                                     | How to verify                                                                                                       |
 | -------------------------------- | ----------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
 | peer-connection                  | `npm run start --workspace=@node-webrtc-rust/example-peer-connection`                                       | Prints `Received: Hello from peer 1!` and exits                                                                     |
+| peer-connection binary           | `npm run start:binary --workspace=@node-webrtc-rust/example-peer-connection`                                | Prints `Binary player-state round-trip OK` and exits                                                                  |
+| peer-connection binary mesh      | `npm run start:binary-mesh --workspace=@node-webrtc-rust/example-peer-connection`                             | Three peers mesh-sync; prints `Mesh binary sync OK` and exits                                                         |
 | peer-connection parity           | `npm run start:parity --workspace=@node-webrtc-rust/example-peer-connection`                                | Runs three parity scenarios; prints `All parity scenarios completed`                                                |
 | audio-cosine                     | `npm run start --workspace=@node-webrtc-rust/example-audio-cosine`                                          | Logs remote track + streams tone for ~5s, then exits                                                                |
 | audio-cosine replace             | `npm run start:replace-track --workspace=@node-webrtc-rust/example-audio-cosine`                            | Swaps 440→880 Hz via `replaceTrack`; logs `readSample` byte lengths                                                 |
diff --git a/examples/browser-cosine-chat/public/client.js b/examples/browser-cosine-chat/public/client.js
index f6a262f..b20c8be 100644
--- a/examples/browser-cosine-chat/public/client.js
+++ b/examples/browser-cosine-chat/public/client.js
@@ -1,4 +1,10 @@
 import { attachAudioVisualizer } from '/shared/audio-visualizer.js'
+import {
+  createStateBuffer,
+  decodePlayerState,
+  encodePlayerState,
+  GAME_SYNC_CHANNEL_LABEL,
+} from '/shared/game-state-sync.js'
 
 const SERVER_PEER_ID = 'cosine-server'
 const ICE_SERVERS = [{ urls: 'stun:stun.l.google.com:19302' }]
@@ -18,6 +24,8 @@ const incomingVizCanvas = document.getElementById('incoming-viz')
 const vizStatusEl = document.getElementById('viz-status')
 const debugPanelEl = document.getElementById('debug-panel')
 const debugLogEl = document.getElementById('debug-log')
+const gameCanvas = document.getElementById('game-canvas')
+const gameStatusEl = document.getElementById('game-status')
 
 /** @type {WebSocket | null} */
 let ws = null
@@ -34,16 +42,113 @@ const peerConnections = new Map()
 const peerNames = new Map()
 /** @type {Map<string, RTCDataChannel>} */
 const chatChannels = new Map()
+/** @type {Map<string, RTCDataChannel>} */
+const gameSyncChannels = new Map()
 /** @type {Map<string, RTCIceCandidateInit[]>} */
 const pendingIceByPeer = new Map()
 /** @type {{ stop: () => void } | null} */
 let incomingVisualizer = null
 
+const localPlayerId = Math.floor(Math.random() * 60000)
+const localState = createStateBuffer()
+let localX = 320
+let localY = 180
+let gameTick = 0
+/** @type {Map<number, { x: number, y: number, peerId: string }>} */
+const remotePlayers = new Map()
+/** @type {number | null} */
+let gameLoopTimer = null
+/** @type {CanvasRenderingContext2D | null} */
+const gameCtx = gameCanvas?.getContext('2d') ?? null
+
+const PLAYER_COLORS = ['#38bdf8', '#f472b6', '#a3e635', '#fb923c', '#c084fc']
+
 if (DEBUG && debugPanelEl && debugLogEl) {
   debugPanelEl.hidden = false
   debugLog('Debug mode on — reload with ?debug if you change this URL mid-session')
 }
 
+window.addEventListener('keydown', (event) => {
+  const step = event.shiftKey ? 24 : 8
+  if (event.key === 'ArrowLeft') localX = Math.max(12, localX - step)
+  if (event.key === 'ArrowRight') localX = Math.min((gameCanvas?.width ?? 640) - 12, localX + step)
+  if (event.key === 'ArrowUp') localY = Math.max(12, localY - step)
+  if (event.key === 'ArrowDown') localY = Math.min((gameCanvas?.height ?? 360) - 12, localY + step)
+})
+
+function startGameLoop() {
+  if (gameLoopTimer != null) return
+  gameLoopTimer = window.setInterval(() => {
+    gameTick++
+    encodePlayerState(localState.view, 0, {
+      tick: gameTick,
+      playerId: localPlayerId,
+      x: localX,
+      y: localY,
+      rot: 0,
+    })
+    for (const dc of gameSyncChannels.values()) {
+      if (dc.readyState === 'open') {
+        dc.send(localState.bytes)
+      }
+    }
+    drawGameScene()
+  }, 100)
+}
+
+function stopGameLoop() {
+  if (gameLoopTimer != null) {
+    clearInterval(gameLoopTimer)
+    gameLoopTimer = null
+  }
+}
+
+function drawGameScene() {
+  if (!gameCtx || !gameCanvas) return
+  gameCtx.fillStyle = '#0b1018'
+  gameCtx.fillRect(0, 0, gameCanvas.width, gameCanvas.height)
+  gameCtx.fillStyle = '#1e293b'
+  gameCtx.fillRect(0, 0, gameCanvas.width, gameCanvas.height)
+  for (const [playerId, player] of remotePlayers) {
+    const color = PLAYER_COLORS[playerId % PLAYER_COLORS.length]
+    gameCtx.fillStyle = color
+    gameCtx.beginPath()
+    gameCtx.arc(player.x, player.y, 10, 0, Math.PI * 2)
+    gameCtx.fill()
+  }
+  gameCtx.fillStyle = '#fbbf24'
+  gameCtx.beginPath()
+  gameCtx.arc(localX, localY, 12, 0, Math.PI * 2)
+  gameCtx.fill()
+  if (gameStatusEl) {
+    gameStatusEl.textContent = `Local #${localPlayerId} · ${remotePlayers.size} remote player(s) · tick ${gameTick}`
+  }
+}
+
+function wireGameSyncChannel(peerId, dc) {
+  gameSyncChannels.set(peerId, dc)
+  dc.binaryType = 'arraybuffer'
+  dc.onopen = () => {
+    startGameLoop()
+    drawGameScene()
+  }
+  dc.onmessage = (event) => {
+    if (typeof event.data === 'string') return
+    const buf = event.data instanceof ArrayBuffer ? event.data : event.data.buffer
+    const decoded = decodePlayerState(buf)
+    if (decoded.playerId === localPlayerId) return
+    remotePlayers.set(decoded.playerId, {
+      x: decoded.x,
+      y: decoded.y,
+      peerId,
+    })
+  }
+  dc.onclose = () => {
+    gameSyncChannels.delete(peerId)
+    if (gameSyncChannels.size === 0) stopGameLoop()
+  }
+}
+
 function debugLog(...args) {
   if (!DEBUG) return
   const line = args.map((arg) => (typeof arg === 'string' ? arg : JSON.stringify(arg))).join(' ')
@@ -142,8 +247,12 @@ function cleanupPeers() {
   }
   peerConnections.clear()
   chatChannels.clear()
+  gameSyncChannels.clear()
+  remotePlayers.clear()
+  stopGameLoop()
   peerNames.clear()
   pendingIceByPeer.clear()
+  drawGameScene()
 }
 
 function handleSignal(message) {
@@ -245,6 +354,7 @@ function onPeerLeft(peerId) {
     session.pc.close()
     peerConnections.delete(peerId)
     chatChannels.delete(peerId)
+    gameSyncChannels.delete(peerId)
   }
 }
 
@@ -257,8 +367,16 @@ async function connectToPeer(peerId, createOffer) {
   if (createOffer) {
     const dc = pc.createDataChannel('chat')
     wireChatChannel(peerId, dc)
+    const gameDc = pc.createDataChannel(GAME_SYNC_CHANNEL_LABEL)
+    wireGameSyncChannel(peerId, gameDc)
   } else {
-    pc.ondatachannel = (event) => wireChatChannel(peerId, event.channel)
+    pc.ondatachannel = (event) => {
+      if (event.channel.label === GAME_SYNC_CHANNEL_LABEL) {
+        wireGameSyncChannel(peerId, event.channel)
+      } else {
+        wireChatChannel(peerId, event.channel)
+      }
+    }
   }
 
   pc.onicecandidate = (event) => {
diff --git a/examples/browser-cosine-chat/public/index.html b/examples/browser-cosine-chat/public/index.html
index d5f9daa..74a0bea 100644
--- a/examples/browser-cosine-chat/public/index.html
+++ b/examples/browser-cosine-chat/public/index.html
@@ -43,6 +43,15 @@ <h2>Incoming audio track</h2>
         <p id="audio-status">Waiting for server track…</p>
       </section>
 
+      <section class="panel game-panel">
+        <h2>Multiplayer sync (binary DataChannel)</h2>
+        <p class="game-hint">
+          Move with arrow keys. Positions sync over a <code>game-sync</code> channel (~10 Hz).
+        </p>
+        <canvas id="game-canvas" width="640" height="360" aria-label="Multiplayer positions"></canvas>
+        <p id="game-status" class="game-status">Join a room to sync player dots.</p>
+      </section>
+
       <section class="panel chat-panel">
         <h2>Room chat</h2>
         <ul id="messages"></ul>
@@ -61,6 +70,6 @@ <h2>Debug log</h2>
       </section>
     </main>
 
-    <script type="module" src="/client.js?v=4"></script>
+    <script type="module" src="/client.js?v=5"></script>
   </body>
 </html>
diff --git a/examples/browser-cosine-chat/public/styles.css b/examples/browser-cosine-chat/public/styles.css
index 54f3894..e027641 100644
--- a/examples/browser-cosine-chat/public/styles.css
+++ b/examples/browser-cosine-chat/public/styles.css
@@ -153,3 +153,24 @@ audio {
   white-space: pre-wrap;
   word-break: break-word;
 }
+
+.game-hint {
+  margin: 0 0 0.75rem;
+  font-size: 0.85rem;
+  color: #94a3b8;
+}
+
+#game-canvas {
+  display: block;
+  width: 100%;
+  height: auto;
+  border-radius: 8px;
+  border: 1px solid #243041;
+  background: #0b1018;
+}
+
+.game-status {
+  margin: 0.75rem 0 0;
+  font-size: 0.8rem;
+  color: #64748b;
+}
diff --git a/examples/peer-connection/package.json b/examples/peer-connection/package.json
index 4ca6d71..1d06f9a 100644
--- a/examples/peer-connection/package.json
+++ b/examples/peer-connection/package.json
@@ -7,6 +7,8 @@
   "scripts": {
     "start": "tsx src/index.ts",
     "start:parity": "tsx src/parity-features.ts",
+    "start:binary": "tsx src/binary-roundtrip.ts",
+    "start:binary-mesh": "tsx src/binary-mesh.ts",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
diff --git a/examples/peer-connection/src/binary-mesh.ts b/examples/peer-connection/src/binary-mesh.ts
new file mode 100644
index 0000000..8d9f446
--- /dev/null
+++ b/examples/peer-connection/src/binary-mesh.ts
@@ -0,0 +1,242 @@
+/**
+ * Three Node peers — mesh binary game-state sync (multiplayer pattern).
+ *
+ * Run: npm run start:binary-mesh --workspace=@node-webrtc-rust/example-peer-connection
+ */
+
+import { RTCPeerConnection, type RTCDataChannel } from '@node-webrtc-rust/sdk'
+import { SignalingClient, SignalingServer } from '@node-webrtc-rust/signaling'
+
+import {
+  createStateBuffer,
+  decodePlayerState,
+  encodePlayerState,
+  GAME_SYNC_CHANNEL_LABEL,
+} from '../../shared/game-state-sync.js'
+import { DEMO_ICE_SERVERS, waitForDataChannelOpen } from '../../shared/webrtc-demo-helpers.js'
+
+const TICKS = 10
+const TICK_MS = 100
+const WALL_MS = 45_000
+
+interface MeshPeer {
+  id: string
+  signaling: SignalingClient
+  links: Map<string, RTCPeerConnection>
+  channels: Map<string, RTCDataChannel>
+  pendingIce: Map<string, RTCIceCandidateInit[]>
+  state: ReturnType<typeof createStateBuffer>
+  seenFrom: Set<string>
+}
+
+function peerNum(id: string): number {
+  return Number(id.replace('pc', ''))
+}
+
+async function flushPendingIce(peer: MeshPeer, remoteId: string): Promise<void> {
+  const link = peer.links.get(remoteId)
+  const pending = peer.pendingIce.get(remoteId) ?? []
+  peer.pendingIce.set(remoteId, [])
+  if (!link) return
+  for (const candidate of pending) {
+    await link.addIceCandidate(candidate)
+  }
+}
+
+function wireChannel(peer: MeshPeer, remoteId: string, channel: RTCDataChannel): void {
+  peer.channels.set(remoteId, channel)
+  channel.binaryType = 'arraybuffer'
+  channel.onmessage = (event) => {
+    if (typeof event.data === 'string') return
+    const buf = Buffer.isBuffer(event.data) ? event.data : Buffer.from(event.data as ArrayBuffer)
+    const decoded = decodePlayerState(buf)
+    peer.seenFrom.add(`${remoteId}:tick${decoded.tick}`)
+  }
+}
+
+async function connectToPeer(peer: MeshPeer, remoteId: string, createOffer: boolean): Promise<void> {
+  if (peer.links.has(remoteId)) return
+
+  const link = new RTCPeerConnection({ iceServers: DEMO_ICE_SERVERS })
+  peer.links.set(remoteId, link)
+  peer.pendingIce.set(remoteId, [])
+
+  if (createOffer) {
+    const dc = link.createDataChannel(GAME_SYNC_CHANNEL_LABEL)
+    wireChannel(peer, remoteId, dc)
+  } else {
+    link.ondatachannel = (event) => wireChannel(peer, remoteId, event.channel)
+  }
+
+  link.onicecandidate = (event) => {
+    if (event.candidate) {
+      peer.signaling.sendIceCandidate(remoteId, event.candidate.toJSON())
+    }
+  }
+
+  if (createOffer) {
+    const offer = await link.createOffer()
+    await link.setLocalDescription(offer)
+    await link.gatheringComplete()
+    peer.signaling.sendOffer(remoteId, link.localDescription!.toJSON())
+  }
+}
+
+async function onOffer(peer: MeshPeer, fromPeerId: string, sdp: RTCSessionDescriptionInit): Promise<void> {
+  if (!peer.links.has(fromPeerId)) {
+    await connectToPeer(peer, fromPeerId, false)
+  }
+  const link = peer.links.get(fromPeerId)
+  if (!link) return
+  await link.setRemoteDescription(sdp)
+  await flushPendingIce(peer, fromPeerId)
+  const answer = await link.createAnswer()
+  await link.setLocalDescription(answer)
+  await link.gatheringComplete()
+  peer.signaling.sendAnswer(fromPeerId, link.localDescription!.toJSON())
+}
+
+async function onAnswer(peer: MeshPeer, fromPeerId: string, sdp: RTCSessionDescriptionInit): Promise<void> {
+  const link = peer.links.get(fromPeerId)
+  if (!link) return
+  await link.setRemoteDescription(sdp)
+  await flushPendingIce(peer, fromPeerId)
+}
+
+async function onRemoteIce(
+  peer: MeshPeer,
+  fromPeerId: string,
+  candidate: RTCIceCandidateInit,
+): Promise<void> {
+  const link = peer.links.get(fromPeerId)
+  if (!link || !candidate.candidate) return
+  if (!link.remoteDescription) {
+    peer.pendingIce.get(fromPeerId)?.push(candidate)
+    return
+  }
+  await link.addIceCandidate(candidate)
+}
+
+function createMeshPeer(id: string, url: string, room: string): MeshPeer {
+  const signaling = new SignalingClient({ url, room, peerId: id })
+  const peer: MeshPeer = {
+    id,
+    signaling,
+    links: new Map(),
+    channels: new Map(),
+    pendingIce: new Map(),
+    state: createStateBuffer(),
+    seenFrom: new Set(),
+  }
+
+  signaling.on('offer', ({ peerId, sdp }) => {
+    void onOffer(peer, peerId, sdp).catch(console.error)
+  })
+
+  signaling.on('answer', ({ peerId, sdp }) => {
+    void onAnswer(peer, peerId, sdp).catch(console.error)
+  })
+
+  signaling.on('ice-candidate', ({ peerId, candidate }) => {
+    void onRemoteIce(peer, peerId, candidate).catch(console.error)
+  })
+
+  return peer
+}
+
+async function main(): Promise<void> {
+  const wall = setTimeout(() => {
+    console.error('binary-mesh wall clock timeout')
+    process.exit(1)
+  }, WALL_MS)
+
+  const server = new SignalingServer({ port: 0 })
+  await server.listen(0)
+  const room = 'binary-mesh'
+  const url = `ws://localhost:${server.port}`
+
+  const peers = ['pc1', 'pc2', 'pc3'].map((id) => createMeshPeer(id, url, room))
+  for (const peer of peers) {
+    await peer.signaling.connect()
+  }
+
+  const peerIds = peers.map((p) => p.id)
+  for (const peer of peers) {
+    for (const remoteId of peerIds) {
+      if (remoteId === peer.id) continue
+      if (peerNum(peer.id) > peerNum(remoteId)) {
+        await connectToPeer(peer, remoteId, true)
+      }
+    }
+  }
+
+  const expectedLinks = peers.length * (peers.length - 1)
+  const deadline = Date.now() + 20_000
+  while (Date.now() < deadline) {
+    const channels = peers.flatMap((p) => [...p.channels.values()])
+    if (
+      channels.length === expectedLinks &&
+      channels.every((ch) => ch.readyState === 'open')
+    ) {
+      break
+    }
+    await new Promise((r) => setTimeout(r, 50))
+  }
+
+  const channels = peers.flatMap((p) => [...p.channels.values()])
+  if (channels.length !== expectedLinks || channels.some((ch) => ch.readyState !== 'open')) {
+    throw new Error(
+      `mesh links incomplete: ${channels.length}/${expectedLinks} channels, states=${channels.map((c) => c.readyState).join(',')}`,
+    )
+  }
+
+  for (const channel of channels) {
+    await waitForDataChannelOpen(channel)
+  }
+
+  for (let tick = 1; tick <= TICKS; tick++) {
+    for (const peer of peers) {
+      encodePlayerState(peer.state.view, 0, {
+        tick,
+        playerId: peerNum(peer.id),
+        x: tick * 0.25,
+        y: peerNum(peer.id),
+        rot: 0,
+      })
+      for (const channel of peer.channels.values()) {
+        channel.send(peer.state.bytes)
+      }
+    }
+    await new Promise((r) => setTimeout(r, TICK_MS))
+  }
+
+  let ok = true
+  for (const peer of peers) {
+    for (const remote of peers) {
+      if (remote.id === peer.id) continue
+      for (let tick = 1; tick <= TICKS; tick++) {
+        const key = `${remote.id}:tick${tick}`
+        if (!peer.seenFrom.has(key)) {
+          console.error(`${peer.id} missing ${key}`)
+          ok = false
+        }
+      }
+    }
+  }
+
+  for (const peer of peers) {
+    for (const link of peer.links.values()) link.close()
+    peer.signaling.disconnect()
+  }
+  await server.close()
+  clearTimeout(wall)
+
+  if (!ok) throw new Error('mesh binary sync incomplete')
+  console.log(`Mesh binary sync OK (${peers.length} peers, ${TICKS} ticks each)`)
+  process.exit(0)
+}
+
+void main().catch((error: unknown) => {
+  console.error(error)
+  process.exitCode = 1
+})
diff --git a/examples/peer-connection/src/binary-roundtrip.ts b/examples/peer-connection/src/binary-roundtrip.ts
new file mode 100644
index 0000000..9b7c51f
--- /dev/null
+++ b/examples/peer-connection/src/binary-roundtrip.ts
@@ -0,0 +1,111 @@
+/**
+ * Two Node peers — binary ArrayBuffer round-trip on a DataChannel.
+ *
+ * Run: npm run start:binary --workspace=@node-webrtc-rust/example-peer-connection
+ */
+
+import { RTCPeerConnection, type RTCDataChannel } from '@node-webrtc-rust/sdk'
+import { autoNegotiate, SignalingClient, SignalingServer } from '@node-webrtc-rust/signaling'
+
+import {
+  createStateBuffer,
+  decodePlayerState,
+  encodePlayerState,
+  PLAYER_STATE_FRAME_BYTES,
+} from '../../shared/game-state-sync.js'
+import { DEMO_ICE_SERVERS, waitForConnection, waitForDataChannelOpen } from '../../shared/webrtc-demo-helpers.js'
+
+const MESSAGE_TIMEOUT_MS = 30_000
+const STRESS_KB = Number(process.env.BINARY_STRESS_KB ?? 0)
+
+async function waitForBinary(channel: RTCDataChannel, timeoutMs: number): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`no binary message within ${timeoutMs / 1000}s`))
+    }, timeoutMs)
+    channel.binaryType = 'arraybuffer'
+    channel.onmessage = (event) => {
+      if (typeof event.data === 'string') return
+      clearTimeout(timer)
+      resolve(Buffer.isBuffer(event.data) ? event.data : Buffer.from(event.data as ArrayBuffer))
+    }
+  })
+}
+
+async function main(): Promise<void> {
+  const server = new SignalingServer({ port: 8080 })
+  await server.listen()
+
+  const pc1 = new RTCPeerConnection({ iceServers: DEMO_ICE_SERVERS })
+  const pc2 = new RTCPeerConnection({ iceServers: DEMO_ICE_SERVERS })
+  const sig1 = new SignalingClient({ url: `ws://localhost:${server.port}`, room: 'binary', peerId: 'pc1' })
+  const sig2 = new SignalingClient({ url: `ws://localhost:${server.port}`, room: 'binary', peerId: 'pc2' })
+
+  const cleanup = async (): Promise<void> => {
+    pc1.close()
+    pc2.close()
+    sig1.disconnect()
+    sig2.disconnect()
+    await server.close()
+  }
+
+  try {
+    const dc1 = pc1.createDataChannel('game-sync')
+    const dc2Promise = new Promise<RTCDataChannel>((resolve) => {
+      pc2.ondatachannel = (event) => resolve(event.channel)
+    })
+
+    autoNegotiate({ pc: pc1, signaling: sig1, polite: false })
+    autoNegotiate({ pc: pc2, signaling: sig2, polite: true })
+    await sig1.connect()
+    await sig2.connect()
+
+    const dc2 = await dc2Promise
+    await waitForDataChannelOpen(dc1)
+    await waitForDataChannelOpen(dc2)
+    await waitForConnection(pc1)
+    await waitForConnection(pc2)
+
+    if (STRESS_KB > 0) {
+      const payload = new Uint8Array(STRESS_KB * 1024)
+      payload[0] = 0xab
+      payload[payload.length - 1] = 0xcd
+      dc1.send(payload)
+      const received = await waitForBinary(dc2, MESSAGE_TIMEOUT_MS)
+      if (received.length !== payload.length || received[0] !== 0xab || received.at(-1) !== 0xcd) {
+        throw new Error(`stress payload mismatch (${received.length} bytes)`)
+      }
+      console.log(`Stress round-trip OK (${STRESS_KB} KiB)`)
+    } else {
+      const state = createStateBuffer()
+      encodePlayerState(state.view, 0, {
+        tick: 42,
+        playerId: 7,
+        x: 12.5,
+        y: -3.25,
+        rot: 1.57,
+      })
+      dc1.send(state.bytes)
+      const received = await waitForBinary(dc2, MESSAGE_TIMEOUT_MS)
+      if (received.length !== PLAYER_STATE_FRAME_BYTES) {
+        throw new Error(`expected ${PLAYER_STATE_FRAME_BYTES} bytes, got ${received.length}`)
+      }
+      const decoded = decodePlayerState(received)
+      if (decoded.tick !== 42 || decoded.playerId !== 7) {
+        throw new Error(`decoded mismatch: ${JSON.stringify(decoded)}`)
+      }
+      console.log('Binary player-state round-trip OK:', decoded)
+    }
+
+    await cleanup()
+    process.exit(0)
+  } catch (error) {
+    await cleanup().catch(() => undefined)
+    throw error
+  }
+}
+
+void main().catch((error: unknown) => {
+  console.error(error)
+  process.exitCode = 1
+})
diff --git a/examples/shared/game-state-sync.js b/examples/shared/game-state-sync.js
new file mode 100644
index 0000000..8e71b41
--- /dev/null
+++ b/examples/shared/game-state-sync.js
@@ -0,0 +1,34 @@
+/** Browser ESM mirror of game-state-sync.ts for /shared/ static imports. */
+
+export const GAME_SYNC_CHANNEL_LABEL = 'game-sync'
+export const PLAYER_STATE_FRAME_BYTES = 20
+
+export function createStateBuffer() {
+  const buffer = new ArrayBuffer(PLAYER_STATE_FRAME_BYTES)
+  const view = new DataView(buffer)
+  const bytes = new Uint8Array(buffer)
+  return { buffer, view, bytes }
+}
+
+export function encodePlayerState(view, offset, state) {
+  view.setUint32(offset, state.tick >>> 0, true)
+  view.setUint16(offset + 4, state.playerId & 0xffff, true)
+  view.setUint16(offset + 6, 0, true)
+  view.setFloat32(offset + 8, state.x, true)
+  view.setFloat32(offset + 12, state.y, true)
+  view.setFloat32(offset + 16, state.rot, true)
+}
+
+export function decodePlayerState(source, offset = 0) {
+  const view =
+    source instanceof ArrayBuffer
+      ? new DataView(source, offset, PLAYER_STATE_FRAME_BYTES)
+      : new DataView(source.buffer, source.byteOffset + offset, PLAYER_STATE_FRAME_BYTES)
+  return {
+    tick: view.getUint32(0, true),
+    playerId: view.getUint16(4, true),
+    x: view.getFloat32(8, true),
+    y: view.getFloat32(12, true),
+    rot: view.getFloat32(16, true),
+  }
+}
diff --git a/examples/shared/game-state-sync.ts b/examples/shared/game-state-sync.ts
new file mode 100644
index 0000000..0659c60
--- /dev/null
+++ b/examples/shared/game-state-sync.ts
@@ -0,0 +1,62 @@
+/**
+ * Fixed-size binary player state frames for multiplayer DataChannel demos.
+ *
+ * Layout (little-endian, 20 bytes):
+ * - u32 tick
+ * - u16 playerId
+ * - u16 reserved
+ * - f32 x
+ * - f32 y
+ * - f32 rot
+ *
+ * Reuse {@link createStateBuffer} and mutate via `view` each tick — send `bytes`
+ * without JSON or per-frame allocations.
+ */
+
+export const GAME_SYNC_CHANNEL_LABEL = 'game-sync'
+export const PLAYER_STATE_FRAME_BYTES = 20
+
+export interface PlayerState {
+  tick: number
+  playerId: number
+  x: number
+  y: number
+  rot: number
+}
+
+export interface StateBuffer {
+  buffer: ArrayBuffer
+  view: DataView
+  /** Send this view on the data channel each tick. */
+  bytes: Uint8Array
+}
+
+export function createStateBuffer(): StateBuffer {
+  const buffer = new ArrayBuffer(PLAYER_STATE_FRAME_BYTES)
+  const view = new DataView(buffer)
+  const bytes = new Uint8Array(buffer)
+  return { buffer, view, bytes }
+}
+
+export function encodePlayerState(view: DataView, offset: number, state: PlayerState): void {
+  view.setUint32(offset, state.tick >>> 0, true)
+  view.setUint16(offset + 4, state.playerId & 0xffff, true)
+  view.setUint16(offset + 6, 0, true)
+  view.setFloat32(offset + 8, state.x, true)
+  view.setFloat32(offset + 12, state.y, true)
+  view.setFloat32(offset + 16, state.rot, true)
+}
+
+export function decodePlayerState(source: ArrayBuffer | Uint8Array, offset = 0): PlayerState {
+  const view =
+    source instanceof ArrayBuffer
+      ? new DataView(source, offset, PLAYER_STATE_FRAME_BYTES)
+      : new DataView(source.buffer, source.byteOffset + offset, PLAYER_STATE_FRAME_BYTES)
+  return {
+    tick: view.getUint32(0, true),
+    playerId: view.getUint16(4, true),
+    x: view.getFloat32(8, true),
+    y: view.getFloat32(12, true),
+    rot: view.getFloat32(16, true),
+  }
+}
diff --git a/packages/bindings/src/data_channel.rs b/packages/bindings/src/data_channel.rs
index bb1228e..38d107f 100644
--- a/packages/bindings/src/data_channel.rs
+++ b/packages/bindings/src/data_channel.rs
@@ -179,11 +179,10 @@ impl JsRTCDataChannel {
                 to_js_unknown(&ctx.env, ctx.env.create_string(text)?)
                     .map(|value| vec![value])
             } else {
-                Ok(vec![
-                    ctx.env
-                        .create_buffer_with_data(message.data.to_vec())?
-                        .into_unknown(),
-                ])
+                // Move webrtc-rs Bytes into a Node Buffer; use `.into()` to avoid napi `into_vec` name clash.
+                let vec: Vec<u8> = message.data.into();
+                let buffer = Buffer::from(vec);
+                to_js_unknown(&ctx.env, buffer).map(|value| vec![value])
             }
         })?;
         wire_event_channel(rx, tsfn);
diff --git a/packages/helpers/src/index.ts b/packages/helpers/src/index.ts
index 0b3e4c2..a8dbedb 100644
--- a/packages/helpers/src/index.ts
+++ b/packages/helpers/src/index.ts
@@ -15,7 +15,7 @@ export {
   type VoiceAgentSessionHostOptions,
 } from './voice-agent-session-host.js'
 
-export { type VoiceSessionContext, type VoiceSessionHandler } from './voice-session-handler.js'
+export { type VoiceSessionContext, type VoiceSessionHandler, type DataChannelKind } from './voice-session-handler.js'
 
 export {
   SessionPod,
diff --git a/packages/helpers/src/session-pod.ts b/packages/helpers/src/session-pod.ts
index 7b51617..fed9821 100644
--- a/packages/helpers/src/session-pod.ts
+++ b/packages/helpers/src/session-pod.ts
@@ -16,7 +16,7 @@ import {
   type VoiceSessionBudget,
   type VoiceSessionBudgetSnapshot,
 } from './voice-session-budget.js'
-import { VOICE_AGENT_SERVER_PEER_ID, VoiceAgentSessionHost } from './voice-agent-session-host.js'
+import { VOICE_AGENT_SERVER_PEER_ID, VoiceAgentSessionHost, type VoiceAgentSessionHostOptions } from './voice-agent-session-host.js'
 import type { VoiceSessionHandler } from './voice-session-handler.js'
 
 interface IceServerConfig {
@@ -38,6 +38,8 @@ export interface SessionPodOptions {
   sessionBudget?: VoiceSessionBudget
   /** Per-tab STT/TTS logic (same handler instance for every room in this pod). */
   voiceHandler?: VoiceSessionHandler
+  /** Optional binary sync data channel per WebRTC connection. */
+  syncChannel?: VoiceAgentSessionHostOptions['syncChannel']
   log?: (message: string) => void
 }
 
@@ -114,6 +116,7 @@ export class SessionPod {
       voiceConfig: this.options.voiceConfig,
       sessionBudget: this.sessionBudget,
       voiceHandler: this.options.voiceHandler,
+      syncChannel: this.options.syncChannel,
       log: this.options.log,
     })
 
diff --git a/packages/helpers/src/voice-agent-session-host.ts b/packages/helpers/src/voice-agent-session-host.ts
index c0f9119..6bde65b 100644
--- a/packages/helpers/src/voice-agent-session-host.ts
+++ b/packages/helpers/src/voice-agent-session-host.ts
@@ -23,6 +23,7 @@ import {
 import {
   VoiceAgent,
   VOICE_CONTROL_CHANNEL_LABEL,
+  VOICE_SYNC_CHANNEL_LABEL,
   forwardVoiceAgentSpeechToDataChannel,
   speechEventToControlMessage,
   wireVoiceAgentToDataChannel,
@@ -37,7 +38,7 @@ import {
   type VoiceSessionBudget,
   type VoiceSessionBudgetSnapshot,
 } from './voice-session-budget.js'
-import type { VoiceSessionContext, VoiceSessionHandler } from './voice-session-handler.js'
+import type { VoiceSessionContext, VoiceSessionHandler, DataChannelKind } from './voice-session-handler.js'
 
 export const VOICE_AGENT_SERVER_PEER_ID = 'voice-agent-server'
 
@@ -52,10 +53,12 @@ interface ClientSession {
   pc: RTCPeerConnection
   agentOut: LocalAudioTrack
   controlChannel: RTCDataChannel
+  syncChannel?: RTCDataChannel
   agent: VoiceAgent
   inboundTrack?: RemoteAudioTrack
   agentStarted: boolean
   unwireControl?: () => void
+  unwireSync?: () => void
   unwireSpeechForward?: () => void
   remoteDescriptionSet: boolean
   offerSent: boolean
@@ -78,6 +81,15 @@ export interface VoiceAgentSessionHostOptions {
    * See `examples/voice-agent-local-sherpa-multi-client/src/voice-handler.ts`.
    */
   voiceHandler?: VoiceSessionHandler
+  /**
+   * Optional second outbound data channel for high-frequency binary sync.
+   * Defaults to disabled; label {@link VOICE_SYNC_CHANNEL_LABEL} when enabled.
+   */
+  syncChannel?: {
+    enabled?: boolean
+    label?: string
+    ordered?: boolean
+  }
   /**
    * Process-wide connection cap (`VOICE_MAX_CONCURRENT_SESSIONS` when omitted).
    * Shared across rooms when using {@link SessionPod}.
@@ -153,7 +165,7 @@ export class VoiceAgentSessionHost {
     const contexts: VoiceSessionContext[] = []
     for (const [peerId, session] of this.sessions) {
       if (!session.agentStarted) continue
-      contexts.push(this.createSessionContext(peerId, session.agent, session.controlChannel))
+      contexts.push(this.createSessionContext(peerId, session.agent, session.controlChannel, session.syncChannel))
     }
 
     const onBroadcastSpeak = this.options.voiceHandler?.onBroadcastSpeak
@@ -207,12 +219,19 @@ export class VoiceAgentSessionHost {
     const agent = new VoiceAgent(this.options.voiceConfig)
 
     const controlChannel = pc.createDataChannel(VOICE_CONTROL_CHANNEL_LABEL, { ordered: true })
+    const syncEnabled = this.options.syncChannel?.enabled ?? false
+    const syncChannel = syncEnabled
+      ? pc.createDataChannel(this.options.syncChannel?.label ?? VOICE_SYNC_CHANNEL_LABEL, {
+          ordered: this.options.syncChannel?.ordered ?? false,
+        })
+      : undefined
     await pc.addTrack(agentOut)
 
     const session: ClientSession = {
       pc,
       agentOut,
       controlChannel,
+      syncChannel,
       agent,
       agentStarted: false,
       remoteDescriptionSet: false,
@@ -281,10 +300,11 @@ export class VoiceAgentSessionHost {
     controlChannel.onopen = () => {
       this.log(`[voice ${peerId}] control channel open`)
       session.unwireControl?.()
-      const ctx = this.createSessionContext(peerId, agent, controlChannel)
+      const ctx = this.createSessionContext(peerId, agent, controlChannel, syncChannel)
       const voiceHandler = this.options.voiceHandler
       const onSpeakRequest = voiceHandler?.onSpeakRequest
       const onDataChannelMessage = voiceHandler?.onDataChannelMessage
+      const onDataChannelBinary = voiceHandler?.onDataChannelBinary
       session.unwireControl = wireVoiceAgentToDataChannel(agent, controlChannel, {
         onSpeak: onSpeakRequest
           ? (text) => {
@@ -296,15 +316,30 @@ export class VoiceAgentSessionHost {
               void onDataChannelMessage(ctx, payload)
             }
           : undefined,
+        onDataChannelBinary: onDataChannelBinary
+          ? (data) => {
+              void onDataChannelBinary(ctx, data, 'control')
+            }
+          : undefined,
       })
     }
 
+    if (syncChannel) {
+      syncChannel.binaryType = 'arraybuffer'
+      syncChannel.onopen = () => {
+        this.log(`[voice ${peerId}] sync channel open (${syncChannel.label})`)
+      }
+      session.unwireSync = this.wireSyncChannel(peerId, session, syncChannel)
+    }
+
     const offer = await pc.createOffer()
     await pc.setLocalDescription(offer)
     await pc.gatheringComplete()
     this.signaling.sendOffer(peerId, pc.localDescription!.toJSON())
     session.offerSent = true
-    this.log(`[voice ${peerId}] offer sent (audio + ${VOICE_CONTROL_CHANNEL_LABEL} DC)`)
+    this.log(
+      `[voice ${peerId}] offer sent (audio + ${VOICE_CONTROL_CHANNEL_LABEL} DC${syncChannel ? ` + ${syncChannel.label}` : ''})`,
+    )
 
     if (session.pendingAnswer) {
       const sdp = session.pendingAnswer
@@ -339,7 +374,18 @@ export class VoiceAgentSessionHost {
     peerId: string,
     agent: VoiceAgent,
     controlChannel: RTCDataChannel,
+    syncChannel?: RTCDataChannel,
   ): VoiceSessionContext {
+    const sendBinary = (data: Buffer | Uint8Array, channel: DataChannelKind = 'sync') => {
+      const target =
+        channel === 'sync' && syncChannel?.readyState === 'open'
+          ? syncChannel
+          : controlChannel.readyState === 'open'
+            ? controlChannel
+            : null
+      if (!target) return
+      target.send(data)
+    }
     return {
       peerId,
       agent,
@@ -348,6 +394,39 @@ export class VoiceAgentSessionHost {
         if (controlChannel.readyState !== 'open') return
         controlChannel.send(JSON.stringify(payload))
       },
+      sendBinaryToClient: (data, channel) => sendBinary(data, channel),
+    }
+  }
+
+  private wireSyncChannel(
+    peerId: string,
+    session: ClientSession,
+    syncChannel: RTCDataChannel,
+  ): () => void {
+    const onDataChannelBinary = this.options.voiceHandler?.onDataChannelBinary
+    if (!onDataChannelBinary) {
+      return () => undefined
+    }
+    const ctx = this.createSessionContext(
+      peerId,
+      session.agent,
+      session.controlChannel,
+      syncChannel,
+    )
+    const previousOnMessage = syncChannel.onmessage
+    syncChannel.onmessage = (event) => {
+      previousOnMessage?.(event)
+      if (typeof event.data === 'string') return
+      const binary =
+        event.data instanceof ArrayBuffer
+          ? Buffer.from(event.data)
+          : Buffer.isBuffer(event.data)
+            ? event.data
+            : Buffer.from(event.data as Uint8Array)
+      void onDataChannelBinary(ctx, binary, 'sync')
+    }
+    return () => {
+      syncChannel.onmessage = previousOnMessage
     }
   }
 
@@ -360,7 +439,7 @@ export class VoiceAgentSessionHost {
       return forwardVoiceAgentSpeechToDataChannel(session.agent, session.controlChannel)
     }
 
-    const ctx = this.createSessionContext(peerId, session.agent, session.controlChannel)
+    const ctx = this.createSessionContext(peerId, session.agent, session.controlChannel, session.syncChannel)
     let active = true
 
     void (async () => {
@@ -456,6 +535,7 @@ export class VoiceAgentSessionHost {
     session.resolveMicTrack = undefined
     session.rejectMicTrack = undefined
     session.unwireControl?.()
+    session.unwireSync?.()
     session.unwireSpeechForward?.()
     void session.agent.stop().catch(() => undefined)
     session.pc.close()
diff --git a/packages/helpers/src/voice-session-handler.ts b/packages/helpers/src/voice-session-handler.ts
index 13b6123..4ccc3f3 100644
--- a/packages/helpers/src/voice-session-handler.ts
+++ b/packages/helpers/src/voice-session-handler.ts
@@ -6,6 +6,9 @@
 
 import type { VoiceAgent, SpeechEvent } from '@node-webrtc-rust/sdk/voice'
 
+/** Which WebRTC data channel carried a binary payload. */
+export type DataChannelKind = 'control' | 'sync'
+
 /** Per-browser-tab context passed into your handlers. */
 export interface VoiceSessionContext {
   /** Signaling peer id (e.g. `client-tab1`). */
@@ -16,6 +19,8 @@ export interface VoiceSessionContext {
   speak: (text: string) => Promise<void>
   /** Send a JSON payload to the browser over the voice-control data channel. */
   sendToClient: (payload: unknown) => void
+  /** Send raw bytes — prefers the sync channel when negotiated and open. */
+  sendBinaryToClient: (data: Buffer | Uint8Array, channel?: DataChannelKind) => void
 }
 
 /**
@@ -46,6 +51,15 @@ export interface VoiceSessionHandler {
     payload: string,
   ) => void | Promise<void>
 
+  /**
+   * Called for binary payloads on the voice-control or sync data channel.
+   */
+  onDataChannelBinary?: (
+    ctx: VoiceSessionContext,
+    data: Buffer,
+    channel: DataChannelKind,
+  ) => void | Promise<void>
+
   /**
    * Called only for an explicit broadcast command (e.g. `POST /api/broadcast-speak`).
    * Use `contexts` to TTS every connected tab — never use this path for STT replies.
diff --git a/packages/sdk/src/RTCDataChannel.ts b/packages/sdk/src/RTCDataChannel.ts
index 29e82f8..67794bc 100644
--- a/packages/sdk/src/RTCDataChannel.ts
+++ b/packages/sdk/src/RTCDataChannel.ts
@@ -94,14 +94,7 @@ export class RTCDataChannel extends EventEmitter {
       return
     }
     this.bufferedAmount += byteLength
-    const payload =
-      typeof data === 'string'
-        ? data
-        : Buffer.isBuffer(data)
-          ? data
-          : data instanceof ArrayBuffer
-            ? Buffer.from(new Uint8Array(data))
-            : Buffer.from(data)
+    const payload = toNativeSendPayload(data)
     void this.native
       .send(payload)
       .then(() => this.refreshBufferedAmount())
@@ -147,7 +140,7 @@ export class RTCDataChannel extends EventEmitter {
         `label=${this.label}, type=${typeof data === 'string' ? 'string' : 'binary'}`,
       )
       const message: MessageEvent =
-        typeof data === 'string' ? { data } : { data: Buffer.from(data) }
+        typeof data === 'string' ? { data } : { data: toMessageBinaryData(data, this.binaryType) }
       this.onmessage?.(message)
       this.emit('message', message)
     })
@@ -191,6 +184,26 @@ export class RTCDataChannel extends EventEmitter {
   }
 }
 
+function toNativeSendPayload(data: SendPayload): string | Buffer {
+  if (typeof data === 'string') {
+    return data
+  }
+  if (Buffer.isBuffer(data)) {
+    return data
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(new Uint8Array(data))
+  }
+  return Buffer.from(data.buffer, data.byteOffset, data.byteLength)
+}
+
+function toMessageBinaryData(data: Buffer, binaryType: 'arraybuffer' | 'blob'): Buffer | ArrayBuffer {
+  if (binaryType === 'arraybuffer') {
+    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength) as ArrayBuffer
+  }
+  return data
+}
+
 function payloadByteLength(data: SendPayload): number {
   if (typeof data === 'string') {
     return Buffer.byteLength(data)
diff --git a/packages/sdk/src/types.ts b/packages/sdk/src/types.ts
index ef9b73b..9535362 100644
--- a/packages/sdk/src/types.ts
+++ b/packages/sdk/src/types.ts
@@ -134,7 +134,7 @@ export interface RTCDataChannelEvent {
 }
 
 /** Incoming data channel message. */
-export interface MessageEvent<T = string | Buffer> {
+export interface MessageEvent<T = string | Buffer | ArrayBuffer> {
   data: T
 }
 
diff --git a/packages/sdk/src/voice/index.ts b/packages/sdk/src/voice/index.ts
index 879691f..dbc4b48 100644
--- a/packages/sdk/src/voice/index.ts
+++ b/packages/sdk/src/voice/index.ts
@@ -25,6 +25,7 @@ export { isVoiceDebugEnabled, voiceDebugLog } from './debug.js'
 /** Browser ↔ Node control channel helpers (`voice-control` label). */
 export {
   VOICE_CONTROL_CHANNEL_LABEL,
+  VOICE_SYNC_CHANNEL_LABEL,
   forwardVoiceAgentSpeechToDataChannel,
   parseVoiceControlClientMessage,
   speechEventToControlMessage,
diff --git a/packages/sdk/src/voice/speech-event-bridge.ts b/packages/sdk/src/voice/speech-event-bridge.ts
index 2a549d3..092d910 100644
--- a/packages/sdk/src/voice/speech-event-bridge.ts
+++ b/packages/sdk/src/voice/speech-event-bridge.ts
@@ -14,6 +14,9 @@ import type { SpeechEvent, SpeechEventType } from './types'
 /** Data channel label used by `examples/voice-agent-browser` and recommended for apps. */
 export const VOICE_CONTROL_CHANNEL_LABEL = 'voice-control'
 
+/** Optional high-frequency binary sync channel (see {@link VOICE_SYNC_CHANNEL_LABEL}). */
+export const VOICE_SYNC_CHANNEL_LABEL = 'voicethere-sync'
+
 /** Client → server: request TTS playback on the agent outbound track. */
 export interface VoiceControlSpeakMessage {
   type: 'speak'
@@ -68,6 +71,8 @@ export interface WireVoiceAgentToDataChannelOptions {
   onSpeak?: (text: string) => void | Promise<void>
   /** Called for other JSON payloads on the voice-control channel. */
   onDataChannelMessage?: (payload: string) => void | Promise<void>
+  /** Called for binary payloads on the voice-control channel. */
+  onDataChannelBinary?: (data: Buffer) => void | Promise<void>
 }
 
 function sendSpeechEventToChannel(channel: RTCDataChannel, event: SpeechEvent): void {
@@ -119,17 +124,27 @@ export function wireVoiceControlSpeakHandler(
   const previousOnMessage = channel.onmessage
   channel.onmessage = (event: MessageEvent) => {
     previousOnMessage?.(event)
-    const payload =
-      typeof event.data === 'string'
-        ? event.data
-        : event.data instanceof ArrayBuffer
-          ? Buffer.from(event.data).toString('utf8')
-          : String(event.data)
-
-    const message = parseVoiceControlClientMessage(payload)
+    if (typeof event.data !== 'string') {
+      const binary =
+        event.data instanceof ArrayBuffer
+          ? Buffer.from(event.data)
+          : Buffer.isBuffer(event.data)
+            ? event.data
+            : Buffer.from(event.data as Uint8Array)
+      if (options?.onDataChannelBinary) {
+        void options.onDataChannelBinary(binary)
+        return
+      }
+      if (options?.onDataChannelMessage) {
+        void options.onDataChannelMessage(binary.toString('utf8'))
+      }
+      return
+    }
+
+    const message = parseVoiceControlClientMessage(event.data)
     if (!message) {
       if (options?.onDataChannelMessage) {
-        void options.onDataChannelMessage(payload)
+        void options.onDataChannelMessage(event.data)
       }
       return
     }
diff --git a/packages/sdk/tests/e2e.test.ts b/packages/sdk/tests/e2e.test.ts
index deb9bf7..3c6fea6 100644
--- a/packages/sdk/tests/e2e.test.ts
+++ b/packages/sdk/tests/e2e.test.ts
@@ -61,6 +61,59 @@ describe('End-to-end peer connection', () => {
     sig2.disconnect()
   })
 
+  test('two peers exchange binary DataChannel payloads via signaling', async () => {
+    const pc1 = new RTCPeerConnection(defaultIceConfig)
+    const pc2 = new RTCPeerConnection(defaultIceConfig)
+
+    const dc1 = pc1.createDataChannel('binary-test')
+
+    const sig1 = new SignalingClient({
+      url: `ws://localhost:${server.port}`,
+      room: 'e2e-binary',
+      peerId: 'pc1',
+    })
+    const sig2 = new SignalingClient({
+      url: `ws://localhost:${server.port}`,
+      room: 'e2e-binary',
+      peerId: 'pc2',
+    })
+
+    autoNegotiate({ pc: pc1, signaling: sig1, polite: false })
+    autoNegotiate({ pc: pc2, signaling: sig2, polite: true })
+
+    const dc2Promise = new Promise<typeof dc1>((resolve) => {
+      pc2.ondatachannel = (event) => resolve(event.channel)
+    })
+
+    await sig1.connect()
+    await sig2.connect()
+
+    const dc2 = await dc2Promise
+
+    await waitForOpen(dc1)
+    await waitForOpen(dc2)
+    await waitForConnection(pc1)
+    await waitForConnection(pc2)
+
+    dc1.binaryType = 'arraybuffer'
+    dc2.binaryType = 'arraybuffer'
+
+    const payload = new Uint8Array([0xde, 0xad, 0xbe, 0xef])
+    dc1.send(payload)
+
+    const message = await waitForMessage(dc2)
+    expect(typeof message.data).not.toBe('string')
+    const received = Buffer.isBuffer(message.data)
+      ? message.data
+      : Buffer.from(message.data as ArrayBuffer)
+    expect(received.equals(payload)).toBe(true)
+
+    pc1.close()
+    pc2.close()
+    sig1.disconnect()
+    sig2.disconnect()
+  })
+
   test('two peers exchange an audio track via signaling', async () => {
     const pc1 = new RTCPeerConnection(defaultIceConfig)
     const pc2 = new RTCPeerConnection(defaultIceConfig)