@stinkycomputing/sesame-api-client 1.4.1-alpha.10 → 1.4.1-alpha.12

package/dist/index.mjs

@@ -21054,6 +21054,602 @@ var sesame = $root.sesame = (() => {
       }();
       return rpc;
     }();
+    v1.wire = function() {
+      const wire = {};
+      wire.FrameType = function() {
+        const valuesById = {}, values = Object.create(valuesById);
+        values[valuesById[0] = "FRAME_TYPE_UNSPECIFIED"] = 0;
+        values[valuesById[1] = "FRAME_TYPE_RPC"] = 1;
+        values[valuesById[2] = "FRAME_TYPE_VIDEO"] = 2;
+        values[valuesById[3] = "FRAME_TYPE_AUDIO"] = 3;
+        values[valuesById[4] = "FRAME_TYPE_MUXED"] = 4;
+        values[valuesById[5] = "FRAME_TYPE_DECODER_DATA"] = 5;
+        return values;
+      }();
+      wire.CodecType = function() {
+        const valuesById = {}, values = Object.create(valuesById);
+        values[valuesById[0] = "CODEC_TYPE_UNSPECIFIED"] = 0;
+        values[valuesById[1] = "CODEC_TYPE_VIDEO_VP8"] = 1;
+        values[valuesById[2] = "CODEC_TYPE_VIDEO_VP9"] = 2;
+        values[valuesById[3] = "CODEC_TYPE_VIDEO_AVC"] = 3;
+        values[valuesById[4] = "CODEC_TYPE_VIDEO_HEVC"] = 4;
+        values[valuesById[5] = "CODEC_TYPE_VIDEO_AV1"] = 5;
+        values[valuesById[64] = "CODEC_TYPE_AUDIO_OPUS"] = 64;
+        values[valuesById[65] = "CODEC_TYPE_AUDIO_AAC"] = 65;
+        values[valuesById[66] = "CODEC_TYPE_AUDIO_PCM"] = 66;
+        return values;
+      }();
+      wire.MediaCodecData = function() {
+        function MediaCodecData2(properties) {
+          if (properties) {
+            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+              if (properties[keys[i]] != null)
+                this[keys[i]] = properties[keys[i]];
+          }
+        }
+        MediaCodecData2.prototype.codecType = 0;
+        MediaCodecData2.prototype.sampleRate = 0;
+        MediaCodecData2.prototype.timebaseNum = 0;
+        MediaCodecData2.prototype.timebaseDen = 0;
+        MediaCodecData2.prototype.codecProfile = 0;
+        MediaCodecData2.prototype.codecLevel = 0;
+        MediaCodecData2.prototype.width = 0;
+        MediaCodecData2.prototype.height = 0;
+        MediaCodecData2.prototype.channels = 0;
+        MediaCodecData2.prototype.bitDepth = 0;
+        MediaCodecData2.create = function create(properties) {
+          return new MediaCodecData2(properties);
+        };
+        MediaCodecData2.encode = function encode(message, writer) {
+          if (!writer)
+            writer = $Writer.create();
+          if (message.codecType != null && Object.hasOwnProperty.call(message, "codecType"))
+            writer.uint32(
+              /* id 1, wireType 0 =*/
+              8
+            ).int32(message.codecType);
+          if (message.sampleRate != null && Object.hasOwnProperty.call(message, "sampleRate"))
+            writer.uint32(
+              /* id 2, wireType 0 =*/
+              16
+            ).uint32(message.sampleRate);
+          if (message.timebaseNum != null && Object.hasOwnProperty.call(message, "timebaseNum"))
+            writer.uint32(
+              /* id 3, wireType 0 =*/
+              24
+            ).uint32(message.timebaseNum);
+          if (message.timebaseDen != null && Object.hasOwnProperty.call(message, "timebaseDen"))
+            writer.uint32(
+              /* id 4, wireType 0 =*/
+              32
+            ).uint32(message.timebaseDen);
+          if (message.codecProfile != null && Object.hasOwnProperty.call(message, "codecProfile"))
+            writer.uint32(
+              /* id 5, wireType 0 =*/
+              40
+            ).uint32(message.codecProfile);
+          if (message.codecLevel != null && Object.hasOwnProperty.call(message, "codecLevel"))
+            writer.uint32(
+              /* id 6, wireType 0 =*/
+              48
+            ).uint32(message.codecLevel);
+          if (message.width != null && Object.hasOwnProperty.call(message, "width"))
+            writer.uint32(
+              /* id 7, wireType 0 =*/
+              56
+            ).uint32(message.width);
+          if (message.height != null && Object.hasOwnProperty.call(message, "height"))
+            writer.uint32(
+              /* id 8, wireType 0 =*/
+              64
+            ).uint32(message.height);
+          if (message.channels != null && Object.hasOwnProperty.call(message, "channels"))
+            writer.uint32(
+              /* id 9, wireType 0 =*/
+              72
+            ).uint32(message.channels);
+          if (message.bitDepth != null && Object.hasOwnProperty.call(message, "bitDepth"))
+            writer.uint32(
+              /* id 10, wireType 0 =*/
+              80
+            ).uint32(message.bitDepth);
+          return writer;
+        };
+        MediaCodecData2.encodeDelimited = function encodeDelimited(message, writer) {
+          return this.encode(message, writer).ldelim();
+        };
+        MediaCodecData2.decode = function decode(reader, length, error) {
+          if (!(reader instanceof $Reader))
+            reader = $Reader.create(reader);
+          let end = length === void 0 ? reader.len : reader.pos + length, message = new $root.sesame.v1.wire.MediaCodecData();
+          while (reader.pos < end) {
+            let tag = reader.uint32();
+            if (tag === error)
+              break;
+            switch (tag >>> 3) {
+              case 1: {
+                message.codecType = reader.int32();
+                break;
+              }
+              case 2: {
+                message.sampleRate = reader.uint32();
+                break;
+              }
+              case 3: {
+                message.timebaseNum = reader.uint32();
+                break;
+              }
+              case 4: {
+                message.timebaseDen = reader.uint32();
+                break;
+              }
+              case 5: {
+                message.codecProfile = reader.uint32();
+                break;
+              }
+              case 6: {
+                message.codecLevel = reader.uint32();
+                break;
+              }
+              case 7: {
+                message.width = reader.uint32();
+                break;
+              }
+              case 8: {
+                message.height = reader.uint32();
+                break;
+              }
+              case 9: {
+                message.channels = reader.uint32();
+                break;
+              }
+              case 10: {
+                message.bitDepth = reader.uint32();
+                break;
+              }
+              default:
+                reader.skipType(tag & 7);
+                break;
+            }
+          }
+          return message;
+        };
+        MediaCodecData2.decodeDelimited = function decodeDelimited(reader) {
+          if (!(reader instanceof $Reader))
+            reader = new $Reader(reader);
+          return this.decode(reader, reader.uint32());
+        };
+        MediaCodecData2.verify = function verify(message) {
+          if (typeof message !== "object" || message === null)
+            return "object expected";
+          if (message.codecType != null && message.hasOwnProperty("codecType"))
+            switch (message.codecType) {
+              default:
+                return "codecType: enum value expected";
+              case 0:
+              case 1:
+              case 2:
+              case 3:
+              case 4:
+              case 5:
+              case 64:
+              case 65:
+              case 66:
+                break;
+            }
+          if (message.sampleRate != null && message.hasOwnProperty("sampleRate")) {
+            if (!$util.isInteger(message.sampleRate))
+              return "sampleRate: integer expected";
+          }
+          if (message.timebaseNum != null && message.hasOwnProperty("timebaseNum")) {
+            if (!$util.isInteger(message.timebaseNum))
+              return "timebaseNum: integer expected";
+          }
+          if (message.timebaseDen != null && message.hasOwnProperty("timebaseDen")) {
+            if (!$util.isInteger(message.timebaseDen))
+              return "timebaseDen: integer expected";
+          }
+          if (message.codecProfile != null && message.hasOwnProperty("codecProfile")) {
+            if (!$util.isInteger(message.codecProfile))
+              return "codecProfile: integer expected";
+          }
+          if (message.codecLevel != null && message.hasOwnProperty("codecLevel")) {
+            if (!$util.isInteger(message.codecLevel))
+              return "codecLevel: integer expected";
+          }
+          if (message.width != null && message.hasOwnProperty("width")) {
+            if (!$util.isInteger(message.width))
+              return "width: integer expected";
+          }
+          if (message.height != null && message.hasOwnProperty("height")) {
+            if (!$util.isInteger(message.height))
+              return "height: integer expected";
+          }
+          if (message.channels != null && message.hasOwnProperty("channels")) {
+            if (!$util.isInteger(message.channels))
+              return "channels: integer expected";
+          }
+          if (message.bitDepth != null && message.hasOwnProperty("bitDepth")) {
+            if (!$util.isInteger(message.bitDepth))
+              return "bitDepth: integer expected";
+          }
+          return null;
+        };
+        MediaCodecData2.fromObject = function fromObject(object) {
+          if (object instanceof $root.sesame.v1.wire.MediaCodecData)
+            return object;
+          let message = new $root.sesame.v1.wire.MediaCodecData();
+          switch (object.codecType) {
+            default:
+              if (typeof object.codecType === "number") {
+                message.codecType = object.codecType;
+                break;
+              }
+              break;
+            case "CODEC_TYPE_UNSPECIFIED":
+            case 0:
+              message.codecType = 0;
+              break;
+            case "CODEC_TYPE_VIDEO_VP8":
+            case 1:
+              message.codecType = 1;
+              break;
+            case "CODEC_TYPE_VIDEO_VP9":
+            case 2:
+              message.codecType = 2;
+              break;
+            case "CODEC_TYPE_VIDEO_AVC":
+            case 3:
+              message.codecType = 3;
+              break;
+            case "CODEC_TYPE_VIDEO_HEVC":
+            case 4:
+              message.codecType = 4;
+              break;
+            case "CODEC_TYPE_VIDEO_AV1":
+            case 5:
+              message.codecType = 5;
+              break;
+            case "CODEC_TYPE_AUDIO_OPUS":
+            case 64:
+              message.codecType = 64;
+              break;
+            case "CODEC_TYPE_AUDIO_AAC":
+            case 65:
+              message.codecType = 65;
+              break;
+            case "CODEC_TYPE_AUDIO_PCM":
+            case 66:
+              message.codecType = 66;
+              break;
+          }
+          if (object.sampleRate != null)
+            message.sampleRate = object.sampleRate >>> 0;
+          if (object.timebaseNum != null)
+            message.timebaseNum = object.timebaseNum >>> 0;
+          if (object.timebaseDen != null)
+            message.timebaseDen = object.timebaseDen >>> 0;
+          if (object.codecProfile != null)
+            message.codecProfile = object.codecProfile >>> 0;
+          if (object.codecLevel != null)
+            message.codecLevel = object.codecLevel >>> 0;
+          if (object.width != null)
+            message.width = object.width >>> 0;
+          if (object.height != null)
+            message.height = object.height >>> 0;
+          if (object.channels != null)
+            message.channels = object.channels >>> 0;
+          if (object.bitDepth != null)
+            message.bitDepth = object.bitDepth >>> 0;
+          return message;
+        };
+        MediaCodecData2.toObject = function toObject(message, options) {
+          if (!options)
+            options = {};
+          let object = {};
+          if (options.defaults) {
+            object.codecType = options.enums === String ? "CODEC_TYPE_UNSPECIFIED" : 0;
+            object.sampleRate = 0;
+            object.timebaseNum = 0;
+            object.timebaseDen = 0;
+            object.codecProfile = 0;
+            object.codecLevel = 0;
+            object.width = 0;
+            object.height = 0;
+            object.channels = 0;
+            object.bitDepth = 0;
+          }
+          if (message.codecType != null && message.hasOwnProperty("codecType"))
+            object.codecType = options.enums === String ? $root.sesame.v1.wire.CodecType[message.codecType] === void 0 ? message.codecType : $root.sesame.v1.wire.CodecType[message.codecType] : message.codecType;
+          if (message.sampleRate != null && message.hasOwnProperty("sampleRate"))
+            object.sampleRate = message.sampleRate;
+          if (message.timebaseNum != null && message.hasOwnProperty("timebaseNum"))
+            object.timebaseNum = message.timebaseNum;
+          if (message.timebaseDen != null && message.hasOwnProperty("timebaseDen"))
+            object.timebaseDen = message.timebaseDen;
+          if (message.codecProfile != null && message.hasOwnProperty("codecProfile"))
+            object.codecProfile = message.codecProfile;
+          if (message.codecLevel != null && message.hasOwnProperty("codecLevel"))
+            object.codecLevel = message.codecLevel;
+          if (message.width != null && message.hasOwnProperty("width"))
+            object.width = message.width;
+          if (message.height != null && message.hasOwnProperty("height"))
+            object.height = message.height;
+          if (message.channels != null && message.hasOwnProperty("channels"))
+            object.channels = message.channels;
+          if (message.bitDepth != null && message.hasOwnProperty("bitDepth"))
+            object.bitDepth = message.bitDepth;
+          return object;
+        };
+        MediaCodecData2.prototype.toJSON = function toJSON() {
+          return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+        MediaCodecData2.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+          if (typeUrlPrefix === void 0) {
+            typeUrlPrefix = "type.googleapis.com";
+          }
+          return typeUrlPrefix + "/sesame.v1.wire.MediaCodecData";
+        };
+        return MediaCodecData2;
+      }();
+      wire.FrameHeader = function() {
+        function FrameHeader2(properties) {
+          if (properties) {
+            for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+              if (properties[keys[i]] != null)
+                this[keys[i]] = properties[keys[i]];
+          }
+        }
+        FrameHeader2.prototype.type = 0;
+        FrameHeader2.prototype.pts = $util.Long ? $util.Long.fromBits(0, 0, true) : 0;
+        FrameHeader2.prototype.id = $util.Long ? $util.Long.fromBits(0, 0, true) : 0;
+        FrameHeader2.prototype.keyframe = false;
+        FrameHeader2.prototype.codecData = null;
+        FrameHeader2.prototype.routingMetadata = "";
+        FrameHeader2.create = function create(properties) {
+          return new FrameHeader2(properties);
+        };
+        FrameHeader2.encode = function encode(message, writer) {
+          if (!writer)
+            writer = $Writer.create();
+          if (message.type != null && Object.hasOwnProperty.call(message, "type"))
+            writer.uint32(
+              /* id 1, wireType 0 =*/
+              8
+            ).int32(message.type);
+          if (message.pts != null && Object.hasOwnProperty.call(message, "pts"))
+            writer.uint32(
+              /* id 2, wireType 0 =*/
+              16
+            ).uint64(message.pts);
+          if (message.id != null && Object.hasOwnProperty.call(message, "id"))
+            writer.uint32(
+              /* id 3, wireType 0 =*/
+              24
+            ).uint64(message.id);
+          if (message.keyframe != null && Object.hasOwnProperty.call(message, "keyframe"))
+            writer.uint32(
+              /* id 4, wireType 0 =*/
+              32
+            ).bool(message.keyframe);
+          if (message.codecData != null && Object.hasOwnProperty.call(message, "codecData"))
+            $root.sesame.v1.wire.MediaCodecData.encode(message.codecData, writer.uint32(
+              /* id 5, wireType 2 =*/
+              42
+            ).fork()).ldelim();
+          if (message.routingMetadata != null && Object.hasOwnProperty.call(message, "routingMetadata"))
+            writer.uint32(
+              /* id 6, wireType 2 =*/
+              50
+            ).string(message.routingMetadata);
+          return writer;
+        };
+        FrameHeader2.encodeDelimited = function encodeDelimited(message, writer) {
+          return this.encode(message, writer).ldelim();
+        };
+        FrameHeader2.decode = function decode(reader, length, error) {
+          if (!(reader instanceof $Reader))
+            reader = $Reader.create(reader);
+          let end = length === void 0 ? reader.len : reader.pos + length, message = new $root.sesame.v1.wire.FrameHeader();
+          while (reader.pos < end) {
+            let tag = reader.uint32();
+            if (tag === error)
+              break;
+            switch (tag >>> 3) {
+              case 1: {
+                message.type = reader.int32();
+                break;
+              }
+              case 2: {
+                message.pts = reader.uint64();
+                break;
+              }
+              case 3: {
+                message.id = reader.uint64();
+                break;
+              }
+              case 4: {
+                message.keyframe = reader.bool();
+                break;
+              }
+              case 5: {
+                message.codecData = $root.sesame.v1.wire.MediaCodecData.decode(reader, reader.uint32());
+                break;
+              }
+              case 6: {
+                message.routingMetadata = reader.string();
+                break;
+              }
+              default:
+                reader.skipType(tag & 7);
+                break;
+            }
+          }
+          return message;
+        };
+        FrameHeader2.decodeDelimited = function decodeDelimited(reader) {
+          if (!(reader instanceof $Reader))
+            reader = new $Reader(reader);
+          return this.decode(reader, reader.uint32());
+        };
+        FrameHeader2.verify = function verify(message) {
+          if (typeof message !== "object" || message === null)
+            return "object expected";
+          if (message.type != null && message.hasOwnProperty("type"))
+            switch (message.type) {
+              default:
+                return "type: enum value expected";
+              case 0:
+              case 1:
+              case 2:
+              case 3:
+              case 4:
+              case 5:
+                break;
+            }
+          if (message.pts != null && message.hasOwnProperty("pts")) {
+            if (!$util.isInteger(message.pts) && !(message.pts && $util.isInteger(message.pts.low) && $util.isInteger(message.pts.high)))
+              return "pts: integer|Long expected";
+          }
+          if (message.id != null && message.hasOwnProperty("id")) {
+            if (!$util.isInteger(message.id) && !(message.id && $util.isInteger(message.id.low) && $util.isInteger(message.id.high)))
+              return "id: integer|Long expected";
+          }
+          if (message.keyframe != null && message.hasOwnProperty("keyframe")) {
+            if (typeof message.keyframe !== "boolean")
+              return "keyframe: boolean expected";
+          }
+          if (message.codecData != null && message.hasOwnProperty("codecData")) {
+            let error = $root.sesame.v1.wire.MediaCodecData.verify(message.codecData);
+            if (error)
+              return "codecData." + error;
+          }
+          if (message.routingMetadata != null && message.hasOwnProperty("routingMetadata")) {
+            if (!$util.isString(message.routingMetadata))
+              return "routingMetadata: string expected";
+          }
+          return null;
+        };
+        FrameHeader2.fromObject = function fromObject(object) {
+          if (object instanceof $root.sesame.v1.wire.FrameHeader)
+            return object;
+          let message = new $root.sesame.v1.wire.FrameHeader();
+          switch (object.type) {
+            default:
+              if (typeof object.type === "number") {
+                message.type = object.type;
+                break;
+              }
+              break;
+            case "FRAME_TYPE_UNSPECIFIED":
+            case 0:
+              message.type = 0;
+              break;
+            case "FRAME_TYPE_RPC":
+            case 1:
+              message.type = 1;
+              break;
+            case "FRAME_TYPE_VIDEO":
+            case 2:
+              message.type = 2;
+              break;
+            case "FRAME_TYPE_AUDIO":
+            case 3:
+              message.type = 3;
+              break;
+            case "FRAME_TYPE_MUXED":
+            case 4:
+              message.type = 4;
+              break;
+            case "FRAME_TYPE_DECODER_DATA":
+            case 5:
+              message.type = 5;
+              break;
+          }
+          if (object.pts != null) {
+            if ($util.Long)
+              (message.pts = $util.Long.fromValue(object.pts)).unsigned = true;
+            else if (typeof object.pts === "string")
+              message.pts = parseInt(object.pts, 10);
+            else if (typeof object.pts === "number")
+              message.pts = object.pts;
+            else if (typeof object.pts === "object")
+              message.pts = new $util.LongBits(object.pts.low >>> 0, object.pts.high >>> 0).toNumber(true);
+          }
+          if (object.id != null) {
+            if ($util.Long)
+              (message.id = $util.Long.fromValue(object.id)).unsigned = true;
+            else if (typeof object.id === "string")
+              message.id = parseInt(object.id, 10);
+            else if (typeof object.id === "number")
+              message.id = object.id;
+            else if (typeof object.id === "object")
+              message.id = new $util.LongBits(object.id.low >>> 0, object.id.high >>> 0).toNumber(true);
+          }
+          if (object.keyframe != null)
+            message.keyframe = Boolean(object.keyframe);
+          if (object.codecData != null) {
+            if (typeof object.codecData !== "object")
+              throw TypeError(".sesame.v1.wire.FrameHeader.codecData: object expected");
+            message.codecData = $root.sesame.v1.wire.MediaCodecData.fromObject(object.codecData);
+          }
+          if (object.routingMetadata != null)
+            message.routingMetadata = String(object.routingMetadata);
+          return message;
+        };
+        FrameHeader2.toObject = function toObject(message, options) {
+          if (!options)
+            options = {};
+          let object = {};
+          if (options.defaults) {
+            object.type = options.enums === String ? "FRAME_TYPE_UNSPECIFIED" : 0;
+            if ($util.Long) {
+              let long = new $util.Long(0, 0, true);
+              object.pts = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+            } else
+              object.pts = options.longs === String ? "0" : 0;
+            if ($util.Long) {
+              let long = new $util.Long(0, 0, true);
+              object.id = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+            } else
+              object.id = options.longs === String ? "0" : 0;
+            object.keyframe = false;
+            object.codecData = null;
+            object.routingMetadata = "";
+          }
+          if (message.type != null && message.hasOwnProperty("type"))
+            object.type = options.enums === String ? $root.sesame.v1.wire.FrameType[message.type] === void 0 ? message.type : $root.sesame.v1.wire.FrameType[message.type] : message.type;
+          if (message.pts != null && message.hasOwnProperty("pts"))
+            if (typeof message.pts === "number")
+              object.pts = options.longs === String ? String(message.pts) : message.pts;
+            else
+              object.pts = options.longs === String ? $util.Long.prototype.toString.call(message.pts) : options.longs === Number ? new $util.LongBits(message.pts.low >>> 0, message.pts.high >>> 0).toNumber(true) : message.pts;
+          if (message.id != null && message.hasOwnProperty("id"))
+            if (typeof message.id === "number")
+              object.id = options.longs === String ? String(message.id) : message.id;
+            else
+              object.id = options.longs === String ? $util.Long.prototype.toString.call(message.id) : options.longs === Number ? new $util.LongBits(message.id.low >>> 0, message.id.high >>> 0).toNumber(true) : message.id;
+          if (message.keyframe != null && message.hasOwnProperty("keyframe"))
+            object.keyframe = message.keyframe;
+          if (message.codecData != null && message.hasOwnProperty("codecData"))
+            object.codecData = $root.sesame.v1.wire.MediaCodecData.toObject(message.codecData, options);
+          if (message.routingMetadata != null && message.hasOwnProperty("routingMetadata"))
+            object.routingMetadata = message.routingMetadata;
+          return object;
+        };
+        FrameHeader2.prototype.toJSON = function toJSON() {
+          return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+        FrameHeader2.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+          if (typeUrlPrefix === void 0) {
+            typeUrlPrefix = "type.googleapis.com";
+          }
+          return typeUrlPrefix + "/sesame.v1.wire.FrameHeader";
+        };
+        return FrameHeader2;
+      }();
+      return wire;
+    }();
     return v1;
   }();
   return sesame2;
@@ -21519,252 +22115,48 @@ var RPCClient = class extends EventEmitter {
 // src/sesame-connection.ts
 import { EventEmitter as EventEmitter2 } from "events";
 
-// src/sesame-binary-protocol.ts
-var PROTOCOL_MAGIC = 1297302867;
-var PROTOCOL_VERSION = 1;
-var HEADER_DATA_SIZE = 32;
-var HEADER_CODEC_DATA_SIZE = 24;
-var HEADER_METADATA_SIZE = 64;
-var FLAG_HAS_CODEC_DATA = 1 << 0;
-var FLAG_HAS_METADATA = 1 << 1;
-var FLAG_IS_KEYFRAME = 1 << 2;
-var PacketType = /* @__PURE__ */ ((PacketType2) => {
-  PacketType2[PacketType2["VIDEO_FRAME"] = 1] = "VIDEO_FRAME";
-  PacketType2[PacketType2["AUDIO_FRAME"] = 2] = "AUDIO_FRAME";
-  PacketType2[PacketType2["RPC"] = 3] = "RPC";
-  PacketType2[PacketType2["MUXED_DATA"] = 4] = "MUXED_DATA";
-  PacketType2[PacketType2["DECODER_DATA"] = 5] = "DECODER_DATA";
-  return PacketType2;
-})(PacketType || {});
-var CodecType = /* @__PURE__ */ ((CodecType2) => {
-  CodecType2[CodecType2["VIDEO_VP8"] = 1] = "VIDEO_VP8";
-  CodecType2[CodecType2["VIDEO_VP9"] = 2] = "VIDEO_VP9";
-  CodecType2[CodecType2["VIDEO_AVC"] = 3] = "VIDEO_AVC";
-  CodecType2[CodecType2["VIDEO_HEVC"] = 4] = "VIDEO_HEVC";
-  CodecType2[CodecType2["VIDEO_AV1"] = 5] = "VIDEO_AV1";
-  CodecType2[CodecType2["AUDIO_OPUS"] = 64] = "AUDIO_OPUS";
-  CodecType2[CodecType2["AUDIO_AAC"] = 65] = "AUDIO_AAC";
-  CodecType2[CodecType2["AUDIO_PCM"] = 66] = "AUDIO_PCM";
-  return CodecType2;
-})(CodecType || {});
-var SesameBinaryProtocol = class {
-  /**
-   * Initialize a header data structure with proper defaults
-   */
-  static initHeader(type, flags, pts, id) {
-    return {
-      magic: PROTOCOL_MAGIC,
-      version: PROTOCOL_VERSION,
-      header_size: this.calculateHeaderSize(flags),
-      type,
-      flags,
-      pts,
-      id,
-      reserved: 0
-      // Always zero reserved fields
-    };
-  }
+// src/sesame-wire-protocol.ts
+var FrameType = sesame.v1.wire.FrameType;
+var FrameHeader = sesame.v1.wire.FrameHeader;
+var MediaCodecData = sesame.v1.wire.MediaCodecData;
+var CodecType = sesame.v1.wire.CodecType;
+var PREFIX_SIZE = 4;
+var WireProtocol = class {
   /**
-   * Calculate the total header size based on flags
+   * Serialize a wire frame: 4-byte LE header_size + protobuf FrameHeader + payload.
    */
-  static calculateHeaderSize(flags) {
-    let size = HEADER_DATA_SIZE;
-    if (flags & FLAG_HAS_METADATA) {
-      size += HEADER_METADATA_SIZE;
+  static serialize(header, payload) {
+    const headerBytes = sesame.v1.wire.FrameHeader.encode(header).finish();
+    const headerSize = headerBytes.length;
+    const payloadSize = payload ? payload.length : 0;
+    const total = PREFIX_SIZE + headerSize + payloadSize;
+    const buffer = new Uint8Array(total);
+    const view = new DataView(buffer.buffer);
+    view.setUint32(0, headerSize, true);
+    buffer.set(headerBytes, PREFIX_SIZE);
+    if (payload && payloadSize > 0) {
+      buffer.set(payload, PREFIX_SIZE + headerSize);
     }
-    if (flags & FLAG_HAS_CODEC_DATA) {
-      size += HEADER_CODEC_DATA_SIZE;
-    }
-    return size;
+    return buffer;
   }
   /**
-   * Validate a header structure
+   * Parse an incoming wire frame.
    */
-  static validateHeader(header, totalSize) {
-    if (header.magic !== PROTOCOL_MAGIC) {
-      return false;
-    }
-    if (header.version !== PROTOCOL_VERSION) {
-      return false;
+  static parse(data) {
+    const result = { valid: false, header: null, payload: null };
+    if (!data || data.length < PREFIX_SIZE) return result;
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const headerSize = view.getUint32(0, true);
+    if (data.length < PREFIX_SIZE + headerSize) return result;
+    try {
+      const headerBytes = data.subarray(PREFIX_SIZE, PREFIX_SIZE + headerSize);
+      result.header = sesame.v1.wire.FrameHeader.decode(headerBytes);
+      result.payload = data.subarray(PREFIX_SIZE + headerSize);
+      result.valid = true;
+    } catch {
     }
-    const expectedHeaderSize = this.calculateHeaderSize(header.flags);
-    if (header.header_size !== expectedHeaderSize) {
-      return false;
-    }
-    if (totalSize < header.header_size) {
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Serialize data into a Uint8Array buffer
-   */
-  static serialize(header, metadata = null, codecData = null, payload = null) {
-    const includeMetadata = metadata !== null && header.flags & FLAG_HAS_METADATA;
-    const includeCodec = codecData !== null && header.flags & FLAG_HAS_CODEC_DATA;
-    let totalSize = HEADER_DATA_SIZE;
-    if (includeMetadata) totalSize += HEADER_METADATA_SIZE;
-    if (includeCodec) totalSize += HEADER_CODEC_DATA_SIZE;
-    if (payload) totalSize += payload.length;
-    header.header_size = totalSize - (payload ? payload.length : 0);
-    const buffer = new ArrayBuffer(totalSize);
-    const view = new DataView(buffer);
-    let offset = 0;
-    view.setUint32(offset, header.magic, true);
-    offset += 4;
-    view.setUint32(offset, header.flags, true);
-    offset += 4;
-    view.setBigUint64(offset, header.pts, true);
-    offset += 8;
-    view.setBigUint64(offset, header.id, true);
-    offset += 8;
-    view.setUint16(offset, header.version, true);
-    offset += 2;
-    view.setUint16(offset, header.header_size, true);
-    offset += 2;
-    view.setUint16(offset, header.type, true);
-    offset += 2;
-    view.setUint16(offset, header.reserved, true);
-    offset += 2;
-    if (includeMetadata && metadata) {
-      const metadataBytes = this.stringToFixedBytes(metadata.metadata, 64);
-      new Uint8Array(buffer, offset, 64).set(metadataBytes);
-      offset += 64;
-    }
-    if (includeCodec && codecData) {
-      view.setUint32(offset, codecData.sample_rate, true);
-      offset += 4;
-      view.setUint32(offset, codecData.timebase_num, true);
-      offset += 4;
-      view.setUint32(offset, codecData.timebase_den, true);
-      offset += 4;
-      view.setUint16(offset, codecData.codec_profile, true);
-      offset += 2;
-      view.setUint16(offset, codecData.codec_level, true);
-      offset += 2;
-      view.setUint16(offset, codecData.width, true);
-      offset += 2;
-      view.setUint16(offset, codecData.height, true);
-      offset += 2;
-      view.setUint8(offset, codecData.codec_type);
-      offset += 1;
-      view.setUint8(offset, codecData.channels);
-      offset += 1;
-      view.setUint8(offset, codecData.bit_depth);
-      offset += 1;
-      view.setUint8(offset, codecData.reserved);
-      offset += 1;
-    }
-    if (payload && payload.length > 0) {
-      new Uint8Array(buffer, offset).set(payload);
-    }
-    return new Uint8Array(buffer);
-  }
-  /**
-   * Parse incoming binary data
-   */
-  static parseData(data) {
-    const result = {
-      valid: false,
-      header: null,
-      metadata: null,
-      codec_data: null,
-      payload: null,
-      payload_size: 0
-    };
-    if (!data || data.length < 36) {
-      return result;
-    }
-    const view = new DataView(data.buffer, data.byteOffset);
-    let offset = 0;
-    const header = {
-      magic: view.getUint32(offset, true),
-      flags: view.getUint32(offset + 4, true),
-      pts: view.getBigUint64(offset + 8, true),
-      id: view.getBigUint64(offset + 16, true),
-      version: view.getUint16(offset + 24, true),
-      header_size: view.getUint16(offset + 26, true),
-      type: view.getUint16(offset + 28, true),
-      reserved: view.getUint16(offset + 30, true)
-    };
-    offset += HEADER_DATA_SIZE;
-    if (!this.validateHeader(header, data.length)) {
-      return result;
-    }
-    result.header = header;
-    if (header.flags & FLAG_HAS_METADATA) {
-      if (data.length < offset + HEADER_METADATA_SIZE) {
-        return result;
-      }
-      const metadataBytes = data.slice(offset, offset + HEADER_METADATA_SIZE);
-      const metadataStr = this.fixedBytesToString(metadataBytes);
-      result.metadata = { metadata: metadataStr };
-      offset += HEADER_METADATA_SIZE;
-    }
-    if (header.flags & FLAG_HAS_CODEC_DATA) {
-      if (data.length < offset + HEADER_CODEC_DATA_SIZE) {
-        return result;
-      }
-      result.codec_data = {
-        sample_rate: view.getUint32(offset, true),
-        timebase_num: view.getUint32(offset + 4, true),
-        timebase_den: view.getUint32(offset + 8, true),
-        codec_profile: view.getUint16(offset + 12, true),
-        codec_level: view.getUint16(offset + 14, true),
-        width: view.getUint16(offset + 16, true),
-        height: view.getUint16(offset + 18, true),
-        codec_type: view.getUint8(offset + 20),
-        channels: view.getUint8(offset + 21),
-        bit_depth: view.getUint8(offset + 22),
-        reserved: view.getUint8(offset + 23)
-      };
-      offset += HEADER_CODEC_DATA_SIZE;
-    }
-    if (offset < data.length) {
-      result.payload = data.slice(offset);
-      result.payload_size = result.payload.length;
-    } else {
-      result.payload = new Uint8Array(0);
-      result.payload_size = 0;
-    }
-    result.valid = true;
     return result;
   }
-  /**
-   * Helper: Convert string to fixed-size byte array (null-terminated)
-   */
-  static stringToFixedBytes(str, size) {
-    const bytes = new Uint8Array(size);
-    let encoded;
-    if (typeof TextEncoder !== "undefined") {
-      const encoder = new TextEncoder();
-      encoded = encoder.encode(str);
-    } else {
-      encoded = new Uint8Array(Buffer.from(str, "utf8"));
-    }
-    const copyLen = Math.min(encoded.length, size - 1);
-    bytes.set(encoded.slice(0, copyLen));
-    bytes[copyLen] = 0;
-    return bytes;
-  }
-  /**
-   * Helper: Convert fixed-size byte array to string (null-terminated)
-   */
-  static fixedBytesToString(bytes) {
-    let len = bytes.length;
-    for (let i = 0; i < bytes.length; i++) {
-      if (bytes[i] === 0) {
-        len = i;
-        break;
-      }
-    }
-    if (typeof TextDecoder !== "undefined") {
-      const decoder = new TextDecoder();
-      return decoder.decode(bytes.slice(0, len));
-    } else {
-      return Buffer.from(bytes.slice(0, len)).toString("utf8");
-    }
-  }
 };
 
 // src/sesame-connection.ts
@@ -21800,14 +22192,16 @@ var SesameConnection = class extends EventEmitter2 {
     };
     this.messageHandler = (event) => {
       if (event.data instanceof ArrayBuffer) {
-        const parsed = SesameBinaryProtocol.parseData(new Uint8Array(event.data));
-        if (!parsed.valid) this.emit("error", new Error("Invalid packet received"));
-        if (parsed.header?.type == 1 /* VIDEO_FRAME */) {
-          this.emit("video-packet", event.data);
-        } else if (parsed.header?.type == 2 /* AUDIO_FRAME */) {
-          this.emit("audio-packet", event.data);
-        } else if (parsed.header?.type == 3 /* RPC */) {
+        const parsed = WireProtocol.parse(new Uint8Array(event.data));
+        if (!parsed.valid) {
+          this.emit("error", new Error("Invalid packet received"));
+          return;
+        }
+        const frameType = parsed.header?.type;
+        if (frameType === FrameType.FRAME_TYPE_RPC) {
           this.emit("rpc", parsed.payload);
+        } else {
+          this.emit("media-packet", parsed);
         }
       }
     };
@@ -21845,10 +22239,9 @@ var SesameConnection = class extends EventEmitter2 {
   }
   async send(data) {
     if (!this.isConnected()) throw new Error("Not connected");
-    const header = SesameBinaryProtocol.initHeader(3 /* RPC */, 0, BigInt(0), BigInt(0));
-    const data_to_send = SesameBinaryProtocol.serialize(header, null, null, data);
-    if (!data_to_send) throw new Error("Failed to serialize data");
-    this.socket.send(data_to_send);
+    const header = { type: sesame.v1.wire.FrameType.FRAME_TYPE_RPC };
+    const frame = WireProtocol.serialize(header, data);
+    this.socket.send(frame);
     return Promise.resolve();
   }
   async connect() {
@@ -21938,9 +22331,6 @@ var StatusApi = class {
   async getIODevices() {
     return this.rpc.service.requestIODeviceList(new sesame.v1.common.Empty());
   }
-  async requestKeyframe(outputId) {
-    await this.rpc.service.requestKeyframe({ id: outputId });
-  }
 };
 
 // src/recorder-api.ts
@@ -22089,9 +22479,7 @@ var SesameClient = class extends EventEmitter3 {
   constructor(portOrUrl) {
     super();
     this.subscriptions = [];
-    this.onVideoPacket = () => {
-    };
-    this.onAudioPacket = () => {
+    this.onMediaPacket = () => {
     };
     this.onCallbackMessage = () => {
     };
@@ -22137,8 +22525,7 @@ var SesameClient = class extends EventEmitter3 {
     this.conn.on("close", () => {
       this.emit("disconnected");
     });
-    this.conn.on("video-packet", (data) => this.onVideoPacket(this.videoSubscriptionId, data));
-    this.conn.on("audio-packet", (data) => this.onAudioPacket(this.videoSubscriptionId, data));
+    this.conn.on("media-packet", (frame) => this.onMediaPacket(this.mediaSubscriptionId, frame));
     this.subscriptions = [];
   }
   isConnected() {
@@ -22148,14 +22535,14 @@ var SesameClient = class extends EventEmitter3 {
     if (!this.isConnected()) return;
     const eventTopics = this.subscriptions.map((subscription) => subscription.topic);
     const channels = [];
-    if (this.videoSubscriptionId) channels.push(`video/${this.videoSubscriptionId}`);
+    if (this.mediaSubscriptionId) channels.push(`media-stream/${this.mediaSubscriptionId}`);
     let subs = { eventTopics, channels };
     this.rpc.service.updateSubscriptions(subs).catch((err) => {
       log.error(`Failed to update subscriptions: ${err.message}`);
     });
   }
-  addVideoSubscription(id) {
-    this.videoSubscriptionId = id;
+  addMediaSubscription(id) {
+    this.mediaSubscriptionId = id;
     this.sendSubscriptions();
   }
   addSubscription(topic, callback) {
@@ -22174,6 +22561,9 @@ var SesameClient = class extends EventEmitter3 {
   getService() {
     return this.rpc;
   }
+  async requestKeyframe(outputId) {
+    await this.rpc.service.requestKeyframe({ id: outputId });
+  }
   async execute(cl) {
     cl.filterCreatedAndDestroyedSources();
     if (cl.getCommandListMsg().commandList.length > 0) {
@@ -22196,17 +22586,18 @@ export {
   ConnectionState,
   EaseKind,
   Event,
+  FrameHeader,
+  FrameType,
   JobsApi,
   Message,
-  PacketType,
   RPCClient,
   RecorderApi,
   Request,
   Response,
-  SesameBinaryProtocol,
   SesameClient,
   SesameConnection,
   StatusApi,
+  WireProtocol,
   getLogger,
   log,
   sesame,