@basmilius/apple-airplay 0.1.3 → 0.2.0

package/dist/index.js

@@ -9,30 +9,12 @@ var __export = (target, all) => {
     });
 };
 
-// src/dataStreamMessages.ts
-var exports_dataStreamMessages = {};
-__export(exports_dataStreamMessages, {
-  wakeDevice: () => wakeDevice,
-  setVolumeMuted: () => setVolumeMuted,
-  setVolume: () => setVolume,
-  setReadyState: () => setReadyState,
-  setConnectionState: () => setConnectionState,
-  sendHIDEvent: () => sendHIDEvent,
-  sendCommand: () => sendCommand,
-  sendButtonEvent: () => sendButtonEvent,
-  protocol: () => protocol,
-  playbackQueueRequest: () => playbackQueueRequest,
-  notification: () => notification,
-  getVolumeMuted: () => getVolumeMuted,
-  getVolume: () => getVolume,
-  getState: () => getState,
-  getExtension: () => getExtension,
-  deviceInfo: () => deviceInfo,
-  configureConnection: () => configureConnection,
-  clientUpdatesConfig: () => clientUpdatesConfig
-});
-import { uint16ToBE, uuid } from "@basmilius/apple-common";
-import { create, getExtension as _getExtension, setExtension } from "@bufbuild/protobuf";
+// src/baseStream.ts
+import { Chacha20, ENCRYPTION, EncryptionAwareConnection } from "@basmilius/apple-common";
+
+// src/utils.ts
+import { Plist } from "@basmilius/apple-encoding";
+import { fromBinary } from "@bufbuild/protobuf";
 
 // src/proto/index.ts
 var exports_proto = {};
@@ -1498,381 +1480,304 @@ import { extDesc as extDesc63, fileDesc as fileDesc90, messageDesc as messageDes
 var file_WakeDeviceMessage = /* @__PURE__ */ fileDesc90("ChdXYWtlRGV2aWNlTWVzc2FnZS5wcm90byITChFXYWtlRGV2aWNlTWVzc2FnZTpSChF3YWtlRGV2aWNlTWVzc2FnZRIQLlByb3RvY29sTWVzc2FnZRgtIAEoCzISLldha2VEZXZpY2VNZXNzYWdlUhF3YWtlRGV2aWNlTWVzc2FnZQ", [file_ProtocolMessage]);
 var WakeDeviceMessageSchema = /* @__PURE__ */ messageDesc90(file_WakeDeviceMessage, 0);
 var wakeDeviceMessage = /* @__PURE__ */ extDesc63(file_WakeDeviceMessage, 0);
-// src/dataStreamMessages.ts
-function protocol(type, errorCode = 0 /* NoError */) {
-  return create(ProtocolMessageSchema, {
-    type,
-    errorCode,
-    identifier: uuid().toUpperCase(),
-    uniqueIdentifier: uuid().toUpperCase()
-  });
-}
-function clientUpdatesConfig(artworkUpdates = true, nowPlayingUpdates = true, volumeUpdates = true, keyboardUpdates = false, outputDeviceUpdates = true, systemEndpointUpdates = true) {
-  const protocolMessage = protocol(16 /* CLIENT_UPDATES_CONFIG_MESSAGE */);
-  const message = create(ClientUpdatesConfigMessageSchema, {
-    artworkUpdates,
-    nowPlayingUpdates,
-    volumeUpdates,
-    keyboardUpdates,
-    outputDeviceUpdates,
-    systemEndpointUpdates
-  });
-  setExtension(protocolMessage, clientUpdatesConfigMessage, message);
-  return protocolMessage;
-}
-function configureConnection(groupId) {
-  const protocolMessage = protocol(120 /* CONFIGURE_CONNECTION_MESSAGE */);
-  const message = create(ConfigureConnectionMessageSchema, {
-    groupID: groupId
-  });
-  setExtension(protocolMessage, configureConnectionMessage, message);
-  return protocolMessage;
-}
-function deviceInfo(pairingId) {
-  const protocolMessage = protocol(15 /* DEVICE_INFO_MESSAGE */);
-  const message = create(DeviceInfoMessageSchema, {
-    uniqueIdentifier: pairingId.toString(),
-    name: "iPhone van Bas",
-    localizedModelName: "iPhone",
-    systemBuildVersion: "18C66",
-    applicationBundleIdentifier: "com.apple.TVRemote",
-    applicationBundleVersion: "344.28",
-    protocolVersion: 1,
-    lastSupportedMessageType: 129,
-    supportsSystemPairing: true,
-    allowsPairing: true,
-    systemMediaApplication: "com.apple.TVMusic",
-    supportsACL: true,
-    supportsSharedQueue: true,
-    supportsExtendedMotion: true,
-    sharedQueueVersion: 2,
-    deviceClass: 1 /* iPhone */,
-    logicalDeviceCount: 1
-  });
-  setExtension(protocolMessage, deviceInfoMessage, message);
-  return protocolMessage;
-}
-function getState() {
-  const protocolMessage = protocol(3 /* GET_STATE_MESSAGE */);
-  const message = create(GetStateMessageSchema, {});
-  setExtension(protocolMessage, getStateMessage, message);
-  return protocolMessage;
-}
-function getVolume(outputDeviceUID) {
-  const protocolMessage = protocol(49 /* GET_VOLUME_MESSAGE */);
-  const message = create(GetVolumeMessageSchema, {
-    outputDeviceUID
-  });
-  setExtension(protocolMessage, getVolumeMessage, message);
-  return protocolMessage;
-}
-function getVolumeMuted(outputDeviceUID) {
-  const protocolMessage = protocol(126 /* GET_VOLUME_MUTED_MESSAGE */);
-  const message = create(GetVolumeMutedMessageSchema, {
-    outputDeviceUID
-  });
-  setExtension(protocolMessage, getVolumeMutedMessage, message);
-  return protocolMessage;
-}
-function notification(notification2) {
-  const protocolMessage = protocol(11 /* NOTIFICATION_MESSAGE */);
-  const message = create(NotificationMessageSchema, {
-    notification: notification2
-  });
-  setExtension(protocolMessage, notificationMessage, message);
-  return protocolMessage;
-}
-function playbackQueueRequest(location, length, includeMetadata = true, includeLanguageOptions = false) {
-  const protocolMessage = protocol(32 /* PLAYBACK_QUEUE_REQUEST_MESSAGE */);
-  const message = create(PlaybackQueueRequestMessageSchema, {
-    location,
-    length,
-    includeMetadata,
-    includeLanguageOptions,
-    artworkHeight: 600,
-    artworkWidth: 600,
-    includeInfo: true,
-    includeLyrics: false,
-    includeSections: false,
-    includeAlignments: false,
-    includeAvailableArtworkFormats: true,
-    includeParticipants: false,
-    isLegacyNowPlayingInfoRequest: false,
-    returnContentItemAssetsInUserCompletion: true,
-    requestedAnimatedArtworkAssetURLFormats: [
-      "MRContentItemAnimatedArtworkFormatSquare",
-      "MRContentItemAnimatedArtworkFormatTall"
-    ]
-  });
-  setExtension(protocolMessage, playbackQueueRequestMessage, message);
-  return protocolMessage;
-}
-function sendButtonEvent(usagePage, usage, buttonDown) {
-  const protocolMessage = protocol(39 /* SEND_BUTTON_EVENT_MESSAGE */);
-  const message = create(SendButtonEventMessageSchema, {
-    usagePage,
-    usage,
-    buttonDown
-  });
-  setExtension(protocolMessage, sendButtonEventMessage, message);
-  return protocolMessage;
-}
-function sendCommand(command, options) {
-  const protocolMessage = protocol(1 /* SEND_COMMAND_MESSAGE */);
-  const message = create(SendCommandMessageSchema, {
-    command,
-    options
-  });
-  setExtension(protocolMessage, sendCommandMessage, message);
-  return protocolMessage;
-}
-function sendHIDEvent(usePage, usage, down) {
-  const protocolMessage = protocol(8 /* SEND_HID_EVENT_MESSAGE */);
-  const message = create(SendHIDEventMessageSchema, {
-    hidEventData: Buffer.concat([
-      Buffer.from("438922cf08020000", "hex"),
-      Buffer.from("00000000000000000100000000000000020" + "00000200000000300000001000000000000", "hex"),
-      Buffer.concat([
-        uint16ToBE(usePage),
-        uint16ToBE(usage),
-        uint16ToBE(down ? 1 : 0)
-      ]),
-      Buffer.from("0000000000000001000000", "hex")
-    ])
-  });
-  setExtension(protocolMessage, sendHIDEventMessage, message);
-  return protocolMessage;
-}
-function setConnectionState(state = 2 /* Connected */) {
-  const protocolMessage = protocol(38 /* SET_CONNECTION_STATE_MESSAGE */);
-  const message = create(SetConnectionStateMessageSchema, {
-    state
-  });
-  setExtension(protocolMessage, setConnectionStateMessage, message);
-  return protocolMessage;
-}
-function setReadyState() {
-  const protocolMessage = protocol(36 /* SET_READY_STATE_MESSAGE */);
-  const message = create(SetReadyStateMessageSchema, {});
-  setExtension(protocolMessage, readyStateMessage, message);
-  return protocolMessage;
-}
-function setVolume(outputDeviceUID, volume) {
-  const protocolMessage = protocol(51 /* SET_VOLUME_MESSAGE */);
-  const message = create(SetVolumeMessageSchema, {
-    outputDeviceUID,
-    volume
-  });
-  setExtension(protocolMessage, setVolumeMessage, message);
-  return protocolMessage;
-}
-function setVolumeMuted(outputDeviceUID, isMuted) {
-  const protocolMessage = protocol(128 /* SET_VOLUME_MUTED_MESSAGE */);
-  const message = create(SetVolumeMutedMessageSchema, {
-    outputDeviceUID,
-    isMuted
-  });
-  setExtension(protocolMessage, setVolumeMutedMessage, message);
-  return protocolMessage;
-}
-function wakeDevice() {
-  const protocolMessage = protocol(41 /* WAKE_DEVICE_MESSAGE */);
-  const message = create(WakeDeviceMessageSchema, {});
-  setExtension(protocolMessage, wakeDeviceMessage, message);
-  return protocolMessage;
-}
-function getExtension(message, extension) {
-  return _getExtension(message, extension);
-}
-// src/protocol.ts
-import { getMacAddress, reporter as reporter4, uuid as uuid2 } from "@basmilius/apple-common";
-import { Plist as Plist3 } from "@basmilius/apple-encoding";
-
 // src/utils.ts
-import { randomBytes } from "node:crypto";
-function makeHttpHeader(method, path, headers, cseq) {
-  const lines = [];
-  lines.push(`${method} ${path} RTSP/1.0`);
-  lines.push(`CSeq: ${cseq}`);
-  lines.push("User-Agent: AirPlay/320.20");
-  lines.push("X-Apple-ProtocolVersion: 1");
-  lines.push("X-ProtocolVersion: 1");
-  for (const [name, value] of Object.entries(headers)) {
-    lines.push(`${name}: ${value}`);
-  }
-  lines.push("");
-  lines.push("");
-  return lines.join(`\r
-`);
-}
-function makeHttpRequest(buffer) {
-  const headerLength = buffer.indexOf(`\r
-\r
-`);
-  const { headers, method, path } = parseRequestHeaders(buffer.subarray(0, headerLength));
-  let contentLength = headers["Content-Length"] ? Number(headers["Content-Length"]) : 0;
-  if (isNaN(contentLength)) {
-    contentLength = 0;
-  }
-  const requestLength = headerLength + 4 + contentLength;
-  if (buffer.byteLength < requestLength) {
-    return null;
-  }
-  const body = buffer.subarray(headerLength + 4, requestLength);
-  return {
-    headers,
-    method,
-    path,
-    body,
-    requestLength
-  };
-}
-function makeHttpResponse(buffer) {
-  const headerLength = buffer.indexOf(`\r
-\r
-`);
-  const { headers, status, statusText } = parseResponseHeaders(buffer.subarray(0, headerLength));
-  let contentLength = headers["Content-Length"] ? Number(headers["Content-Length"]) : 0;
-  if (isNaN(contentLength)) {
-    contentLength = 0;
-  }
-  const responseLength = headerLength + 4 + contentLength;
-  if (buffer.byteLength < responseLength) {
-    return null;
-  }
-  const body = buffer.subarray(headerLength + 4, responseLength);
-  const response = new Response(body, {
-    status,
-    statusText,
-    headers
-  });
-  return {
-    response,
-    responseLength
-  };
+function generateActiveRemoteId() {
+  return Math.floor(Math.random() * 2 ** 32).toString(10);
 }
-function randomInt32() {
-  return randomBytes(4).readUInt32BE(0);
+function generateDacpId() {
+  return Math.floor(Math.random() * 2 ** 64).toString(16).toUpperCase();
 }
-function randomInt64() {
-  return randomBytes(8).readBigUint64LE(0);
+function generateSessionId() {
+  return Math.floor(Math.random() * 2 ** 32).toString(10);
 }
-function parseHeaders(lines) {
-  const headers = {};
-  for (let i = 0;i < lines.length; i++) {
-    const colon = lines[i].indexOf(":");
-    if (colon <= 0) {
-      continue;
-    }
-    const name = lines[i].substring(0, colon).trim();
-    headers[name] = lines[i].substring(colon + 1).trim();
-  }
-  return headers;
+function nonce(counter) {
+  const nonceArray = new Uint8Array(12);
+  const view = new DataView(nonceArray.buffer);
+  view.setBigUint64(4, BigInt(counter), true);
+  return Buffer.from(nonceArray);
 }
-function parseRequestHeaders(buffer) {
-  const lines = buffer.toString("utf8").split(`\r
-`);
-  const rawRequest = lines[0].match(/^(\S+)\s+(\S+)\s+RTSP\/1\.0$/);
-  const method = rawRequest[1];
-  const path = rawRequest[2];
-  const headers = parseHeaders(lines.slice(1));
-  return {
-    headers,
-    method,
-    path
-  };
+function buildHeader(totalSize, seqno) {
+  const buf = Buffer.alloc(32);
+  buf.writeUInt32BE(totalSize, 0);
+  buf.write("sync", 4, "ascii");
+  buf.fill(0, 8, 16);
+  buf.write("comm", 16, "ascii");
+  buf.writeBigUInt64BE(seqno, 20);
+  buf.writeUInt32BE(0, 28);
+  return buf;
 }
-function parseResponseHeaders(buffer) {
-  const lines = buffer.toString("utf8").split(`\r
-`);
-  const rawStatus = lines[0].match(/(HTTP|RTSP)\/[\d.]+\s+(\d+)\s+(.+)/);
-  const status = Number(rawStatus[2]);
-  const statusText = rawStatus[3];
-  const headers = parseHeaders(lines.slice(1));
-  return {
-    headers,
-    status,
-    statusText
-  };
+function buildReply(seqno) {
+  const header = Buffer.alloc(32);
+  header.writeUInt32BE(0, 0);
+  header.write("rply", 4, "ascii");
+  header.fill(0, 8, 16);
+  header.writeBigUInt64BE(seqno, 20);
+  header.writeUInt32BE(0, 28);
+  const plist = Buffer.from(Plist.serialize(Buffer.alloc(0)));
+  const total = header.length + plist.length;
+  header.writeUInt32BE(total, 0);
+  return Buffer.concat([header, plist]);
 }
-
-// src/dataStream.ts
-import { Chacha20 as Chacha202, ENCRYPTION as ENCRYPTION2, hkdf, reporter } from "@basmilius/apple-common";
-import { Plist } from "@basmilius/apple-encoding";
-import { fromBinary, getExtension as getExtension2, toBinary } from "@bufbuild/protobuf";
-
-// src/stream.ts
-import { Chacha20, ENCRYPTION, EncryptionAwareConnection } from "@basmilius/apple-common";
-
-class AirPlayStream extends EncryptionAwareConnection {
-  get #encryption() {
-    return this[ENCRYPTION];
-  }
-  #buffer = Buffer.alloc(0);
-  async decrypt(data) {
-    if (this.#buffer) {
-      data = Buffer.concat([this.#buffer, data]);
-      this.#buffer = undefined;
-    }
-    let result = Buffer.alloc(0);
-    let offset = 0;
-    while (offset + 2 <= data.length) {
-      const length = data.readUInt16LE(offset);
-      const totalChunkLength = 2 + length + 16;
-      if (offset + totalChunkLength > data.length) {
-        this.#buffer = data.subarray(offset);
-        break;
-      }
-      const aad = data.subarray(offset, offset + 2);
-      const ciphertext = data.subarray(offset + 2, offset + 2 + length);
-      const authTag = data.subarray(offset + 2 + length, offset + 2 + length + 16);
-      const nonce = this.nonce(this.#encryption.readCount++);
-      const plaintext = Chacha20.decrypt(this.#encryption.readKey, nonce, aad, ciphertext, authTag);
-      result = Buffer.concat([result, plaintext]);
-      offset += totalChunkLength;
-    }
-    return result;
+function encodeVarint(value) {
+  if (value < 0) {
+    throw new RangeError("Varint only supports non-negative integers");
   }
-  async encrypt(data) {
-    const total = data.length;
-    let result = Buffer.alloc(0);
-    for (let offset = 0;offset < total; ) {
-      const length = Math.min(total - offset, 1024);
-      const leLength = Buffer.alloc(2);
-      leLength.writeUInt16LE(length, 0);
-      const nonce = this.nonce(this.#encryption.writeCount++);
-      const encrypted = Chacha20.encrypt(this.#encryption.writeKey, nonce, leLength, data.subarray(offset, offset + length));
-      offset += length;
-      result = Buffer.concat([result, leLength, encrypted.ciphertext, encrypted.authTag]);
-    }
-    return result;
+  const bytes = [];
+  while (value > 127) {
+    bytes.push(value & 127 | 128);
+    value >>>= 7;
   }
-  nonce(counter) {
-    const nonceArray = new Uint8Array(12);
-    const view = new DataView(nonceArray.buffer);
-    view.setBigUint64(4, BigInt(counter), true);
-    return Buffer.from(nonceArray);
+  bytes.push(value);
+  return Uint8Array.from(bytes);
+}
+function parseHeaderSeqno(header) {
+  if (header.length < 28) {
+    throw new Error("Header too short");
+  }
+  return header.readBigUInt64BE(20);
+}
+function parseMessages(content) {
+  const messages = [];
+  let offset = 0;
+  while (offset < content.length) {
+    const firstByte = content[offset];
+    if (firstByte === 8) {
+      const message2 = content.subarray(offset);
+      const decoded2 = fromBinary(ProtocolMessageSchema, message2, { readUnknownFields: true });
+      messages.push(decoded2);
+      break;
+    }
+    const [length, variantLen] = readVariant(content, offset);
+    offset += variantLen;
+    if (offset + length > content.length) {
+      break;
+    }
+    const message = content.subarray(offset, offset + length);
+    offset += length;
+    const decoded = fromBinary(ProtocolMessageSchema, message, { readUnknownFields: true });
+    messages.push(decoded);
+  }
+  return messages;
+}
+function readVariant(buf, offset = 0) {
+  let result = 0;
+  let shift = 0;
+  let bytesRead = 0;
+  while (true) {
+    const byte = buf[offset + bytesRead++];
+    result |= (byte & 127) << shift;
+    if ((byte & 128) === 0) {
+      break;
+    }
+    shift += 7;
+  }
+  return [result, bytesRead];
+}
+
+// src/baseStream.ts
+class BaseStream extends EncryptionAwareConnection {
+  get #encryptionState() {
+    return this[ENCRYPTION];
+  }
+  decrypt(data) {
+    const result = [];
+    let offset = 0;
+    let readCount = this.#encryptionState.readCount ?? 0;
+    while (offset < data.length) {
+      if (offset + 2 > data.length) {
+        this.context.logger.warn("Expected frame length to be within buffer bounds.");
+        return false;
+      }
+      const frameLength = data.readUInt16LE(offset);
+      offset += 2;
+      const end = offset + frameLength + 16;
+      if (end > data.length) {
+        this.context.logger.warn(`Truncated frame end=${end} length=${data.length}`);
+        return false;
+      }
+      const ciphertext = data.subarray(offset, offset + frameLength);
+      const authTag = data.subarray(offset + frameLength, end);
+      offset = end;
+      const plaintext = Chacha20.decrypt(this.#encryptionState.readKey, nonce(readCount++), Buffer.from(Uint16Array.of(frameLength).buffer.slice(0, 2)), ciphertext, authTag);
+      result.push(plaintext);
+    }
+    this.#encryptionState.readCount = readCount;
+    return Buffer.concat(result);
+  }
+  encrypt(data) {
+    const FRAME_LENGTH = 1024;
+    const result = [];
+    for (let offset = 0;offset < data.length; ) {
+      const frame = data.subarray(offset, offset + FRAME_LENGTH);
+      offset += frame.length;
+      const leLength = Buffer.alloc(2);
+      leLength.writeUInt16LE(frame.length, 0);
+      const encrypted = Chacha20.encrypt(this.#encryptionState.writeKey, nonce(this.#encryptionState.writeCount++), leLength, frame);
+      result.push(leLength, encrypted.ciphertext, encrypted.authTag);
+    }
+    return Buffer.concat(result);
+  }
+}
+// src/controlStream.ts
+import { HTTP_TIMEOUT } from "@basmilius/apple-common";
+import { RTSP } from "@basmilius/apple-encoding";
+class ControlStream extends BaseStream {
+  get activeRemoteId() {
+    return this.#activeRemoteId;
+  }
+  get dacpId() {
+    return this.#dacpId;
+  }
+  get sessionId() {
+    return this.#sessionId;
+  }
+  #activeRemoteId;
+  #dacpId;
+  #sessionId;
+  #buffer = Buffer.alloc(0);
+  #cseq = 0;
+  #requesting = false;
+  #requestTimer;
+  #reject;
+  #resolve;
+  constructor(context, address, port) {
+    super(context, address, port);
+    this.#activeRemoteId = generateActiveRemoteId();
+    this.#dacpId = generateDacpId();
+    this.#sessionId = generateSessionId();
+    this.on("close", this.#onClose.bind(this));
+    this.on("data", this.#onData.bind(this));
+    this.on("error", this.#onError.bind(this));
+    this.on("timeout", this.#onTimeout.bind(this));
+  }
+  async get(path, headers = {}, timeout = HTTP_TIMEOUT) {
+    return await this.#request("GET", path, null, headers, timeout);
+  }
+  async post(path, body = null, headers = {}, timeout = HTTP_TIMEOUT) {
+    return await this.#request("POST", path, body, headers, timeout);
+  }
+  async record(path, headers = {}, timeout = HTTP_TIMEOUT) {
+    return await this.#request("RECORD", path, null, headers, timeout);
+  }
+  async setup(path, body = null, headers = {}, timeout = HTTP_TIMEOUT) {
+    return await this.#request("SETUP", path, body, headers, timeout);
+  }
+  #handle(data, err) {
+    if (this.#requestTimer) {
+      clearTimeout(this.#requestTimer);
+      this.#requestTimer = undefined;
+    }
+    if (err) {
+      this.#reject?.(err);
+    } else {
+      this.#resolve?.(data);
+    }
+    this.#reject = undefined;
+    this.#resolve = undefined;
+    this.#requesting = false;
+  }
+  async#request(method, path, body, headers, timeout = HTTP_TIMEOUT) {
+    if (this.#requesting) {
+      return Promise.reject(new Error("Another request is currently being made."));
+    }
+    this.#requesting = true;
+    headers["Active-Remote"] = this.activeRemoteId;
+    headers["Client-Instance"] = this.dacpId;
+    headers["DACP-ID"] = this.dacpId;
+    const cseq = this.#cseq++;
+    let data;
+    if (body) {
+      headers["Content-Length"] = Buffer.byteLength(body);
+      data = Buffer.concat([
+        Buffer.from(RTSP.makeHeader(method, path, headers, cseq)),
+        Buffer.from(body)
+      ]);
+    } else {
+      headers["Content-Length"] = 0;
+      data = Buffer.from(RTSP.makeHeader(method, path, headers, cseq));
+    }
+    this.context.logger.net("[control]", method, path, `cseq = ${cseq}`);
+    if (this.isEncrypted) {
+      data = this.encrypt(data);
+    }
+    return new Promise(async (resolve, reject) => {
+      this.#reject = reject;
+      this.#resolve = resolve;
+      this.#requestTimer = setTimeout(() => this.#handle(undefined, new Error("Request timed out")), timeout);
+      await this.write(data).catch((err) => this.#handle(undefined, err));
+    });
+  }
+  #onClose() {
+    this.#buffer = Buffer.alloc(0);
+    this.#handle(undefined, new Error("Connection closed."));
+    this.context.logger.net("[control]", "#onClose()");
+  }
+  #onData(data) {
+    try {
+      this.#buffer = Buffer.concat([this.#buffer, data]);
+      if (this.isEncrypted) {
+        const decrypted = this.decrypt(this.#buffer);
+        if (!decrypted) {
+          return;
+        }
+        this.#buffer = decrypted;
+      }
+      while (this.#buffer.byteLength > 0) {
+        const result = RTSP.makeResponse(this.#buffer);
+        if (result === null) {
+          return;
+        }
+        this.#buffer = this.#buffer.subarray(result.responseLength);
+        this.#handle(result.response, undefined);
+      }
+    } catch (err) {
+      this.context.logger.error("[control]", "#onData()", err);
+      this.emit("error", err);
+    }
+  }
+  #onError(err) {
+    this.#handle(undefined, err);
+    this.context.logger.error("[control]", "#onError()", err);
+  }
+  #onTimeout() {
+    this.#handle(undefined, new Error("Request timed out."));
+    this.context.logger.net("[control]", "#onTimeout()");
   }
 }
-
 // src/dataStream.ts
+import { hkdf, randomInt32 } from "@basmilius/apple-common";
+import { Plist as Plist2 } from "@basmilius/apple-encoding";
+import { getExtension, toBinary } from "@bufbuild/protobuf";
 var DATA_HEADER_LENGTH = 32;
 
-class AirPlayDataStream extends AirPlayStream {
-  get #encryption() {
-    return this[ENCRYPTION2];
-  }
-  #bindings;
+class DataStream extends BaseStream {
   #buffer = Buffer.alloc(0);
   #seqno;
   #handler;
-  constructor(address, port) {
-    super(address, port);
+  #handlers = {};
+  constructor(context, address, port) {
+    super(context, address, port);
     this.#seqno = 0x100000000n + BigInt(randomInt32());
-    this.#bindings = {
-      onData: this.#onData.bind(this)
-    };
-    this.on("data", this.#bindings.onData);
+    this.on("data", this.#onData.bind(this));
+    this.#handlers[15 /* DEVICE_INFO_MESSAGE */] = [deviceInfoMessage, this.#onDeviceInfoMessage.bind(this)];
+    this.#handlers[37 /* DEVICE_INFO_UPDATE_MESSAGE */] = [deviceInfoMessage, this.#onDeviceInfoUpdateMessage.bind(this)];
+    this.#handlers[105 /* ORIGIN_CLIENT_PROPERTIES_MESSAGE */] = [originClientPropertiesMessage, this.#onOriginClientPropertiesMessage.bind(this)];
+    this.#handlers[104 /* PLAYER_CLIENT_PROPERTIES_MESSAGE */] = [playerClientPropertiesMessage, this.#onPlayerClientPropertiesMessage.bind(this)];
+    this.#handlers[2 /* SEND_COMMAND_RESULT_MESSAGE */] = [sendCommandResultMessage, this.#onSendCommandResultMessage.bind(this)];
+    this.#handlers[5 /* SET_ARTWORK_MESSAGE */] = [setArtworkMessage, this.#onSetArtworkMessage.bind(this)];
+    this.#handlers[72 /* SET_DEFAULT_SUPPORTED_COMMANDS_MESSAGE */] = [setDefaultSupportedCommandsMessage, this.#onSetDefaultSupportedCommandsMessage.bind(this)];
+    this.#handlers[46 /* SET_NOW_PLAYING_CLIENT_MESSAGE */] = [setNowPlayingClientMessage, this.#onSetNowPlayingClientMessage.bind(this)];
+    this.#handlers[47 /* SET_NOW_PLAYING_PLAYER_MESSAGE */] = [setNowPlayingPlayerMessage, this.#onSetNowPlayingPlayerMessage.bind(this)];
+    this.#handlers[4 /* SET_STATE_MESSAGE */] = [setStateMessage, this.#onSetStateMessage.bind(this)];
+    this.#handlers[53 /* REMOVE_CLIENT_MESSAGE */] = [removeClientMessage, this.#onRemoveClientMessage.bind(this)];
+    this.#handlers[55 /* UPDATE_CLIENT_MESSAGE */] = [updateClientMessage, this.#onUpdateClientMessage.bind(this)];
+    this.#handlers[56 /* UPDATE_CONTENT_ITEM_MESSAGE */] = [updateContentItemMessage, this.#onUpdateContentItemMessage.bind(this)];
+    this.#handlers[57 /* UPDATE_CONTENT_ITEM_ARTWORK_MESSAGE */] = [updateContentItemArtworkMessage, this.#onUpdateContentItemArtworkMessage.bind(this)];
+    this.#handlers[58 /* UPDATE_PLAYER_MESSAGE */] = [updatePlayerMessage, this.#onUpdatePlayerMessage.bind(this)];
+    this.#handlers[65 /* UPDATE_OUTPUT_DEVICE_MESSAGE */] = [updateOutputDeviceMessage, this.#onUpdateOutputDeviceMessage.bind(this)];
+    this.#handlers[17 /* VOLUME_CONTROL_AVAILABILITY_MESSAGE */] = [volumeControlAvailabilityMessage, this.#onVolumeControlAvailabilityMessage.bind(this)];
+    this.#handlers[64 /* VOLUME_CONTROL_CAPABILITIES_DID_CHANGE_MESSAGE */] = [volumeControlCapabilitiesDidChangeMessage, this.#onVolumeControlCapabilitiesDidChangeMessage.bind(this)];
+    this.#handlers[52 /* VOLUME_DID_CHANGE_MESSAGE */] = [volumeDidChangeMessage, this.#onVolumeDidChangeMessage.bind(this)];
   }
   async exchange(message) {
     return new Promise(async (resolve, reject) => {
@@ -1882,25 +1787,32 @@ class AirPlayDataStream extends AirPlayStream {
   }
   async reply(seqno) {
     const rply = buildReply(seqno);
-    reporter.raw(`[datastream] Sending reply for seqno ${seqno}.`);
-    await this.write(await this.#encrypt(rply));
+    this.context.logger.raw("[data]", `Sending reply packet seqno=${seqno}`);
+    await this.write(this.encrypt(rply));
   }
   async send(message) {
-    const bytes = toBinary(ProtocolMessageSchema, message, { writeUnknownFields: true });
-    const lenPrefix = Buffer.from(encodeVarint(bytes.length));
-    const pbPayload = Buffer.concat([lenPrefix, Buffer.from(bytes)]);
-    const plistPayload = Buffer.from(Plist.serialize({
+    let extension;
+    if (Array.isArray(message)) {
+      extension = message[1];
+      message = message[0];
+    }
+    const bytes = toBinary(ProtocolMessageSchema, message, { writeUnknownFields: false });
+    const lengthPrefix = Buffer.from(encodeVarint(bytes.byteLength));
+    const payload = Buffer.concat([lengthPrefix, bytes]);
+    const plistPayload = Buffer.from(Plist2.serialize({
       params: {
-        data: pbPayload.buffer.slice(pbPayload.byteOffset, pbPayload.byteOffset + pbPayload.byteLength)
+        data: payload.buffer.slice(payload.byteOffset, payload.byteOffset + payload.byteLength)
       }
     }));
     const header = buildHeader(DATA_HEADER_LENGTH + plistPayload.byteLength, this.#seqno++);
-    const frame = Buffer.concat([header, plistPayload]);
-    const encrypted = await this.#encrypt(frame);
-    reporter.raw("[datastream] Sending message.", message);
-    await this.write(encrypted);
+    let frame = Buffer.concat([header, plistPayload]);
+    if (this.isEncrypted) {
+      frame = this.encrypt(frame);
+    }
+    this.context.logger.raw("[data]", "Sending message.", message.type, extension ? getExtension(message, extension) : message);
+    await this.write(frame);
   }
-  async setup(sharedSecret, seed) {
+  setup(sharedSecret, seed) {
     const readKey = hkdf({
       hash: "sha512",
       key: sharedSecret,
@@ -1915,103 +1827,32 @@ class AirPlayDataStream extends AirPlayStream {
       salt: Buffer.from(`DataStream-Salt${seed}`),
       info: Buffer.from("DataStream-Output-Encryption-Key")
     });
-    await this.enableEncryption(readKey, writeKey);
-  }
-  async#onDeviceInfoMessage(message) {
-    reporter.info("Connected to device", message.name);
-    this.emit("deviceInfo", message);
-  }
-  async#onDeviceInfoUpdateMessage(message) {
-    reporter.info("Device info update", message);
-    this.emit("deviceInfoUpdate", message);
-  }
-  async#onOriginClientPropertiesMessage(message) {
-    reporter.raw("Origin client properties", message);
-    this.emit("originClientProperties", message);
+    this.enableEncryption(readKey, writeKey);
   }
-  async#onPlayerClientPropertiesMessage(message) {
-    reporter.raw("Player client properties", message);
-    this.emit("playerClientProperties", message);
-  }
-  async#onRemoveClientMessage(message) {
-    reporter.info("Remove client", message);
-    this.emit("removeClient", message);
-  }
-  async#onSendCommandResultMessage(message) {
-    reporter.info("Send command result", message);
-    this.emit("sendCommandResult", message);
-  }
-  async#onSetArtworkMessage(message) {
-    reporter.info("Set artwork", message);
-    this.emit("setArtwork", message);
-  }
-  async#onSetDefaultSupportedCommandsMessage(message) {
-    reporter.info("Set default supported commands", message);
-    this.emit("setDefaultSupportedCommands", message);
-  }
-  async#onSetNowPlayingClientMessage(message) {
-    reporter.info("Set now playing client", message);
-    this.emit("setNowPlayingClient", message);
-  }
-  async#onSetNowPlayingPlayerMessage(message) {
-    reporter.info("Set now playing player", message);
-    this.emit("setNowPlayingPlayer", message);
-  }
-  async#onSetStateMessage(message) {
-    reporter.info("Set state", message);
-    this.emit("setState", message);
-  }
-  async#onUpdateClientMessage(message) {
-    reporter.info("Update client", message);
-    this.emit("updateClient", message);
-  }
-  async#onUpdateContentItemMessage(message) {
-    reporter.info("Update content item", message);
-    this.emit("updateContentItem", message);
-  }
-  async#onUpdateContentItemArtworkMessage(message) {
-    reporter.info("Update content artwork", message);
-    this.emit("updateContentItemArtwork", message);
-  }
-  async#onUpdatePlayerMessage(message) {
-    reporter.info("Update player", message);
-    this.emit("updatePlayer", message);
-  }
-  async#onUpdateOutputDeviceMessage(message) {
-    reporter.info("Update output device", message);
-    this.emit("updateOutputDevice", message);
-  }
-  async#onVolumeControlAvailabilityMessage(message) {
-    reporter.info("Volume control availability", message);
-    this.emit("volumeControlAvailability", message);
-  }
-  async#onVolumeControlCapabilitiesDidChangeMessage(message) {
-    reporter.info("Volume control capabilities did change", message);
-    this.emit("volumeControlCapabilitiesDidChange", message);
-  }
-  async#onVolumeDidChangeMessage(message) {
-    reporter.info("VolumeDidChange message", message);
-    this.emit("volumeDidChange", message);
-  }
-  async#onData(buffer) {
+  async#onData(data) {
     try {
-      this.#buffer = Buffer.concat([this.#buffer, buffer]);
-      this.#buffer = await this.#decrypt(this.#buffer);
+      this.#buffer = Buffer.concat([this.#buffer, data]);
+      if (this.isEncrypted) {
+        const decrypted = this.decrypt(this.#buffer);
+        if (!decrypted) {
+          return;
+        }
+        this.#buffer = decrypted;
+      }
       while (this.#buffer.byteLength > DATA_HEADER_LENGTH) {
         const header = this.#buffer.subarray(0, DATA_HEADER_LENGTH);
         const totalLength = header.readUint32BE();
         if (this.#buffer.byteLength < totalLength) {
-          reporter.warn(`Not enough data yet, waiting on the next frame.. needed=${totalLength} available=${this.#buffer.byteLength} receivedLength=${buffer.byteLength}`);
+          this.context.logger.warn("[data]", `Data packet is too short needed=${totalLength} available=${this.#buffer.byteLength} receivedLength=${data.byteLength}`);
           return;
         }
         const frame = this.#buffer.subarray(DATA_HEADER_LENGTH, totalLength);
-        const plist = Plist.parse(frame.buffer.slice(frame.byteOffset, frame.byteOffset + frame.byteLength));
+        const plist = Plist2.parse(frame.buffer.slice(frame.byteOffset, frame.byteOffset + frame.byteLength));
         const command = header.toString("ascii", 4, 8);
-        reporter.raw("Raw data received", header.toString());
         this.#buffer = this.#buffer.subarray(totalLength);
         if (!plist || !plist.params || !plist.params.data) {
           if (command === "rply") {
-            reporter.raw("Got reply...");
+            this.context.logger.raw("[data]", "Received reply packet.");
           } else if (command === "sync") {
             await this.reply(parseHeaderSeqno(header));
           }
@@ -2023,221 +1864,117 @@ class AirPlayDataStream extends AirPlayStream {
           continue;
         }
         const content = Buffer.from(plist.params.data);
-        for (const message of await parseMessages(content)) {
-          reporter.raw("Parsed message", message);
-          await this.#handleMessage(message);
+        for (const message of parseMessages(content)) {
+          this.context.logger.raw("[data]", `Received message.`, message);
+          this.#handleMessage(message);
         }
         if (command === "sync") {
           await this.reply(parseHeaderSeqno(header));
         }
       }
     } catch (err) {
-      reporter.error("Error in data stream #onData()", err);
+      this.context.logger.error("[data]", "#onData()", err);
       this.emit("error", err);
     }
   }
-  async#decrypt(data) {
-    const result = [];
-    let offset = 0;
-    let readCount = this.#encryption.readCount ?? 0;
-    while (offset < data.length) {
-      if (offset + 2 > data.length) {
-        reporter.warn("Truncated frame length");
-        return this.#buffer;
-      }
-      const frameLength = data.readUInt16LE(offset);
-      offset += 2;
-      const nonce = this.nonce(readCount++);
-      const end = offset + frameLength + 16;
-      if (end > data.length) {
-        reporter.warn(`Truncated frame end=${end} length=${data.length}`);
-        return this.#buffer;
-      }
-      const ciphertext = data.subarray(offset, offset + frameLength);
-      const authTag = data.subarray(offset + frameLength, end);
-      offset = end;
-      const plaintext = Chacha202.decrypt(this.#encryption.readKey, nonce, Buffer.from(Uint16Array.of(frameLength).buffer.slice(0, 2)), ciphertext, authTag);
-      result.push(plaintext);
-    }
-    this.#encryption.readCount = readCount;
-    return Buffer.concat(result);
-  }
-  async#encrypt(data) {
-    const FRAME_LENGTH = 1024;
-    const result = [];
-    for (let offset = 0;offset < data.length; ) {
-      const frame = data.subarray(offset, offset + FRAME_LENGTH);
-      offset += frame.length;
-      const leLength = Buffer.alloc(2);
-      leLength.writeUInt16LE(frame.length, 0);
-      const nonce = this.nonce(this.#encryption.writeCount++);
-      const encrypted = Chacha202.encrypt(this.#encryption.writeKey, nonce, leLength, frame);
-      result.push(leLength, encrypted.ciphertext, encrypted.authTag);
-    }
-    return Buffer.concat(result);
-  }
-  async#handleMessage(message) {
+  #handleMessage(message) {
     if (this.#handler) {
       const [resolve] = this.#handler;
       this.#handler = undefined;
       resolve(message);
     }
-    switch (message.type) {
-      case 15 /* DEVICE_INFO_MESSAGE */:
-        await this.#onDeviceInfoMessage(getExtension2(message, deviceInfoMessage));
-        break;
-      case 37 /* DEVICE_INFO_UPDATE_MESSAGE */:
-        await this.#onDeviceInfoUpdateMessage(getExtension2(message, deviceInfoMessage));
-        break;
-      case 105 /* ORIGIN_CLIENT_PROPERTIES_MESSAGE */:
-        await this.#onOriginClientPropertiesMessage(getExtension2(message, originClientPropertiesMessage));
-        break;
-      case 104 /* PLAYER_CLIENT_PROPERTIES_MESSAGE */:
-        await this.#onPlayerClientPropertiesMessage(getExtension2(message, playerClientPropertiesMessage));
-        break;
-      case 2 /* SEND_COMMAND_RESULT_MESSAGE */:
-        await this.#onSendCommandResultMessage(getExtension2(message, sendCommandResultMessage));
-        break;
-      case 5 /* SET_ARTWORK_MESSAGE */:
-        await this.#onSetArtworkMessage(getExtension2(message, setArtworkMessage));
-        break;
-      case 72 /* SET_DEFAULT_SUPPORTED_COMMANDS_MESSAGE */:
-        await this.#onSetDefaultSupportedCommandsMessage(getExtension2(message, setDefaultSupportedCommandsMessage));
-        break;
-      case 46 /* SET_NOW_PLAYING_CLIENT_MESSAGE */:
-        await this.#onSetNowPlayingClientMessage(getExtension2(message, setNowPlayingClientMessage));
-        break;
-      case 47 /* SET_NOW_PLAYING_PLAYER_MESSAGE */:
-        await this.#onSetNowPlayingPlayerMessage(getExtension2(message, setNowPlayingPlayerMessage));
-        break;
-      case 4 /* SET_STATE_MESSAGE */:
-        await this.#onSetStateMessage(getExtension2(message, setStateMessage));
-        break;
-      case 53 /* REMOVE_CLIENT_MESSAGE */:
-        await this.#onRemoveClientMessage(getExtension2(message, removeClientMessage));
-        break;
-      case 55 /* UPDATE_CLIENT_MESSAGE */:
-        await this.#onUpdateClientMessage(getExtension2(message, updateClientMessage));
-        break;
-      case 56 /* UPDATE_CONTENT_ITEM_MESSAGE */:
-        await this.#onUpdateContentItemMessage(getExtension2(message, updateContentItemMessage));
-        break;
-      case 57 /* UPDATE_CONTENT_ITEM_ARTWORK_MESSAGE */:
-        await this.#onUpdateContentItemArtworkMessage(getExtension2(message, updateContentItemArtworkMessage));
-        break;
-      case 58 /* UPDATE_PLAYER_MESSAGE */:
-        await this.#onUpdatePlayerMessage(getExtension2(message, updatePlayerMessage));
-        break;
-      case 65 /* UPDATE_OUTPUT_DEVICE_MESSAGE */:
-        await this.#onUpdateOutputDeviceMessage(getExtension2(message, updateOutputDeviceMessage));
-        break;
-      case 17 /* VOLUME_CONTROL_AVAILABILITY_MESSAGE */:
-        await this.#onVolumeControlAvailabilityMessage(getExtension2(message, volumeControlAvailabilityMessage));
-        break;
-      case 64 /* VOLUME_CONTROL_CAPABILITIES_DID_CHANGE_MESSAGE */:
-        await this.#onVolumeControlCapabilitiesDidChangeMessage(getExtension2(message, volumeControlCapabilitiesDidChangeMessage));
-        break;
-      case 52 /* VOLUME_DID_CHANGE_MESSAGE */:
-        await this.#onVolumeDidChangeMessage(getExtension2(message, volumeDidChangeMessage));
-        break;
-      case 0 /* UNKNOWN_MESSAGE */:
-        break;
-      default:
-        reporter.warn("Received unknown message.", message);
-        break;
+    if (message.type in this.#handlers) {
+      const [extension, handler] = this.#handlers[message.type];
+      handler(getExtension(message, extension));
+    } else if (message.type !== 0 /* UNKNOWN_MESSAGE */) {
+      this.context.logger.warn("[data]", `Unknown message type ${message.type}.`);
     }
   }
-}
-function buildHeader(totalSize, seqno) {
-  const buf = Buffer.alloc(32);
-  buf.writeUInt32BE(totalSize, 0);
-  buf.write("sync", 4, "ascii");
-  buf.fill(0, 8, 16);
-  buf.write("comm", 16, "ascii");
-  buf.writeBigUInt64BE(seqno, 20);
-  buf.writeUInt32BE(0, 28);
-  return buf;
-}
-function buildReply(seqno) {
-  const header = Buffer.alloc(32);
-  header.writeUInt32BE(0, 0);
-  header.write("rply", 4, "ascii");
-  header.fill(0, 8, 16);
-  header.writeBigUInt64BE(seqno, 20);
-  header.writeUInt32BE(0, 28);
-  const plist = Buffer.from(Plist.serialize(Buffer.alloc(0)));
-  const total = header.length + plist.length;
-  header.writeUInt32BE(total, 0);
-  return Buffer.concat([header, plist]);
-}
-function encodeVarint(value) {
-  if (value < 0) {
-    throw new RangeError("Varint only supports non-negative integers");
+  #onDeviceInfoMessage(message) {
+    this.context.logger.info("[data]", "Connected to device", message.name);
+    this.emit("deviceInfo", message);
   }
-  const bytes = [];
-  while (value > 127) {
-    bytes.push(value & 127 | 128);
-    value >>>= 7;
+  #onDeviceInfoUpdateMessage(message) {
+    this.context.logger.info("[data]", "Device info update", message);
+    this.emit("deviceInfoUpdate", message);
   }
-  bytes.push(value);
-  return Uint8Array.from(bytes);
-}
-function parseHeaderSeqno(header) {
-  if (header.length < 28) {
-    throw new Error("Header too short");
+  #onOriginClientPropertiesMessage(message) {
+    this.context.logger.raw("[data]", "Origin client properties", message);
+    this.emit("originClientProperties", message);
   }
-  return header.readBigUInt64BE(20);
-}
-async function parseMessages(content) {
-  const messages = [];
-  let offset = 0;
-  while (offset < content.length) {
-    const firstByte = content[offset];
-    if (firstByte === 8) {
-      const message2 = content.subarray(offset);
-      const decoded2 = fromBinary(ProtocolMessageSchema, message2, { readUnknownFields: true });
-      messages.push(decoded2);
-      break;
-    }
-    const [length, variantLen] = readVariant(content, offset);
-    offset += variantLen;
-    if (offset + length > content.length) {
-      break;
-    }
-    const message = content.subarray(offset, offset + length);
-    offset += length;
-    const decoded = fromBinary(ProtocolMessageSchema, message, { readUnknownFields: true });
-    messages.push(decoded);
+  #onPlayerClientPropertiesMessage(message) {
+    this.context.logger.raw("[data]", "Player client properties", message);
+    this.emit("playerClientProperties", message);
   }
-  return messages;
-}
-function readVariant(buf, offset = 0) {
-  let result = 0;
-  let shift = 0;
-  let bytesRead = 0;
-  while (true) {
-    const byte = buf[offset + bytesRead++];
-    result |= (byte & 127) << shift;
-    if ((byte & 128) === 0) {
-      break;
-    }
-    shift += 7;
+  #onRemoveClientMessage(message) {
+    this.context.logger.info("[data]", "Remove client", message);
+    this.emit("removeClient", message);
+  }
+  #onSendCommandResultMessage(message) {
+    this.context.logger.info("[data]", "Send command result", message);
+    this.emit("sendCommandResult", message);
+  }
+  #onSetArtworkMessage(message) {
+    this.context.logger.info("[data]", "Set artwork", message);
+    this.emit("setArtwork", message);
+  }
+  #onSetDefaultSupportedCommandsMessage(message) {
+    this.context.logger.info("[data]", "Set default supported commands", message);
+    this.emit("setDefaultSupportedCommands", message);
+  }
+  #onSetNowPlayingClientMessage(message) {
+    this.context.logger.info("[data]", "Set now playing client", message);
+    this.emit("setNowPlayingClient", message);
+  }
+  #onSetNowPlayingPlayerMessage(message) {
+    this.context.logger.info("[data]", "Set now playing player", message);
+    this.emit("setNowPlayingPlayer", message);
+  }
+  #onSetStateMessage(message) {
+    this.context.logger.info("[data]", "Set state", message);
+    this.emit("setState", message);
+  }
+  #onUpdateClientMessage(message) {
+    this.context.logger.info("[data]", "Update client", message);
+    this.emit("updateClient", message);
+  }
+  #onUpdateContentItemMessage(message) {
+    this.context.logger.info("[data]", "Update content item", message);
+    this.emit("updateContentItem", message);
+  }
+  #onUpdateContentItemArtworkMessage(message) {
+    this.context.logger.info("[data]", "Update content artwork", message);
+    this.emit("updateContentItemArtwork", message);
+  }
+  #onUpdatePlayerMessage(message) {
+    this.context.logger.info("[data]", "Update player", message);
+    this.emit("updatePlayer", message);
+  }
+  #onUpdateOutputDeviceMessage(message) {
+    this.context.logger.info("[data]", "Update output device", message);
+    this.emit("updateOutputDevice", message);
+  }
+  #onVolumeControlAvailabilityMessage(message) {
+    this.context.logger.info("[data]", "Volume control availability", message);
+    this.emit("volumeControlAvailability", message);
+  }
+  #onVolumeControlCapabilitiesDidChangeMessage(message) {
+    this.context.logger.info("[data]", "Volume control capabilities did change", message);
+    this.emit("volumeControlCapabilitiesDidChange", message);
+  }
+  #onVolumeDidChangeMessage(message) {
+    this.context.logger.info("[data]", "VolumeDidChange message", message);
+    this.emit("volumeDidChange", message);
   }
-  return [result, bytesRead];
 }
-
 // src/eventStream.ts
-import { hkdf as hkdf2, reporter as reporter2 } from "@basmilius/apple-common";
-import { Plist as Plist2 } from "@basmilius/apple-encoding";
-class AirPlayEventStream extends AirPlayStream {
-  #bindings;
+import { hkdf as hkdf2 } from "@basmilius/apple-common";
+import { Plist as Plist3, RTSP as RTSP2 } from "@basmilius/apple-encoding";
+class EventStream extends BaseStream {
   #buffer = Buffer.alloc(0);
-  constructor(address, port) {
-    super(address, port);
-    this.#bindings = {
-      onData: this.#onData.bind(this)
-    };
-    this.on("data", this.#bindings.onData);
+  constructor(context, address, port) {
+    super(context, address, port);
+    this.on("data", this.#onData.bind(this));
   }
   async respond(response) {
     const body = Buffer.from(await response.arrayBuffer());
@@ -2265,11 +2002,11 @@ class AirPlayEventStream extends AirPlayStream {
       data = Buffer.from(headers);
     }
     if (this.isEncrypted) {
-      data = await this.encrypt(data);
+      data = this.encrypt(data);
     }
     await this.write(data);
   }
-  async setup(sharedSecret) {
+  setup(sharedSecret) {
     const readKey = hkdf2({
       hash: "sha512",
       key: sharedSecret,
@@ -2284,14 +2021,14 @@ class AirPlayEventStream extends AirPlayStream {
       salt: Buffer.from("Events-Salt"),
       info: Buffer.from("Events-Write-Encryption-Key")
     });
-    await this.enableEncryption(writeKey, readKey);
+    this.enableEncryption(writeKey, readKey);
   }
   async#handle(method, path, headers, body) {
     const key = `${method} ${path}`;
     switch (key) {
       case "POST /command":
-        const data = Plist2.parse(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength));
-        reporter2.info("Received event stream request.", data);
+        const data = Plist3.parse(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength));
+        this.context.logger.info("[event]", "Received event stream request.", data);
         const response = new Response(null, {
           status: 200,
           statusText: "OK",
@@ -2303,224 +2040,102 @@ class AirPlayEventStream extends AirPlayStream {
         await this.respond(response);
         break;
       default:
-        reporter2.warn("No handler for url", key);
-        break;
-    }
-  }
-  async#onData(buffer) {
-    try {
-      this.#buffer = Buffer.concat([this.#buffer, buffer]);
-      if (this.isEncrypted) {
-        this.#buffer = await this.decrypt(this.#buffer);
-      }
-      while (this.#buffer.byteLength > 0) {
-        const result = makeHttpRequest(this.#buffer);
-        if (result === null) {
-          return;
-        }
-        this.#buffer = this.#buffer.subarray(result.requestLength);
-        await this.#handle(result.method, result.path, result.headers, result.body);
-      }
-    } catch (err) {
-      reporter2.error("Error in event stream #onData()", err);
-      this.emit("error", err);
-    }
-  }
-}
-
-// src/pairing.ts
-import { AccessoryPair } from "@basmilius/apple-common";
-
-class AirPlayPairing {
-  get internal() {
-    return this.#internal;
-  }
-  get rtsp() {
-    return this.#protocol.rtsp;
-  }
-  #internal;
-  #protocol;
-  #hkp;
-  constructor(protocol2) {
-    this.#internal = new AccessoryPair(this.#request.bind(this));
-    this.#protocol = protocol2;
-  }
-  async start() {
-    await this.#internal.start();
-  }
-  async pin(askPin) {
-    this.#hkp = 3;
-    await this.#pinStart();
-    return this.#internal.pin(askPin);
-  }
-  async pinStart() {
-    this.#hkp = 3;
-    await this.#pinStart();
-  }
-  async transient() {
-    this.#hkp = 4;
-    await this.#pinStart();
-    return this.#internal.transient();
-  }
-  async#pinStart() {
-    const response = await this.rtsp.post("/pair-pin-start", null, {
-      "Content-Type": "application/octet-stream",
-      "X-Apple-HKP": this.#hkp.toString()
-    });
-    if (response.status !== 200) {
-      throw new Error(`Cannot start pairing session. ${response.status} ${response.statusText} ${await response.text()}`);
-    }
-  }
-  async#request(_, data) {
-    const response = await this.rtsp.post("/pair-setup", data, {
-      "Content-Type": "application/octet-stream",
-      "X-Apple-HKP": this.#hkp.toString()
-    });
-    return Buffer.from(await response.arrayBuffer());
-  }
-}
-
-// src/rtsp.ts
-import { HTTP_TIMEOUT, reporter as reporter3 } from "@basmilius/apple-common";
-class AirPlayRTSP extends AirPlayStream {
-  get activeRemote() {
-    return this.#activeRemote;
-  }
-  get dacpId() {
-    return this.#dacpId;
-  }
-  get sessionId() {
-    return this.#sessionId;
-  }
-  #activeRemote;
-  #bindings;
-  #dacpId;
-  #sessionId;
-  #buffer = Buffer.alloc(0);
-  #cseq = 0;
-  #requesting = false;
-  #requestTimer;
-  #reject;
-  #resolve;
-  constructor(address, port) {
-    super(address, port);
-    this.#activeRemote = Math.floor(Math.random() * 2 ** 32).toString(10);
-    this.#dacpId = Math.floor(Math.random() * 2 ** 64).toString(16).toUpperCase();
-    this.#sessionId = Math.floor(Math.random() * 2 ** 32).toString(10);
-    this.#bindings = {
-      onClose: this.#onClose.bind(this),
-      onData: this.#onData.bind(this),
-      onError: this.#onError.bind(this),
-      onTimeout: this.#onTimeout.bind(this)
-    };
-    this.on("close", this.#bindings.onClose);
-    this.on("data", this.#bindings.onData);
-    this.on("error", this.#bindings.onError);
-    this.on("timeout", this.#bindings.onTimeout);
-  }
-  async get(path, headers = {}, timeout = HTTP_TIMEOUT) {
-    return await this.#request("GET", path, null, headers, timeout);
-  }
-  async post(path, body = null, headers = {}, timeout = HTTP_TIMEOUT) {
-    return await this.#request("POST", path, body, headers, timeout);
-  }
-  async record(path, headers = {}, timeout = HTTP_TIMEOUT) {
-    return await this.#request("RECORD", path, null, headers, timeout);
-  }
-  async setup(path, body = null, headers = {}, timeout = HTTP_TIMEOUT) {
-    return await this.#request("SETUP", path, body, headers, timeout);
-  }
-  async#handle(data, err) {
-    if (this.#requestTimer) {
-      clearTimeout(this.#requestTimer);
-      this.#requestTimer = undefined;
-    }
-    if (err) {
-      this.#reject?.(err);
-    } else {
-      this.#resolve?.(data);
-    }
-    this.#reject = undefined;
-    this.#resolve = undefined;
-    this.#requesting = false;
-  }
-  async#request(method, path, body, headers, timeout = HTTP_TIMEOUT) {
-    if (!this.isConnected) {
-      return Promise.reject(new Error("Accessory not connected."));
-    }
-    if (this.#requesting) {
-      return Promise.reject(new Error("Another request is currently being made."));
-    }
-    this.#requesting = true;
-    headers["Active-Remote"] = this.activeRemote;
-    headers["Client-Instance"] = this.dacpId;
-    headers["DACP-ID"] = this.dacpId;
-    const cseq = this.#cseq++;
-    let data;
-    if (body) {
-      headers["Content-Length"] = Buffer.byteLength(body).toString();
-      data = Buffer.concat([
-        Buffer.from(makeHttpHeader(method, path, headers, cseq)),
-        Buffer.from(body)
-      ]);
-    } else {
-      headers["Content-Length"] = "0";
-      data = Buffer.from(makeHttpHeader(method, path, headers, cseq));
-    }
-    reporter3.net("[rtsp]", method, path, `cseq = ${cseq}`);
-    if (this.isEncrypted) {
-      data = await this.encrypt(data);
+        this.context.logger.warn("[event]", "No handler for url", key);
+        break;
     }
-    return new Promise(async (resolve, reject) => {
-      this.#reject = reject;
-      this.#resolve = resolve;
-      this.#requestTimer = setTimeout(() => this.#handle(undefined, new Error("Request timed out")), timeout);
-      await this.write(data).catch((err) => this.#handle(undefined, err));
-    });
-  }
-  async#onClose() {
-    this.#buffer = Buffer.alloc(0);
-    await this.#handle(undefined, new Error("Connection closed."));
   }
-  async#onData(buffer) {
+  async#onData(data) {
     try {
-      this.#buffer = Buffer.concat([this.#buffer, buffer]);
+      this.#buffer = Buffer.concat([this.#buffer, data]);
       if (this.isEncrypted) {
-        this.#buffer = await this.decrypt(this.#buffer);
+        const decrypted = this.decrypt(this.#buffer);
+        if (!decrypted) {
+          return;
+        }
+        this.#buffer = decrypted;
       }
       while (this.#buffer.byteLength > 0) {
-        const result = makeHttpResponse(this.#buffer);
+        const result = RTSP2.makeRequest(this.#buffer);
         if (result === null) {
           return;
         }
-        this.#buffer = this.#buffer.subarray(result.responseLength);
-        await this.#handle(result.response, undefined);
+        this.#buffer = this.#buffer.subarray(result.requestLength);
+        await this.#handle(result.method, result.path, result.headers, result.body);
       }
     } catch (err) {
-      reporter3.error("Error in rtsp #onData()", err);
+      this.context.logger.error("[event]", "#onData()", err);
       this.emit("error", err);
     }
   }
-  async#onError(err) {
-    await this.#handle(undefined, err);
+}
+// src/protocol.ts
+import { AIRPLAY_SERVICE, Context, getMacAddress, randomInt64, uuid } from "@basmilius/apple-common";
+import { Plist as Plist4 } from "@basmilius/apple-encoding";
+
+// src/pairing.ts
+import { AccessoryPair, AccessoryVerify, hkdf as hkdf3 } from "@basmilius/apple-common";
+
+class Pairing {
+  get controlStream() {
+    return this.#controlStream;
+  }
+  get internal() {
+    return this.#internal;
+  }
+  #controlStream;
+  #internal;
+  #hkp;
+  constructor(protocol) {
+    this.#controlStream = protocol.controlStream;
+    this.#internal = new AccessoryPair(protocol.context, this.#request.bind(this));
+  }
+  async start() {
+    await this.#internal.start();
+  }
+  async pin(askPin) {
+    this.#hkp = 3;
+    await this.#pinStart();
+    return this.#internal.pin(askPin);
+  }
+  async pinStart() {
+    this.#hkp = 3;
+    await this.#pinStart();
+  }
+  async transient() {
+    this.#hkp = 4;
+    await this.#pinStart();
+    return this.#internal.transient();
+  }
+  async#pinStart() {
+    const response = await this.#controlStream.post("/pair-pin-start", null, {
+      "Content-Type": "application/octet-stream",
+      "X-Apple-HKP": this.#hkp.toString()
+    });
+    if (response.status !== 200) {
+      throw new Error(`Cannot start pairing session. ${response.status} ${response.statusText} ${await response.text()}`);
+    }
   }
-  async#onTimeout() {
-    await this.#handle(undefined, new Error("Request timed out."));
+  async#request(_, data) {
+    const response = await this.#controlStream.post("/pair-setup", data, {
+      "Content-Type": "application/octet-stream",
+      "X-Apple-HKP": this.#hkp.toString()
+    });
+    return Buffer.from(await response.arrayBuffer());
   }
 }
 
-// src/verify.ts
-import { AccessoryVerify, hkdf as hkdf3 } from "@basmilius/apple-common";
-
-class AirPlayVerify {
-  get rtsp() {
-    return this.#protocol.rtsp;
+class Verify {
+  get controlStream() {
+    return this.#controlStream;
   }
+  get internal() {
+    return this.#internal;
+  }
+  #controlStream;
   #internal;
-  #protocol;
-  constructor(protocol2) {
-    this.#internal = new AccessoryVerify(this.#request.bind(this));
-    this.#protocol = protocol2;
+  constructor(protocol) {
+    this.#controlStream = protocol.controlStream;
+    this.#internal = new AccessoryVerify(protocol.context, this.#request.bind(this));
   }
   async start(credentials) {
     const keys = await this.#internal.start(credentials);
@@ -2546,7 +2161,7 @@ class AirPlayVerify {
     };
   }
   async#request(_, data) {
-    const response = await this.rtsp.post("/pair-verify", data, {
+    const response = await this.controlStream.post("/pair-verify", data, {
       "Content-Type": "application/octet-stream",
       "X-Apple-HKP": "3"
     });
@@ -2555,79 +2170,89 @@ class AirPlayVerify {
 }
 
 // src/protocol.ts
-class AirPlay {
-  get device() {
-    return this.#device;
+class Protocol {
+  get context() {
+    return this.#context;
+  }
+  get controlStream() {
+    return this.#controlStream;
   }
   get dataStream() {
     return this.#dataStream;
   }
+  get discoveryResult() {
+    return this.#discoveryResult;
+  }
   get eventStream() {
     return this.#eventStream;
   }
   get pairing() {
     return this.#pairing;
   }
-  get rtsp() {
-    return this.#rtsp;
-  }
   get sessionUUID() {
     return this.#sessionUUID;
   }
   get verify() {
     return this.#verify;
   }
-  #device;
+  #context;
+  #controlStream;
+  #discoveryResult;
   #pairing;
-  #rtsp;
-  #verify;
   #sessionUUID;
+  #verify;
   #dataStream;
   #eventStream;
   #timingServer;
-  constructor(device) {
-    this.#device = device;
-    this.#rtsp = new AirPlayRTSP(device.address, device.service.port);
-    this.#pairing = new AirPlayPairing(this);
-    this.#verify = new AirPlayVerify(this);
-    this.#sessionUUID = uuid2();
+  constructor(deviceId, discoveryResult) {
+    this.#context = new Context(deviceId.replace(`.${AIRPLAY_SERVICE}`, "").replace(".local", ""));
+    this.#discoveryResult = discoveryResult;
+    this.#sessionUUID = uuid();
+    this.#controlStream = new ControlStream(this.#context, discoveryResult.address, discoveryResult.service.port);
+    this.#pairing = new Pairing(this);
+    this.#verify = new Verify(this);
   }
   async connect() {
-    await this.#rtsp.connect();
+    await this.#controlStream.connect();
+  }
+  async destroy() {
+    await this.#controlStream.destroy();
   }
   async disconnect() {
-    await this.#rtsp.disconnect();
+    await this.#dataStream.disconnect();
   }
   async feedback() {
-    await this.#rtsp.post("/feedback", undefined, undefined, 1900);
+    await this.#controlStream.post("/feedback", undefined, undefined, 1900);
   }
   async setupDataStream(sharedSecret, onBeforeConnect) {
     const seed = randomInt64();
-    const request = Plist3.serialize({
-      streams: [
-        {
-          controlType: 2,
-          channelID: uuid2().toUpperCase(),
-          seed,
-          clientUUID: uuid2().toUpperCase(),
-          type: 130,
-          wantsDedicatedSocket: true,
-          clientTypeUUID: "1910A70F-DBC0-4242-AF95-115DB30604E1"
-        }
-      ]
+    const request = Plist4.serialize({
+      streams: [{
+        controlType: 2,
+        channelID: uuid().toUpperCase(),
+        seed,
+        clientUUID: uuid().toUpperCase(),
+        type: 130,
+        wantsDedicatedSocket: true,
+        clientTypeUUID: "1910A70F-DBC0-4242-AF95-115DB30604E1"
+      }]
     });
-    const response = await this.#rtsp.setup(`/${this.rtsp.sessionId}`, Buffer.from(request), {
+    const response = await this.#controlStream.setup(`/${this.#controlStream.sessionId}`, Buffer.from(request), {
       "Content-Type": "application/x-apple-binary-plist"
     });
-    const plist = Plist3.parse(await response.arrayBuffer());
+    if (response.status !== 200) {
+      this.context.logger.error("[protocol]", "Failed to setup data stream.", response.status, response.statusText, await response.text());
+      throw new Error("Failed to setup data stream.");
+    }
+    const plist = Plist4.parse(await response.arrayBuffer());
     const dataPort = plist.streams[0].dataPort & 65535;
-    reporter4.net(`Connecting to data stream on port ${dataPort}...`);
-    this.#dataStream = new AirPlayDataStream(this.#rtsp.address, dataPort);
-    await this.#dataStream.setup(sharedSecret, seed);
-    await onBeforeConnect?.();
+    this.context.logger.net("[protocol]", `Connecting to data stream on port ${dataPort}...`);
+    this.#dataStream = new DataStream(this.context, this.#controlStream.address, dataPort);
+    this.#dataStream.setup(sharedSecret, seed);
+    onBeforeConnect?.();
     await this.#dataStream.connect();
   }
-  async setupEventStream(pairingId, sharedSecret) {
+  async setupEventStream(sharedSecret, pairingId) {
     const body = {
       deviceID: pairingId.toString(),
       macAddress: getMacAddress().toUpperCase(),
@@ -2645,28 +2270,291 @@ class AirPlay {
       body.timingPort = this.#timingServer.port;
       body.timingProtocol = "NTP";
     }
-    const request = Plist3.serialize(body);
-    const response = await this.#rtsp.setup(`/${this.rtsp.sessionId}`, Buffer.from(request), {
+    const request = Plist4.serialize(body);
+    const response = await this.#controlStream.setup(`/${this.#controlStream.sessionId}`, Buffer.from(request), {
       "Content-Type": "application/x-apple-binary-plist"
     });
     if (response.status !== 200) {
-      reporter4.error("Cannot setup event stream", response.status, response.statusText, await response.text());
-      throw new Error("Cannot setup event stream.");
+      this.context.logger.error("[protocol]", "Failed to setup event stream.", response.status, response.statusText, await response.text());
+      throw new Error("Failed to setup event stream.");
     }
-    const plist = Plist3.parse(await response.arrayBuffer());
+    const plist = Plist4.parse(await response.arrayBuffer());
     const eventPort = plist.eventPort & 65535;
-    reporter4.net(`Connecting to event stream on port ${eventPort}...`);
-    this.#eventStream = new AirPlayEventStream(this.#rtsp.address, eventPort);
-    await this.#eventStream.setup(sharedSecret);
+    this.context.logger.net("[protocol]", `Connecting to event stream on port ${eventPort}...`);
+    this.#eventStream = new EventStream(this.#context, this.#controlStream.address, eventPort);
+    this.#eventStream.setup(sharedSecret);
     await this.#eventStream.connect();
-    await this.#rtsp.record(`/${this.rtsp.sessionId}`);
+    await this.#controlStream.record(`/${this.#controlStream.sessionId}`);
   }
-  async setupTimingServer(timing) {
-    this.#timingServer = timing;
+  useTimingServer(timingServer) {
+    this.#timingServer = timingServer;
   }
 }
+// src/dataStreamMessages.ts
+var exports_dataStreamMessages = {};
+__export(exports_dataStreamMessages, {
+  wakeDevice: () => wakeDevice,
+  setVolumeMuted: () => setVolumeMuted,
+  setVolume: () => setVolume,
+  setReadyState: () => setReadyState,
+  setConnectionState: () => setConnectionState,
+  sendHIDEvent: () => sendHIDEvent,
+  sendCommand: () => sendCommand,
+  sendButtonEvent: () => sendButtonEvent,
+  protocol: () => protocol,
+  playbackQueueRequest: () => playbackQueueRequest,
+  notification: () => notification,
+  getVolumeMuted: () => getVolumeMuted,
+  getVolume: () => getVolume,
+  getState: () => getState,
+  getExtension: () => getExtension2,
+  deviceInfo: () => deviceInfo,
+  configureConnection: () => configureConnection,
+  clientUpdatesConfig: () => clientUpdatesConfig
+});
+import { uint16ToBE, uuid as uuid2 } from "@basmilius/apple-common";
+import { create, getExtension as _getExtension, setExtension } from "@bufbuild/protobuf";
+function protocol(type, errorCode = 0 /* NoError */) {
+  return create(ProtocolMessageSchema, {
+    type,
+    errorCode,
+    identifier: uuid2().toUpperCase(),
+    uniqueIdentifier: uuid2().toUpperCase()
+  });
+}
+function clientUpdatesConfig(artworkUpdates = true, nowPlayingUpdates = true, volumeUpdates = true, keyboardUpdates = false, outputDeviceUpdates = true, systemEndpointUpdates = true) {
+  const protocolMessage = protocol(16 /* CLIENT_UPDATES_CONFIG_MESSAGE */);
+  const message = create(ClientUpdatesConfigMessageSchema, {
+    artworkUpdates,
+    nowPlayingUpdates,
+    volumeUpdates,
+    keyboardUpdates,
+    outputDeviceUpdates,
+    systemEndpointUpdates
+  });
+  setExtension(protocolMessage, clientUpdatesConfigMessage, message);
+  return [
+    protocolMessage,
+    clientUpdatesConfigMessage
+  ];
+}
+function configureConnection(groupId) {
+  const protocolMessage = protocol(120 /* CONFIGURE_CONNECTION_MESSAGE */);
+  const message = create(ConfigureConnectionMessageSchema, {
+    groupID: groupId
+  });
+  setExtension(protocolMessage, configureConnectionMessage, message);
+  return [
+    protocolMessage,
+    configureConnectionMessage
+  ];
+}
+function deviceInfo(pairingId) {
+  const protocolMessage = protocol(15 /* DEVICE_INFO_MESSAGE */);
+  const message = create(DeviceInfoMessageSchema, {
+    uniqueIdentifier: pairingId.toString(),
+    name: "iPhone van Bas",
+    localizedModelName: "iPhone",
+    systemBuildVersion: "18C66",
+    applicationBundleIdentifier: "com.apple.TVRemote",
+    applicationBundleVersion: "344.28",
+    protocolVersion: 1,
+    lastSupportedMessageType: 129,
+    supportsSystemPairing: true,
+    allowsPairing: true,
+    systemMediaApplication: "com.apple.TVMusic",
+    supportsACL: true,
+    supportsSharedQueue: true,
+    supportsExtendedMotion: true,
+    sharedQueueVersion: 2,
+    deviceClass: 1 /* iPhone */,
+    logicalDeviceCount: 1
+  });
+  setExtension(protocolMessage, deviceInfoMessage, message);
+  return [
+    protocolMessage,
+    deviceInfoMessage
+  ];
+}
+function getState() {
+  const protocolMessage = protocol(3 /* GET_STATE_MESSAGE */);
+  const message = create(GetStateMessageSchema, {});
+  setExtension(protocolMessage, getStateMessage, message);
+  return [
+    protocolMessage,
+    getStateMessage
+  ];
+}
+function getVolume(outputDeviceUID) {
+  const protocolMessage = protocol(49 /* GET_VOLUME_MESSAGE */);
+  const message = create(GetVolumeMessageSchema, {
+    outputDeviceUID
+  });
+  setExtension(protocolMessage, getVolumeMessage, message);
+  return [
+    protocolMessage,
+    getVolumeMessage
+  ];
+}
+function getVolumeMuted(outputDeviceUID) {
+  const protocolMessage = protocol(126 /* GET_VOLUME_MUTED_MESSAGE */);
+  const message = create(GetVolumeMutedMessageSchema, {
+    outputDeviceUID
+  });
+  setExtension(protocolMessage, getVolumeMutedMessage, message);
+  return [
+    protocolMessage,
+    getVolumeMutedMessage
+  ];
+}
+function notification(notification2) {
+  const protocolMessage = protocol(11 /* NOTIFICATION_MESSAGE */);
+  const message = create(NotificationMessageSchema, {
+    notification: notification2
+  });
+  setExtension(protocolMessage, notificationMessage, message);
+  return [
+    protocolMessage,
+    notificationMessage
+  ];
+}
+function playbackQueueRequest(location, length, includeMetadata = true, includeLanguageOptions = false) {
+  const protocolMessage = protocol(32 /* PLAYBACK_QUEUE_REQUEST_MESSAGE */);
+  const message = create(PlaybackQueueRequestMessageSchema, {
+    location,
+    length,
+    includeMetadata,
+    includeLanguageOptions,
+    artworkHeight: 600,
+    artworkWidth: 600,
+    includeInfo: true,
+    includeLyrics: false,
+    includeSections: false,
+    includeAlignments: false,
+    includeAvailableArtworkFormats: true,
+    includeParticipants: false,
+    isLegacyNowPlayingInfoRequest: false,
+    returnContentItemAssetsInUserCompletion: true,
+    requestedAnimatedArtworkAssetURLFormats: [
+      "MRContentItemAnimatedArtworkFormatSquare",
+      "MRContentItemAnimatedArtworkFormatTall"
+    ]
+  });
+  setExtension(protocolMessage, playbackQueueRequestMessage, message);
+  return [
+    protocolMessage,
+    playbackQueueRequestMessage
+  ];
+}
+function sendButtonEvent(usagePage, usage, buttonDown) {
+  const protocolMessage = protocol(39 /* SEND_BUTTON_EVENT_MESSAGE */);
+  const message = create(SendButtonEventMessageSchema, {
+    usagePage,
+    usage,
+    buttonDown
+  });
+  setExtension(protocolMessage, sendButtonEventMessage, message);
+  return [
+    protocolMessage,
+    sendButtonEventMessage
+  ];
+}
+function sendCommand(command, options) {
+  const protocolMessage = protocol(1 /* SEND_COMMAND_MESSAGE */);
+  const message = create(SendCommandMessageSchema, {
+    command,
+    options
+  });
+  setExtension(protocolMessage, sendCommandMessage, message);
+  return [
+    protocolMessage,
+    sendCommandMessage
+  ];
+}
+function sendHIDEvent(usePage, usage, down) {
+  const protocolMessage = protocol(8 /* SEND_HID_EVENT_MESSAGE */);
+  const message = create(SendHIDEventMessageSchema, {
+    hidEventData: Buffer.concat([
+      Buffer.from("438922cf08020000", "hex"),
+      Buffer.from("00000000000000000100000000000000020" + "00000200000000300000001000000000000", "hex"),
+      Buffer.concat([
+        uint16ToBE(usePage),
+        uint16ToBE(usage),
+        uint16ToBE(down ? 1 : 0)
+      ]),
+      Buffer.from("0000000000000001000000", "hex")
+    ])
+  });
+  setExtension(protocolMessage, sendHIDEventMessage, message);
+  return [
+    protocolMessage,
+    sendHIDEventMessage
+  ];
+}
+function setConnectionState(state = 2 /* Connected */) {
+  const protocolMessage = protocol(38 /* SET_CONNECTION_STATE_MESSAGE */);
+  const message = create(SetConnectionStateMessageSchema, {
+    state
+  });
+  setExtension(protocolMessage, setConnectionStateMessage, message);
+  return [
+    protocolMessage,
+    setConnectionStateMessage
+  ];
+}
+function setReadyState() {
+  const protocolMessage = protocol(36 /* SET_READY_STATE_MESSAGE */);
+  const message = create(SetReadyStateMessageSchema, {});
+  setExtension(protocolMessage, readyStateMessage, message);
+  return [
+    protocolMessage,
+    readyStateMessage
+  ];
+}
+function setVolume(outputDeviceUID, volume) {
+  const protocolMessage = protocol(51 /* SET_VOLUME_MESSAGE */);
+  const message = create(SetVolumeMessageSchema, {
+    outputDeviceUID,
+    volume
+  });
+  setExtension(protocolMessage, setVolumeMessage, message);
+  return [
+    protocolMessage,
+    setVolumeMessage
+  ];
+}
+function setVolumeMuted(outputDeviceUID, isMuted) {
+  const protocolMessage = protocol(128 /* SET_VOLUME_MUTED_MESSAGE */);
+  const message = create(SetVolumeMutedMessageSchema, {
+    outputDeviceUID,
+    isMuted
+  });
+  setExtension(protocolMessage, setVolumeMutedMessage, message);
+  return [
+    protocolMessage,
+    setVolumeMutedMessage
+  ];
+}
+function wakeDevice() {
+  const protocolMessage = protocol(41 /* WAKE_DEVICE_MESSAGE */);
+  const message = create(WakeDeviceMessageSchema, {});
+  setExtension(protocolMessage, wakeDeviceMessage, message);
+  return [
+    protocolMessage,
+    wakeDeviceMessage
+  ];
+}
+function getExtension2(message, extension) {
+  return _getExtension(message, extension);
+}
 export {
+  Verify,
+  Protocol,
   exports_proto as Proto,
+  Pairing,
+  EventStream,
   exports_dataStreamMessages as DataStreamMessage,
-  AirPlay
+  DataStream,
+  ControlStream,
+  BaseStream
 };