@stinkycomputing/sesame-api-client 1.4.1-alpha.9 → 1.4.1-beta.2

package/dist/index.browser.mjs

@@ -13699,15 +13699,22 @@ var sesame = $root.sesame = (() => {
         }
         TransportEvent.prototype.sourceId = "";
         TransportEvent.prototype.userId = "";
+        TransportEvent.prototype.uri = "";
         TransportEvent.prototype.state = 0;
         TransportEvent.prototype.durationUs = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
         TransportEvent.prototype.positionUs = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
         TransportEvent.prototype.materialPositionUs = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
+        TransportEvent.prototype.userTimeMs = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
+        TransportEvent.prototype.speed = 0;
         TransportEvent.prototype.userPlaylistId = "";
         TransportEvent.prototype.playlistIndex = 0;
         TransportEvent.prototype.playlistLength = 0;
         TransportEvent.prototype.clipId = $util.Long ? $util.Long.fromBits(0, 0, true) : 0;
         TransportEvent.prototype.clipPositionUs = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
+        TransportEvent.prototype.clipDurationUs = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
+        TransportEvent.prototype.preroll = 0;
+        TransportEvent.prototype.postroll = 0;
+        TransportEvent.prototype.metadata = "";
         TransportEvent.create = function create(properties) {
           return new TransportEvent(properties);
         };
@@ -13724,51 +13731,86 @@ var sesame = $root.sesame = (() => {
               /* id 2, wireType 2 =*/
               18
             ).string(message.userId);
+          if (message.uri != null && Object.hasOwnProperty.call(message, "uri"))
+            writer.uint32(
+              /* id 3, wireType 2 =*/
+              26
+            ).string(message.uri);
           if (message.state != null && Object.hasOwnProperty.call(message, "state"))
             writer.uint32(
-              /* id 3, wireType 0 =*/
-              24
+              /* id 4, wireType 0 =*/
+              32
             ).int32(message.state);
           if (message.durationUs != null && Object.hasOwnProperty.call(message, "durationUs"))
             writer.uint32(
-              /* id 4, wireType 0 =*/
-              32
+              /* id 5, wireType 0 =*/
+              40
             ).int64(message.durationUs);
           if (message.positionUs != null && Object.hasOwnProperty.call(message, "positionUs"))
             writer.uint32(
-              /* id 5, wireType 0 =*/
-              40
+              /* id 6, wireType 0 =*/
+              48
             ).int64(message.positionUs);
           if (message.materialPositionUs != null && Object.hasOwnProperty.call(message, "materialPositionUs"))
             writer.uint32(
-              /* id 6, wireType 0 =*/
-              48
+              /* id 7, wireType 0 =*/
+              56
             ).int64(message.materialPositionUs);
+          if (message.userTimeMs != null && Object.hasOwnProperty.call(message, "userTimeMs"))
+            writer.uint32(
+              /* id 8, wireType 0 =*/
+              64
+            ).int64(message.userTimeMs);
+          if (message.speed != null && Object.hasOwnProperty.call(message, "speed"))
+            writer.uint32(
+              /* id 9, wireType 5 =*/
+              77
+            ).float(message.speed);
           if (message.userPlaylistId != null && Object.hasOwnProperty.call(message, "userPlaylistId"))
             writer.uint32(
-              /* id 7, wireType 2 =*/
-              58
+              /* id 10, wireType 2 =*/
+              82
             ).string(message.userPlaylistId);
           if (message.playlistIndex != null && Object.hasOwnProperty.call(message, "playlistIndex"))
             writer.uint32(
-              /* id 8, wireType 0 =*/
-              64
+              /* id 11, wireType 0 =*/
+              88
             ).uint32(message.playlistIndex);
           if (message.playlistLength != null && Object.hasOwnProperty.call(message, "playlistLength"))
             writer.uint32(
-              /* id 9, wireType 0 =*/
-              72
+              /* id 12, wireType 0 =*/
+              96
             ).uint32(message.playlistLength);
           if (message.clipId != null && Object.hasOwnProperty.call(message, "clipId"))
             writer.uint32(
-              /* id 10, wireType 0 =*/
-              80
+              /* id 13, wireType 0 =*/
+              104
             ).uint64(message.clipId);
           if (message.clipPositionUs != null && Object.hasOwnProperty.call(message, "clipPositionUs"))
             writer.uint32(
-              /* id 11, wireType 0 =*/
-              88
+              /* id 14, wireType 0 =*/
+              112
             ).int64(message.clipPositionUs);
+          if (message.clipDurationUs != null && Object.hasOwnProperty.call(message, "clipDurationUs"))
+            writer.uint32(
+              /* id 15, wireType 0 =*/
+              120
+            ).int64(message.clipDurationUs);
+          if (message.preroll != null && Object.hasOwnProperty.call(message, "preroll"))
+            writer.uint32(
+              /* id 16, wireType 0 =*/
+              128
+            ).uint32(message.preroll);
+          if (message.postroll != null && Object.hasOwnProperty.call(message, "postroll"))
+            writer.uint32(
+              /* id 17, wireType 0 =*/
+              136
+            ).uint32(message.postroll);
+          if (message.metadata != null && Object.hasOwnProperty.call(message, "metadata"))
+            writer.uint32(
+              /* id 18, wireType 2 =*/
+              146
+            ).string(message.metadata);
           return writer;
         };
         TransportEvent.encodeDelimited = function encodeDelimited(message, writer) {
@@ -13792,41 +13834,69 @@ var sesame = $root.sesame = (() => {
                 break;
               }
               case 3: {
-                message.state = reader.int32();
+                message.uri = reader.string();
                 break;
               }
               case 4: {
-                message.durationUs = reader.int64();
+                message.state = reader.int32();
                 break;
               }
               case 5: {
-                message.positionUs = reader.int64();
+                message.durationUs = reader.int64();
                 break;
               }
               case 6: {
-                message.materialPositionUs = reader.int64();
+                message.positionUs = reader.int64();
                 break;
               }
               case 7: {
-                message.userPlaylistId = reader.string();
+                message.materialPositionUs = reader.int64();
                 break;
               }
               case 8: {
-                message.playlistIndex = reader.uint32();
+                message.userTimeMs = reader.int64();
                 break;
               }
               case 9: {
-                message.playlistLength = reader.uint32();
+                message.speed = reader.float();
                 break;
               }
               case 10: {
-                message.clipId = reader.uint64();
+                message.userPlaylistId = reader.string();
                 break;
               }
               case 11: {
+                message.playlistIndex = reader.uint32();
+                break;
+              }
+              case 12: {
+                message.playlistLength = reader.uint32();
+                break;
+              }
+              case 13: {
+                message.clipId = reader.uint64();
+                break;
+              }
+              case 14: {
                 message.clipPositionUs = reader.int64();
                 break;
               }
+              case 15: {
+                message.clipDurationUs = reader.int64();
+                break;
+              }
+              case 16: {
+                message.preroll = reader.uint32();
+                break;
+              }
+              case 17: {
+                message.postroll = reader.uint32();
+                break;
+              }
+              case 18: {
+                message.metadata = reader.string();
+                break;
+              }
               default:
                 reader.skipType(tag & 7);
                 break;
@@ -13850,6 +13920,10 @@ var sesame = $root.sesame = (() => {
             if (!$util.isString(message.userId))
               return "userId: string expected";
           }
+          if (message.uri != null && message.hasOwnProperty("uri")) {
+            if (!$util.isString(message.uri))
+              return "uri: string expected";
+          }
           if (message.state != null && message.hasOwnProperty("state"))
             switch (message.state) {
               default:
@@ -13873,6 +13947,14 @@ var sesame = $root.sesame = (() => {
             if (!$util.isInteger(message.materialPositionUs) && !(message.materialPositionUs && $util.isInteger(message.materialPositionUs.low) && $util.isInteger(message.materialPositionUs.high)))
               return "materialPositionUs: integer|Long expected";
           }
+          if (message.userTimeMs != null && message.hasOwnProperty("userTimeMs")) {
+            if (!$util.isInteger(message.userTimeMs) && !(message.userTimeMs && $util.isInteger(message.userTimeMs.low) && $util.isInteger(message.userTimeMs.high)))
+              return "userTimeMs: integer|Long expected";
+          }
+          if (message.speed != null && message.hasOwnProperty("speed")) {
+            if (typeof message.speed !== "number")
+              return "speed: number expected";
+          }
           if (message.userPlaylistId != null && message.hasOwnProperty("userPlaylistId")) {
             if (!$util.isString(message.userPlaylistId))
               return "userPlaylistId: string expected";
@@ -13893,6 +13975,22 @@ var sesame = $root.sesame = (() => {
             if (!$util.isInteger(message.clipPositionUs) && !(message.clipPositionUs && $util.isInteger(message.clipPositionUs.low) && $util.isInteger(message.clipPositionUs.high)))
               return "clipPositionUs: integer|Long expected";
           }
+          if (message.clipDurationUs != null && message.hasOwnProperty("clipDurationUs")) {
+            if (!$util.isInteger(message.clipDurationUs) && !(message.clipDurationUs && $util.isInteger(message.clipDurationUs.low) && $util.isInteger(message.clipDurationUs.high)))
+              return "clipDurationUs: integer|Long expected";
+          }
+          if (message.preroll != null && message.hasOwnProperty("preroll")) {
+            if (!$util.isInteger(message.preroll))
+              return "preroll: integer expected";
+          }
+          if (message.postroll != null && message.hasOwnProperty("postroll")) {
+            if (!$util.isInteger(message.postroll))
+              return "postroll: integer expected";
+          }
+          if (message.metadata != null && message.hasOwnProperty("metadata")) {
+            if (!$util.isString(message.metadata))
+              return "metadata: string expected";
+          }
           return null;
         };
         TransportEvent.fromObject = function fromObject(object) {
@@ -13903,6 +14001,8 @@ var sesame = $root.sesame = (() => {
             message.sourceId = String(object.sourceId);
           if (object.userId != null)
             message.userId = String(object.userId);
+          if (object.uri != null)
+            message.uri = String(object.uri);
           switch (object.state) {
             default:
               if (typeof object.state === "number") {
@@ -13961,6 +14061,18 @@ var sesame = $root.sesame = (() => {
             else if (typeof object.materialPositionUs === "object")
               message.materialPositionUs = new $util.LongBits(object.materialPositionUs.low >>> 0, object.materialPositionUs.high >>> 0).toNumber();
           }
+          if (object.userTimeMs != null) {
+            if ($util.Long)
+              (message.userTimeMs = $util.Long.fromValue(object.userTimeMs)).unsigned = false;
+            else if (typeof object.userTimeMs === "string")
+              message.userTimeMs = parseInt(object.userTimeMs, 10);
+            else if (typeof object.userTimeMs === "number")
+              message.userTimeMs = object.userTimeMs;
+            else if (typeof object.userTimeMs === "object")
+              message.userTimeMs = new $util.LongBits(object.userTimeMs.low >>> 0, object.userTimeMs.high >>> 0).toNumber();
+          }
+          if (object.speed != null)
+            message.speed = Number(object.speed);
           if (object.userPlaylistId != null)
             message.userPlaylistId = String(object.userPlaylistId);
           if (object.playlistIndex != null)
@@ -13987,6 +14099,22 @@ var sesame = $root.sesame = (() => {
             else if (typeof object.clipPositionUs === "object")
               message.clipPositionUs = new $util.LongBits(object.clipPositionUs.low >>> 0, object.clipPositionUs.high >>> 0).toNumber();
           }
+          if (object.clipDurationUs != null) {
+            if ($util.Long)
+              (message.clipDurationUs = $util.Long.fromValue(object.clipDurationUs)).unsigned = false;
+            else if (typeof object.clipDurationUs === "string")
+              message.clipDurationUs = parseInt(object.clipDurationUs, 10);
+            else if (typeof object.clipDurationUs === "number")
+              message.clipDurationUs = object.clipDurationUs;
+            else if (typeof object.clipDurationUs === "object")
+              message.clipDurationUs = new $util.LongBits(object.clipDurationUs.low >>> 0, object.clipDurationUs.high >>> 0).toNumber();
+          }
+          if (object.preroll != null)
+            message.preroll = object.preroll >>> 0;
+          if (object.postroll != null)
+            message.postroll = object.postroll >>> 0;
+          if (object.metadata != null)
+            message.metadata = String(object.metadata);
           return message;
         };
         TransportEvent.toObject = function toObject(message, options) {
@@ -13996,6 +14124,7 @@ var sesame = $root.sesame = (() => {
           if (options.defaults) {
             object.sourceId = "";
             object.userId = "";
+            object.uri = "";
             object.state = options.enums === String ? "SOURCE_TRANSPORT_STATE_STOPPED" : 0;
             if ($util.Long) {
               let long = new $util.Long(0, 0, false);
@@ -14012,6 +14141,12 @@ var sesame = $root.sesame = (() => {
               object.materialPositionUs = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
             } else
               object.materialPositionUs = options.longs === String ? "0" : 0;
+            if ($util.Long) {
+              let long = new $util.Long(0, 0, false);
+              object.userTimeMs = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+            } else
+              object.userTimeMs = options.longs === String ? "0" : 0;
+            object.speed = 0;
             object.userPlaylistId = "";
             object.playlistIndex = 0;
             object.playlistLength = 0;
@@ -14025,11 +14160,21 @@ var sesame = $root.sesame = (() => {
               object.clipPositionUs = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
             } else
               object.clipPositionUs = options.longs === String ? "0" : 0;
+            if ($util.Long) {
+              let long = new $util.Long(0, 0, false);
+              object.clipDurationUs = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+            } else
+              object.clipDurationUs = options.longs === String ? "0" : 0;
+            object.preroll = 0;
+            object.postroll = 0;
+            object.metadata = "";
           }
           if (message.sourceId != null && message.hasOwnProperty("sourceId"))
             object.sourceId = message.sourceId;
           if (message.userId != null && message.hasOwnProperty("userId"))
             object.userId = message.userId;
+          if (message.uri != null && message.hasOwnProperty("uri"))
+            object.uri = message.uri;
           if (message.state != null && message.hasOwnProperty("state"))
             object.state = options.enums === String ? $root.sesame.v1.sources.SourceTransportState[message.state] === void 0 ? message.state : $root.sesame.v1.sources.SourceTransportState[message.state] : message.state;
           if (message.durationUs != null && message.hasOwnProperty("durationUs"))
@@ -14047,6 +14192,13 @@ var sesame = $root.sesame = (() => {
               object.materialPositionUs = options.longs === String ? String(message.materialPositionUs) : message.materialPositionUs;
             else
               object.materialPositionUs = options.longs === String ? $util.Long.prototype.toString.call(message.materialPositionUs) : options.longs === Number ? new $util.LongBits(message.materialPositionUs.low >>> 0, message.materialPositionUs.high >>> 0).toNumber() : message.materialPositionUs;
+          if (message.userTimeMs != null && message.hasOwnProperty("userTimeMs"))
+            if (typeof message.userTimeMs === "number")
+              object.userTimeMs = options.longs === String ? String(message.userTimeMs) : message.userTimeMs;
+            else
+              object.userTimeMs = options.longs === String ? $util.Long.prototype.toString.call(message.userTimeMs) : options.longs === Number ? new $util.LongBits(message.userTimeMs.low >>> 0, message.userTimeMs.high >>> 0).toNumber() : message.userTimeMs;
+          if (message.speed != null && message.hasOwnProperty("speed"))
+            object.speed = options.json && !isFinite(message.speed) ? String(message.speed) : message.speed;
           if (message.userPlaylistId != null && message.hasOwnProperty("userPlaylistId"))
             object.userPlaylistId = message.userPlaylistId;
           if (message.playlistIndex != null && message.hasOwnProperty("playlistIndex"))
@@ -14063,6 +14215,17 @@ var sesame = $root.sesame = (() => {
               object.clipPositionUs = options.longs === String ? String(message.clipPositionUs) : message.clipPositionUs;
             else
               object.clipPositionUs = options.longs === String ? $util.Long.prototype.toString.call(message.clipPositionUs) : options.longs === Number ? new $util.LongBits(message.clipPositionUs.low >>> 0, message.clipPositionUs.high >>> 0).toNumber() : message.clipPositionUs;
+          if (message.clipDurationUs != null && message.hasOwnProperty("clipDurationUs"))
+            if (typeof message.clipDurationUs === "number")
+              object.clipDurationUs = options.longs === String ? String(message.clipDurationUs) : message.clipDurationUs;
+            else
+              object.clipDurationUs = options.longs === String ? $util.Long.prototype.toString.call(message.clipDurationUs) : options.longs === Number ? new $util.LongBits(message.clipDurationUs.low >>> 0, message.clipDurationUs.high >>> 0).toNumber() : message.clipDurationUs;
+          if (message.preroll != null && message.hasOwnProperty("preroll"))
+            object.preroll = message.preroll;
+          if (message.postroll != null && message.hasOwnProperty("postroll"))
+            object.postroll = message.postroll;
+          if (message.metadata != null && message.hasOwnProperty("metadata"))
+            object.metadata = message.metadata;
           return object;
         };
         TransportEvent.prototype.toJSON = function toJSON() {
@@ -21449,108 +21612,710 @@ var sesame = $root.sesame = (() => {
       }();
       return rpc;
     }();
-    return v1;
-  }();
-  return sesame2;
-})();
-
-// src/command-list.ts
-var CommandList = class {
-  constructor() {
-    this.cl = new sesame.v1.commands.CommandList();
-    this.cl.commandList = [];
-  }
-  add(item, timeOffsetMs, transaction) {
-    item.timeOffsetUs = (timeOffsetMs || 0) * 1e3;
-    if (transaction) {
-      item.transactionDeps = transaction?.dependencies || [];
-      item.transactionId = transaction.transactionId;
-    }
-    this.cl.commandList.push(item);
-    return item;
-  }
-  applyTransaction(transaction) {
-    this.cl.commandList.forEach((item) => {
-      if (transaction.transactionId !== void 0) {
-        item.transactionId = transaction.transactionId;
-      }
-      if (transaction.dependencies !== void 0) {
-        item.transactionDeps = item.transactionDeps ? item.transactionDeps.concat(transaction.dependencies) : transaction.dependencies;
-      }
-    });
-  }
-  getLength() {
-    return this.cl.commandList.length;
-  }
-  filterCreatedAndDestroyedSources() {
-    const created = /* @__PURE__ */ new Map();
-    const createdAndRemoved = [];
-    for (let i = 0; i < this.cl.commandList.length; i++) {
-      if (this.cl.commandList[i].addSource) {
-        created.set(this.cl.commandList[i].addSource.id, this.cl.commandList[i]);
-      } else if (this.cl.commandList[i].removeSource) {
-        const id = this.cl.commandList[i].removeSource.id;
-        if (created.has(id)) {
-          createdAndRemoved.push({ add: created.get(id), del: this.cl.commandList[i] });
+    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;
+        values[valuesById[6] = "FRAME_TYPE_DATA"] = 6;
+        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]];
+          }
         }
-      }
-    }
-    createdAndRemoved.forEach((item) => {
-      this.cl.commandList.splice(this.cl.commandList.indexOf(item.add), 1);
-      this.cl.commandList.splice(this.cl.commandList.indexOf(item.del), 1);
-    });
-  }
-  getCommandListMsg() {
-    return this.cl;
-  }
-  callback(event, data, timeOffsetMs) {
-    let item = new sesame.v1.commands.CommandListItem();
-    item.callback = { event, data };
-    return this.add(item, timeOffsetMs);
-  }
-  compositorAdd(id, width, height, multisample, timeOffsetMs) {
-    let item = new sesame.v1.commands.CommandListItem();
-    item.addCompositor = { id, multisample, width, height };
-    return this.add(item, timeOffsetMs);
-  }
-  compositorRemove(id, timeOffsetMs) {
-    let item = new sesame.v1.commands.CommandListItem();
-    item.removeCompositor = { id };
-    return this.add(item, timeOffsetMs);
-  }
-  compositorClear(id, timeOffsetMs) {
-    let item = new sesame.v1.commands.CommandListItem();
-    item.clearCompositor = { id };
-    return this.add(item, timeOffsetMs);
-  }
-  sourceAdd(id, cfg, timeOffsetMs) {
-    let item = new sesame.v1.commands.CommandListItem();
-    item.addSource = { id, config: cfg };
-    return this.add(item, timeOffsetMs);
-  }
-  sourceRemove(id, timeOffsetMs) {
-    let item = new sesame.v1.commands.CommandListItem();
-    item.removeSource = { id };
-    return this.add(item, timeOffsetMs);
-  }
-  nodeAdd(id, cfg, timeOffsetMs) {
-    let item = new sesame.v1.commands.CommandListItem();
-    item.addNode = {
-      compositorId: cfg.compositorId,
-      nodeId: id,
-      parentAddress: cfg.parentAddress || "",
-      nodeType: cfg.nodeType
-    };
-    return this.add(item, timeOffsetMs);
-  }
-  nodeRemove(compositorId, address, timeOffsetMs) {
-    let item = new sesame.v1.commands.CommandListItem();
-    item.removeNode = { compositorId, address };
-    return this.add(item, timeOffsetMs);
-  }
-  propertySet(propertyDomain, addr, prop, val, timeOffsetMs) {
-    let item = new sesame.v1.commands.CommandListItem();
-    item.setProperty = {
+        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:
+              case 6:
+                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;
+            case "FRAME_TYPE_DATA":
+            case 6:
+              message.type = 6;
+              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;
+})();
+
+// src/command-list.ts
+var CommandList = class {
+  constructor() {
+    this.cl = new sesame.v1.commands.CommandList();
+    this.cl.commandList = [];
+  }
+  add(item, timeOffsetMs, transaction) {
+    item.timeOffsetUs = (timeOffsetMs || 0) * 1e3;
+    if (transaction) {
+      item.transactionDeps = transaction?.dependencies || [];
+      item.transactionId = transaction.transactionId;
+    }
+    this.cl.commandList.push(item);
+    return item;
+  }
+  applyTransaction(transaction) {
+    this.cl.commandList.forEach((item) => {
+      if (transaction.transactionId !== void 0) {
+        item.transactionId = transaction.transactionId;
+      }
+      if (transaction.dependencies !== void 0) {
+        item.transactionDeps = item.transactionDeps ? item.transactionDeps.concat(transaction.dependencies) : transaction.dependencies;
+      }
+    });
+  }
+  getLength() {
+    return this.cl.commandList.length;
+  }
+  filterCreatedAndDestroyedSources() {
+    const created = /* @__PURE__ */ new Map();
+    const createdAndRemoved = [];
+    for (let i = 0; i < this.cl.commandList.length; i++) {
+      if (this.cl.commandList[i].addSource) {
+        created.set(this.cl.commandList[i].addSource.id, this.cl.commandList[i]);
+      } else if (this.cl.commandList[i].removeSource) {
+        const id = this.cl.commandList[i].removeSource.id;
+        if (created.has(id)) {
+          createdAndRemoved.push({ add: created.get(id), del: this.cl.commandList[i] });
+        }
+      }
+    }
+    createdAndRemoved.forEach((item) => {
+      this.cl.commandList.splice(this.cl.commandList.indexOf(item.add), 1);
+      this.cl.commandList.splice(this.cl.commandList.indexOf(item.del), 1);
+    });
+  }
+  getCommandListMsg() {
+    return this.cl;
+  }
+  callback(event, data, timeOffsetMs) {
+    let item = new sesame.v1.commands.CommandListItem();
+    item.callback = { event, data };
+    return this.add(item, timeOffsetMs);
+  }
+  compositorAdd(id, width, height, multisample, timeOffsetMs) {
+    let item = new sesame.v1.commands.CommandListItem();
+    item.addCompositor = { id, multisample, width, height };
+    return this.add(item, timeOffsetMs);
+  }
+  compositorRemove(id, timeOffsetMs) {
+    let item = new sesame.v1.commands.CommandListItem();
+    item.removeCompositor = { id };
+    return this.add(item, timeOffsetMs);
+  }
+  compositorClear(id, timeOffsetMs) {
+    let item = new sesame.v1.commands.CommandListItem();
+    item.clearCompositor = { id };
+    return this.add(item, timeOffsetMs);
+  }
+  sourceAdd(id, cfg, timeOffsetMs) {
+    let item = new sesame.v1.commands.CommandListItem();
+    item.addSource = { id, config: cfg };
+    return this.add(item, timeOffsetMs);
+  }
+  sourceRemove(id, timeOffsetMs) {
+    let item = new sesame.v1.commands.CommandListItem();
+    item.removeSource = { id };
+    return this.add(item, timeOffsetMs);
+  }
+  nodeAdd(id, cfg, timeOffsetMs) {
+    let item = new sesame.v1.commands.CommandListItem();
+    item.addNode = {
+      compositorId: cfg.compositorId,
+      nodeId: id,
+      parentAddress: cfg.parentAddress || "",
+      nodeType: cfg.nodeType
+    };
+    return this.add(item, timeOffsetMs);
+  }
+  nodeRemove(compositorId, address, timeOffsetMs) {
+    let item = new sesame.v1.commands.CommandListItem();
+    item.removeNode = { compositorId, address };
+    return this.add(item, timeOffsetMs);
+  }
+  propertySet(propertyDomain, addr, prop, val, timeOffsetMs) {
+    let item = new sesame.v1.commands.CommandListItem();
+    item.setProperty = {
       address: addr,
       property: prop,
       domain: propertyDomain,
@@ -21888,7 +22653,8 @@ var RPCClient = class extends import_events.EventEmitter {
   eventHandler(event) {
     const topic = event.topic ?? 0;
     if (topic === sesame.v1.common.EventTopic.EVENT_TOPIC_UNSPECIFIED) {
-      throw new Error(`Unknown event topic: ${event.topic}`);
+      log.warn(`Ignoring event with unspecified topic: ${event.topic}`);
+      return;
     }
     const type = this.eventTypes[topic];
     let payload;
@@ -21914,255 +22680,58 @@ var RPCClient = class extends import_events.EventEmitter {
 // src/sesame-connection.ts
 var import_events2 = __toESM(require_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 {
+// 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 {
   /**
-   * Initialize a header data structure with proper defaults
+   * Serialize a wire frame: 4-byte LE header_size + protobuf FrameHeader + payload.
    */
-  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
-    };
-  }
-  /**
-   * Calculate the total header size based on flags
-   */
-  static calculateHeaderSize(flags) {
-    let size = HEADER_DATA_SIZE;
-    if (flags & FLAG_HAS_METADATA) {
-      size += HEADER_METADATA_SIZE;
-    }
-    if (flags & FLAG_HAS_CODEC_DATA) {
-      size += HEADER_CODEC_DATA_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);
     }
-    return size;
+    return buffer;
   }
   /**
-   * Validate a header structure
+   * Parse an incoming wire frame.
    */
-  static validateHeader(header, totalSize) {
-    if (header.magic !== PROTOCOL_MAGIC) {
-      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 {
     }
-    if (header.version !== PROTOCOL_VERSION) {
-      return false;
-    }
-    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
+var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
+  ConnectionState2["Disconnected"] = "disconnected";
+  ConnectionState2["Connecting"] = "connecting";
+  ConnectionState2["Connected"] = "connected";
+  ConnectionState2["Reconnecting"] = "reconnecting";
+  return ConnectionState2;
+})(ConnectionState || {});
 function waitForEvent(emitter, eventName) {
   return new Promise((resolve) => {
     emitter.once(eventName, resolve);
@@ -22175,6 +22744,7 @@ var SesameConnection = class extends import_events2.EventEmitter {
     this.numRetries = 0;
     this.url = "";
     this.autoReconnect = true;
+    this._state = "disconnected" /* Disconnected */;
     /* Bound listeners so we can removeEventListener later */
     this.boundMessageHandler = (event) => this.messageHandler(event);
     this.boundOpenHandler = () => this.openHandler();
@@ -22182,38 +22752,68 @@ var SesameConnection = class extends import_events2.EventEmitter {
     this.boundErrorHandler = (event) => this.errorHandler(event);
     this.openHandler = () => {
       this.numRetries = 0;
+      this.setState("connected" /* Connected */);
       this.emit("open");
     };
     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);
         }
       }
     };
     this.url = options.url;
     this.autoReconnect = options.autoReconnect;
-    if (options.autoConnect) this.connect().catch(() => log.debug("failed connect"));
+    if (options.autoConnect) this.connect().catch(() => {
+    });
+  }
+  get state() {
+    return this._state;
+  }
+  setState(newState) {
+    if (this._state === newState) return;
+    const prev = this._state;
+    this._state = newState;
+    switch (newState) {
+      case "connected" /* Connected */:
+        log.info("Connected to Sesame");
+        break;
+      case "reconnecting" /* Reconnecting */:
+        if (prev === "connected" /* Connected */) {
+          log.warn("Lost connection to Sesame, will try reconnect..");
+        } else {
+          log.warn("Failed to connect to Sesame, will try reconnect..");
+        }
+        break;
+      case "disconnected" /* Disconnected */:
+        log.info("Disconnected from Sesame");
+        break;
+    }
+    this.emit("state", newState, prev);
   }
   isConnected() {
     return this.socket !== void 0 && this.socket.readyState === WebSocket.OPEN;
   }
   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() {
     this.active = true;
+    if (this._state === "disconnected" /* Disconnected */) {
+      this.setState("connecting" /* Connecting */);
+    }
     this.socket = new WebSocket(this.url);
     this.socket.addEventListener("message", this.boundMessageHandler);
     this.socket.addEventListener("open", this.boundOpenHandler);
@@ -22236,6 +22836,7 @@ var SesameConnection = class extends import_events2.EventEmitter {
   async disconnect() {
     this.active = false;
     if (!this.socket) {
+      this.setState("disconnected" /* Disconnected */);
       return;
     }
     const sock = this.socket;
@@ -22253,7 +22854,8 @@ var SesameConnection = class extends import_events2.EventEmitter {
   }
   retryHandler() {
     if (this.active && this.autoReconnect) {
-      this.connect().catch((err) => log.error("Retry failed", err));
+      this.connect().catch(() => {
+      });
     }
   }
   closeHandler() {
@@ -22263,13 +22865,17 @@ var SesameConnection = class extends import_events2.EventEmitter {
     }
     this.socket = void 0;
     if (this.active) {
-      try {
+      if (this.autoReconnect) {
+        this.setState("reconnecting" /* Reconnecting */);
         setTimeout(() => {
           this.retryHandler();
         }, defaultBackoff(++this.numRetries));
-      } catch (err) {
-        log.error("Connection error", err);
+      } else {
+        this.active = false;
+        this.setState("disconnected" /* Disconnected */);
       }
+    } else {
+      this.setState("disconnected" /* Disconnected */);
     }
   }
   errorHandler(error) {
@@ -22295,9 +22901,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
@@ -22446,10 +23049,7 @@ var SesameClient = class extends import_events3.EventEmitter {
   constructor(portOrUrl) {
     super();
     this.subscriptions = [];
-    this.errorIsLogged = false;
-    this.onVideoPacket = () => {
-    };
-    this.onAudioPacket = () => {
+    this.onMediaPacket = () => {
     };
     this.onCallbackMessage = () => {
     };
@@ -22460,10 +23060,6 @@ var SesameClient = class extends import_events3.EventEmitter {
       autoReconnect: true
     });
     this.conn.on("error", () => {
-      if (!this.errorIsLogged) {
-        log.warn("Could not connect to Sesame Engine, will keep trying..");
-        this.errorIsLogged = true;
-      }
     });
     let events = {
       [sesame.v1.common.EventTopic.EVENT_TOPIC_ERROR]: sesame.v1.status.Event,
@@ -22488,18 +23084,18 @@ var SesameClient = class extends import_events3.EventEmitter {
       }
     });
     this.rpc.on("error", (err) => {
-      log.error(`RPC error: ${err.message}`);
+      if (this.isConnected()) {
+        log.error(`RPC error: ${err.message}`);
+      }
     });
     this.conn.on("open", async () => {
       this.sendSubscriptions();
-      this.errorIsLogged = false;
       this.emit("connected");
     });
     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() {
@@ -22509,14 +23105,14 @@ var SesameClient = class extends import_events3.EventEmitter {
     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) {
@@ -22535,6 +23131,9 @@ var SesameClient = class extends import_events3.EventEmitter {
   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) {
@@ -22554,19 +23153,21 @@ var Event = sesame.v1.rpc.Event;
 export {
   CodecType,
   CommandList,
+  ConnectionState,
   EaseKind,
   Event,
+  FrameHeader,
+  FrameType,
   JobsApi,
   Message,
-  PacketType,
   RPCClient,
   RecorderApi,
   Request,
   Response,
-  SesameBinaryProtocol,
   SesameClient,
   SesameConnection,
   StatusApi,
+  WireProtocol,
   getLogger,
   log,
   sesame,