@supraio/client-daemon-js 0.0.1 → 1.0.0-mzbrightsigndecoder.477

package/daemon.js

@@ -10290,12 +10290,12 @@
                 if (process2["initializeTTYs"]) {
                   process2["initializeTTYs"]();
                 }
-                function install2(obj) {
+                function install(obj) {
                   obj.Buffer = Buffer2;
                   obj.process = process2;
                   var oldRequire = obj.require ? obj.require : null;
                   obj.require = function(arg) {
-                    var rv = BFSRequire(arg);
+                    var rv = BFSRequire2(arg);
                     if (!rv) {
                       return oldRequire.apply(null, Array.prototype.slice.call(arguments, 0));
                     } else {
@@ -10306,7 +10306,7 @@
                 function registerFileSystem(name, fs2) {
                   Backends[name] = fs2;
                 }
-                function BFSRequire(module4) {
+                function BFSRequire2(module4) {
                   switch (module4) {
                     case "fs":
                       return _fsMock;
@@ -10421,9 +10421,9 @@
                     };
                   }
                 }
-                exports2.install = install2;
+                exports2.install = install;
                 exports2.registerFileSystem = registerFileSystem;
-                exports2.BFSRequire = BFSRequire;
+                exports2.BFSRequire = BFSRequire2;
                 exports2.initialize = initialize;
                 exports2.configure = configure2;
                 exports2.getFileSystem = getFileSystem;
@@ -16830,6 +16830,3992 @@
     }
   });
 
+  // node_modules/@signageos/brightsign-decoder/dist/contracts.js
+  var require_contracts = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/contracts.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.ConnectionState = exports.FrameType = void 0;
+      var FrameType;
+      (function(FrameType2) {
+        FrameType2[FrameType2["Delta"] = 0] = "Delta";
+        FrameType2[FrameType2["Key"] = 1] = "Key";
+      })(FrameType || (exports.FrameType = FrameType = {}));
+      var ConnectionState;
+      (function(ConnectionState2) {
+        ConnectionState2["Connecting"] = "connecting";
+        ConnectionState2["Connected"] = "connected";
+        ConnectionState2["Closed"] = "closed";
+        ConnectionState2["Error"] = "error";
+      })(ConnectionState || (exports.ConnectionState = ConnectionState = {}));
+    }
+  });
+
+  // node_modules/@signageos/brightsign-decoder/dist/tcp/PacketParser.js
+  var require_PacketParser = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/tcp/PacketParser.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.PacketParser = void 0;
+      var HEADER_SIZE = 2;
+      var DEFAULT_MAX_PACKET_SIZE = 32 * 1024;
+      var DEFAULT_MAX_QUEUED_BYTES = 1024 * 1024;
+      var PacketParser = class {
+        constructor(options) {
+          this.chunks = [];
+          this.headIndex = 0;
+          this.chunkOffset = 0;
+          this.queuedBytes = 0;
+          this.pending = [];
+          this.maxPacketSize = options !== void 0 && options !== null && options.maxPacketSize !== void 0 ? options.maxPacketSize : DEFAULT_MAX_PACKET_SIZE;
+          this.maxQueuedBytes = options !== void 0 && options !== null && options.maxQueuedBytes !== void 0 ? options.maxQueuedBytes : DEFAULT_MAX_QUEUED_BYTES;
+          if (!Number.isSafeInteger(this.maxPacketSize) || this.maxPacketSize <= 0 || this.maxPacketSize > 65535) {
+            throw new RangeError(`maxPacketSize must be an integer in 1..65535, got ${this.maxPacketSize}`);
+          }
+          if (!Number.isSafeInteger(this.maxQueuedBytes) || this.maxQueuedBytes <= 0) {
+            throw new RangeError(`maxQueuedBytes must be positive, got ${this.maxQueuedBytes}`);
+          }
+        }
+        /** Push a socket chunk. Returns array of complete packets parsed so far. */
+        push(data) {
+          if (data.byteLength === 0) {
+            return [];
+          }
+          const nextQueuedBytes = this.queuedBytes + data.byteLength;
+          if (nextQueuedBytes > this.maxQueuedBytes) {
+            throw new RangeError(`Queued bytes would exceed limit: ${nextQueuedBytes} > ${this.maxQueuedBytes}`);
+          }
+          this.chunks.push(data);
+          this.queuedBytes = nextQueuedBytes;
+          this.pending.length = 0;
+          this.parse();
+          const result = this.pending.slice();
+          this.pending.length = 0;
+          return result;
+        }
+        /** Verify no leftover bytes remain. */
+        finish() {
+          if (this.queuedBytes !== 0) {
+            throw new Error(`TCP stream ended with ${this.queuedBytes} unparsed bytes`);
+          }
+        }
+        /** Clear buffered chunks, cursors, and pending parser state. */
+        reset() {
+          this.clearState();
+        }
+        /** Idempotently discard all parser state. */
+        destroy() {
+          this.clearState();
+        }
+        /** Current number of queued bytes. */
+        get bufferedBytes() {
+          return this.queuedBytes;
+        }
+        peekByte(offset) {
+          let remaining = offset;
+          for (let index = this.headIndex; index < this.chunks.length; index += 1) {
+            const start = index === this.headIndex ? this.chunkOffset : 0;
+            const chunk = this.chunks[index];
+            if (chunk === void 0) {
+              break;
+            }
+            const available = chunk.byteLength - start;
+            if (remaining < available) {
+              const byteValue = chunk[start + remaining];
+              if (byteValue === void 0) {
+                throw new Error("Packet parser peek: unexpected undefined byte");
+              }
+              return byteValue;
+            }
+            remaining -= available;
+          }
+          throw new Error("Packet parser peek exceeded queued bytes");
+        }
+        readInto(destination) {
+          let written = 0;
+          while (written < destination.byteLength) {
+            const chunk = this.chunks[this.headIndex];
+            if (chunk === void 0) {
+              throw new Error("Packet parser read: no more chunks");
+            }
+            const available = chunk.byteLength - this.chunkOffset;
+            const length = Math.min(available, destination.byteLength - written);
+            destination.set(chunk.subarray(this.chunkOffset, this.chunkOffset + length), written);
+            written += length;
+            this.chunkOffset += length;
+            this.queuedBytes -= length;
+            if (this.chunkOffset === chunk.byteLength) {
+              this.headIndex += 1;
+              this.chunkOffset = 0;
+              if (this.queuedBytes === 0) {
+                this.chunks.length = 0;
+                this.headIndex = 0;
+              } else if (this.headIndex >= 16 && this.headIndex * 2 >= this.chunks.length) {
+                this.chunks.splice(0, this.headIndex);
+                this.headIndex = 0;
+              }
+            }
+          }
+        }
+        parse() {
+          while (this.queuedBytes >= HEADER_SIZE) {
+            const packetLength = this.peekByte(0) * 256 + this.peekByte(1);
+            if (packetLength === 0) {
+              throw new RangeError("Packet length is zero");
+            }
+            if (packetLength > this.maxPacketSize) {
+              throw new RangeError(`Packet length ${packetLength} exceeds maxPacketSize ${this.maxPacketSize}`);
+            }
+            if (this.queuedBytes < packetLength + HEADER_SIZE) {
+              return;
+            }
+            const header = new Uint8Array(HEADER_SIZE);
+            this.readInto(header);
+            const packet = new Uint8Array(packetLength);
+            this.readInto(packet);
+            this.pending.push(packet);
+          }
+        }
+        clearState() {
+          this.chunks.length = 0;
+          this.headIndex = 0;
+          this.chunkOffset = 0;
+          this.queuedBytes = 0;
+          this.pending.length = 0;
+        }
+      };
+      exports.PacketParser = PacketParser;
+    }
+  });
+
+  // node_modules/@signageos/brightsign-decoder/dist/frame/protocol.js
+  var require_protocol = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/frame/protocol.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.FIRST_HEADER_SIZE = exports.FIRST_PACKET_EXTRA = exports.GENERAL_HEADER_SIZE = void 0;
+      exports.parseInnerHeader = parseInnerHeader;
+      exports.parseFirstPacketMeta = parseFirstPacketMeta;
+      exports.GENERAL_HEADER_SIZE = 6;
+      exports.FIRST_PACKET_EXTRA = 9;
+      exports.FIRST_HEADER_SIZE = exports.GENERAL_HEADER_SIZE + exports.FIRST_PACKET_EXTRA;
+      function parseInnerHeader(packet) {
+        if (packet.byteLength < exports.GENERAL_HEADER_SIZE) {
+          throw new RangeError(`Packet too short for inner header: ${packet.byteLength} < ${exports.GENERAL_HEADER_SIZE}`);
+        }
+        const view = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+        return {
+          frameId: view.getUint16(0),
+          sequence: view.getUint16(2),
+          totalPackets: view.getUint16(4)
+        };
+      }
+      function parseFirstPacketMeta(packet) {
+        if (packet.byteLength < exports.FIRST_HEADER_SIZE) {
+          throw new RangeError(`Packet too short for first-packet header: ${packet.byteLength} < ${exports.FIRST_HEADER_SIZE}`);
+        }
+        const view = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+        return {
+          frameType: view.getUint8(6),
+          timestampHi: view.getUint32(7),
+          timestampLo: view.getUint32(11)
+        };
+      }
+    }
+  });
+
+  // node_modules/@signageos/brightsign-decoder/dist/frame/FrameCollector.js
+  var require_FrameCollector = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/frame/FrameCollector.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.FrameCollector = void 0;
+      var contracts_1 = require_contracts();
+      var protocol_1 = require_protocol();
+      var DEFAULT_MAX_ASSEMBLING = 16;
+      var DEFAULT_MAX_COMPLETED = 1;
+      var DEFAULT_MAX_PACKET_SIZE = 32 * 1024;
+      var DEFAULT_MAX_FRAME_SIZE = 4 * 1024 * 1024;
+      function validatePositiveInt(name, value) {
+        if (!Number.isInteger(value) || value <= 0) {
+          throw new RangeError(`${name} must be a positive integer, got ${value}`);
+        }
+      }
+      var FrameCollector = class {
+        constructor(registry, options) {
+          this.assembling = /* @__PURE__ */ new Map();
+          this.completed = [];
+          this.registry = registry;
+          this.maxAssembling = options !== void 0 && options !== null && options.maxAssembling !== void 0 ? options.maxAssembling : DEFAULT_MAX_ASSEMBLING;
+          this.maxCompleted = options !== void 0 && options !== null && options.maxCompleted !== void 0 ? options.maxCompleted : DEFAULT_MAX_COMPLETED;
+          this.maxPacketSize = options !== void 0 && options !== null && options.maxPacketSize !== void 0 ? options.maxPacketSize : DEFAULT_MAX_PACKET_SIZE;
+          this.maxFrameSize = options !== void 0 && options !== null && options.maxFrameSize !== void 0 ? options.maxFrameSize : DEFAULT_MAX_FRAME_SIZE;
+          validatePositiveInt("maxAssembling", this.maxAssembling);
+          validatePositiveInt("maxCompleted", this.maxCompleted);
+          validatePositiveInt("maxPacketSize", this.maxPacketSize);
+          validatePositiveInt("maxFrameSize", this.maxFrameSize);
+          if (this.maxPacketSize <= protocol_1.FIRST_HEADER_SIZE) {
+            throw new RangeError(`maxPacketSize (${this.maxPacketSize}) must be greater than first-packet header size (${protocol_1.FIRST_HEADER_SIZE})`);
+          }
+        }
+        /** Can the collector accept another packet? */
+        get canAccept() {
+          return this.completed.length < this.maxCompleted || this.assembling.size < this.maxAssembling;
+        }
+        /** Number of completed frames awaiting consumption. */
+        get completedCount() {
+          return this.completed.length;
+        }
+        /** Number of currently assembling frames. */
+        get assemblingCount() {
+          return this.assembling.size;
+        }
+        /** Is the completed queue full? */
+        get isCompletedFull() {
+          return this.completed.length >= this.maxCompleted;
+        }
+        /** Take the oldest completed frame reference and transfer exposure to the caller. Returns undefined if none. */
+        take() {
+          const completedFrame = this.completed.shift();
+          if (completedFrame !== void 0) {
+            this.promoteReadyFrames();
+          }
+          return completedFrame;
+        }
+        /**
+         * Accept a protocol fragment packet.
+         * Completed frames stay owned by the collector until a later take() call
+         * dequeues the oldest ready frame in first-seen order.
+         */
+        accept(packet) {
+          if (packet.byteLength > this.maxPacketSize) {
+            throw new RangeError(`Inner packet length ${packet.byteLength} exceeds maxPacketSize ${this.maxPacketSize}`);
+          }
+          const header = (0, protocol_1.parseInnerHeader)(packet);
+          const { frameId, sequence, totalPackets } = header;
+          if (totalPackets === 0) {
+            throw new RangeError(`Frame ${frameId}: totalPackets is zero`);
+          }
+          if (sequence >= totalPackets) {
+            throw new RangeError(`Frame ${frameId}: sequence ${sequence} >= totalPackets ${totalPackets}`);
+          }
+          const headerSize = sequence === 0 ? protocol_1.FIRST_HEADER_SIZE : protocol_1.GENERAL_HEADER_SIZE;
+          if (packet.byteLength < headerSize) {
+            throw new RangeError(`Frame ${frameId}: packet too short for header: ${packet.byteLength} < ${headerSize}`);
+          }
+          const normalCapacity = this.maxPacketSize - protocol_1.GENERAL_HEADER_SIZE;
+          if (normalCapacity <= 0) {
+            throw new RangeError("maxPacketSize too small for frame header");
+          }
+          const worstCaseCapacity = totalPackets * normalCapacity - protocol_1.FIRST_PACKET_EXTRA;
+          if (worstCaseCapacity <= 0) {
+            throw new RangeError(`Frame ${frameId}: computed capacity ${worstCaseCapacity} is non-positive`);
+          }
+          if (worstCaseCapacity > this.maxFrameSize) {
+            throw new RangeError(`Frame ${frameId}: computed capacity ${worstCaseCapacity} exceeds maxFrameSize ${this.maxFrameSize}`);
+          }
+          if (sequence !== 0 && sequence < totalPackets - 1) {
+            const expectedPayload = normalCapacity;
+            const actualPayload = packet.byteLength - headerSize;
+            if (actualPayload !== expectedPayload) {
+              throw new RangeError(`Frame ${frameId}: non-final fragment seq ${sequence} has ${actualPayload} payload bytes, expected ${expectedPayload}`);
+            }
+          }
+          if (sequence === 0 && totalPackets > 1) {
+            const firstCapacity = this.maxPacketSize - protocol_1.FIRST_HEADER_SIZE;
+            const actualPayload = packet.byteLength - headerSize;
+            if (actualPayload !== firstCapacity) {
+              throw new RangeError(`Frame ${frameId}: non-final first packet has ${actualPayload} payload bytes, expected ${firstCapacity}`);
+            }
+          }
+          let parsedFrameType;
+          let parsedTimestampHi = 0;
+          let parsedTimestampLo = 0;
+          if (sequence === 0) {
+            const meta = (0, protocol_1.parseFirstPacketMeta)(packet);
+            if (meta.frameType !== contracts_1.FrameType.Delta && meta.frameType !== contracts_1.FrameType.Key) {
+              throw new RangeError(`Frame ${frameId}: invalid frameType ${meta.frameType}`);
+            }
+            parsedFrameType = meta.frameType;
+            parsedTimestampHi = meta.timestampHi;
+            parsedTimestampLo = meta.timestampLo;
+          }
+          const payload = packet.subarray(headerSize);
+          const destinationOffset = sequence === 0 ? 0 : sequence * normalCapacity - protocol_1.FIRST_PACKET_EXTRA;
+          if (destinationOffset < 0) {
+            throw new RangeError(`Frame ${frameId}: negative destination offset for sequence ${sequence}`);
+          }
+          const destinationEnd = destinationOffset + payload.byteLength;
+          if (destinationEnd > worstCaseCapacity) {
+            throw new RangeError(`Frame ${frameId}: payload exceeds allocation at sequence ${sequence}`);
+          }
+          let frame = this.assembling.get(frameId);
+          if (frame === void 0) {
+            const wouldCompleteOldest = totalPackets === 1 && this.assembling.size === 0;
+            if (wouldCompleteOldest && this.completed.length >= this.maxCompleted) {
+              throw new Error("Frame collector: completed queue full");
+            }
+            if (this.assembling.size >= this.maxAssembling) {
+              throw new Error("Frame collector: assembling capacity exceeded");
+            }
+            frame = {
+              buffer: new Uint8Array(worstCaseCapacity),
+              frameId,
+              totalPackets,
+              received: Array.from({ length: totalPackets }).fill(false),
+              receivedCount: 0,
+              usedLength: 0,
+              frameType: contracts_1.FrameType.Delta,
+              timestampHi: 0,
+              timestampLo: 0,
+              hasFirstPacket: false,
+              ready: false
+            };
+            this.assembling.set(frameId, frame);
+          }
+          if (frame.totalPackets !== totalPackets) {
+            throw new Error(`Frame ${frameId}: conflicting totalPackets: ${frame.totalPackets} vs ${totalPackets}`);
+          }
+          if (frame.received[sequence] === true) {
+            throw new Error(`Frame ${frameId}: duplicate sequence ${sequence}`);
+          }
+          const willComplete = frame.receivedCount + 1 === frame.totalPackets;
+          if (willComplete && this.isOldestAssembling(frame) && this.completed.length >= this.maxCompleted) {
+            throw new Error("Frame collector: completed queue full");
+          }
+          if (sequence === 0) {
+            if (frame.hasFirstPacket) {
+              throw new Error(`Frame ${frameId}: duplicate first packet`);
+            }
+            if (parsedFrameType === void 0) {
+              throw new Error(`Frame ${frameId}: missing parsed first-packet metadata`);
+            }
+            frame.frameType = parsedFrameType;
+            frame.timestampHi = parsedTimestampHi;
+            frame.timestampLo = parsedTimestampLo;
+            frame.hasFirstPacket = true;
+          }
+          frame.buffer.set(payload, destinationOffset);
+          frame.usedLength = Math.max(frame.usedLength, destinationEnd);
+          frame.received[sequence] = true;
+          frame.receivedCount += 1;
+          if (frame.receivedCount !== frame.totalPackets) {
+            return;
+          }
+          for (let s = 0; s < frame.totalPackets; s += 1) {
+            if (frame.received[s] !== true) {
+              throw new Error(`Frame ${frameId}: missing sequence ${s} at completion`);
+            }
+          }
+          if (!frame.hasFirstPacket) {
+            throw new Error(`Frame ${frameId}: completed without first-packet metadata`);
+          }
+          frame.ready = true;
+          this.promoteReadyFrames();
+        }
+        isOldestAssembling(target) {
+          for (const frame of this.assembling.values()) {
+            return frame === target;
+          }
+          return false;
+        }
+        promoteReadyFrames() {
+          while (this.completed.length < this.maxCompleted) {
+            let oldest;
+            for (const frame of this.assembling.values()) {
+              oldest = frame;
+              break;
+            }
+            if (oldest === void 0 || !oldest.ready) {
+              return;
+            }
+            const removed = this.assembling.delete(oldest.frameId);
+            if (!removed) {
+              throw new Error(`Frame ${oldest.frameId}: failed to remove ready frame`);
+            }
+            const trimmed = oldest.buffer.subarray(0, oldest.usedLength);
+            const timestamp = { hi: oldest.timestampHi, lo: oldest.timestampLo };
+            const reference = this.registry.register(trimmed, oldest.frameType, timestamp);
+            this.completed.push({
+              reference,
+              frameId: oldest.frameId,
+              frameType: oldest.frameType,
+              timestamp
+            });
+          }
+        }
+        /**
+         * Mark input complete, abandon incomplete frames, and expose every complete
+         * frame that remains in first-seen order. Completed references stay owned by
+         * the collector until taken or destroyed.
+         */
+        finish() {
+          for (const [frameId, frame] of this.assembling) {
+            if (!frame.ready) {
+              this.assembling.delete(frameId);
+            }
+          }
+          this.promoteReadyFrames();
+        }
+        /** Release all assembling frames and clear completed queue, releasing refs. */
+        destroy() {
+          for (const frame of this.completed) {
+            this.registry.release(frame.reference);
+          }
+          this.assembling.clear();
+          this.completed.length = 0;
+        }
+      };
+      exports.FrameCollector = FrameCollector;
+    }
+  });
+
+  // node_modules/@signageos/brightsign-decoder/dist/frame/FrameReferenceRegistry.js
+  var require_FrameReferenceRegistry = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/frame/FrameReferenceRegistry.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.FrameReferenceRegistry = void 0;
+      var RefState;
+      (function(RefState2) {
+        RefState2[RefState2["Available"] = 0] = "Available";
+        RefState2[RefState2["Claimed"] = 1] = "Claimed";
+        RefState2[RefState2["Released"] = 2] = "Released";
+      })(RefState || (RefState = {}));
+      var refMeta = /* @__PURE__ */ new WeakMap();
+      function createOpaqueRef(id, generation, owner) {
+        const ref = Object.freeze({ __frameRef: true });
+        refMeta.set(ref, { id, generation, owner });
+        return ref;
+      }
+      function readRef(reference) {
+        const meta = refMeta.get(reference);
+        if (meta === void 0) {
+          throw new TypeError("Invalid frame reference");
+        }
+        return meta;
+      }
+      var FrameReferenceRegistry2 = class {
+        constructor() {
+          this.entries = /* @__PURE__ */ new Map();
+          this.nextId = 0;
+          this.generation = 0;
+        }
+        /** Register a completed frame buffer and return an opaque reference. */
+        register(data, frameType, timestamp) {
+          const id = this.nextId;
+          this.nextId += 1;
+          this.entries.set(id, {
+            state: RefState.Available,
+            claimant: void 0,
+            generation: this.generation,
+            data,
+            frameType,
+            timestamp
+          });
+          return createOpaqueRef(id, this.generation, this);
+        }
+        /**
+         * Atomically claim a reference. Returns the underlying frame data.
+         * Throws on stale generation, double claim, or released reference.
+         */
+        claim(reference) {
+          const meta = readRef(reference);
+          return meta.owner.claimOwned(meta, this);
+        }
+        claimOwned(meta, claimant) {
+          const entry = this.entries.get(meta.id);
+          if (entry === void 0) {
+            throw new Error(`Frame reference ${meta.id} does not exist`);
+          }
+          if (entry.generation !== meta.generation) {
+            throw new Error(`Stale generation: expected ${entry.generation}, got ${meta.generation}`);
+          }
+          if (entry.state === RefState.Claimed) {
+            throw new Error(`Frame reference ${meta.id} is already claimed`);
+          }
+          if (entry.state === RefState.Released) {
+            throw new Error(`Frame reference ${meta.id} is already released`);
+          }
+          entry.state = RefState.Claimed;
+          entry.claimant = claimant;
+          return {
+            data: entry.data,
+            frameType: entry.frameType,
+            timestamp: entry.timestamp
+          };
+        }
+        /** Restore this registry's claim after downstream admission rejected ownership. */
+        restoreClaim(reference) {
+          const meta = refMeta.get(reference);
+          if (meta === void 0) {
+            return;
+          }
+          meta.owner.restoreOwnedClaim(meta, this);
+        }
+        restoreOwnedClaim(meta, claimant) {
+          const entry = this.entries.get(meta.id);
+          if (entry === void 0 || entry.generation !== meta.generation || entry.state !== RefState.Claimed || entry.claimant !== claimant) {
+            return;
+          }
+          entry.state = RefState.Available;
+          entry.claimant = void 0;
+        }
+        /**
+         * Release a reference. Only claimed or available (explicit TCP close) refs
+         * can be released. Stale generation is a no-op during teardown.
+         */
+        release(reference) {
+          const meta = refMeta.get(reference);
+          if (meta === void 0) {
+            return;
+          }
+          meta.owner.releaseOwned(meta, this);
+        }
+        releaseOwned(meta, releaser) {
+          const entry = this.entries.get(meta.id);
+          if (entry === void 0 || entry.generation !== meta.generation || entry.state === RefState.Released) {
+            return;
+          }
+          if (entry.state === RefState.Available && releaser !== this) {
+            return;
+          }
+          if (entry.state === RefState.Claimed && entry.claimant !== releaser) {
+            return;
+          }
+          entry.state = RefState.Released;
+          entry.claimant = void 0;
+          this.entries.delete(meta.id);
+        }
+        /** Number of currently tracked references. */
+        get size() {
+          return this.entries.size;
+        }
+        /** Increment generation and release all entries. */
+        destroy() {
+          this.generation += 1;
+          this.entries.clear();
+          this.nextId = 0;
+        }
+      };
+      exports.FrameReferenceRegistry = FrameReferenceRegistry2;
+    }
+  });
+
+  // node_modules/@signageos/brightsign-decoder/dist/tcp/ConnectionRegistry.js
+  var require_ConnectionRegistry = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/tcp/ConnectionRegistry.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.ConnectionRegistry = void 0;
+      var ConnectionRegistry = class {
+        constructor() {
+          this.slots = /* @__PURE__ */ new Map();
+          this.freeSlots = [];
+          this.nextSlot = 0;
+        }
+        /** Allocate a new connection slot and return its handle. */
+        allocate() {
+          const reusable = this.freeSlots.pop();
+          if (reusable !== void 0) {
+            const entry = this.slots.get(reusable);
+            if (entry === void 0 || entry.active) {
+              throw new Error("Connection registry free-list corruption");
+            }
+            entry.active = true;
+            return { slot: reusable, generation: entry.generation };
+          }
+          const slot = this.nextSlot;
+          this.nextSlot += 1;
+          this.slots.set(slot, { generation: 0, active: true });
+          return { slot, generation: 0 };
+        }
+        /** Check whether a handle is still valid (same generation, active). */
+        isValid(handle) {
+          const entry = this.slots.get(handle.slot);
+          if (entry === void 0) {
+            return false;
+          }
+          return entry.active && entry.generation === handle.generation;
+        }
+        /**
+         * Close a connection slot.
+         * Increments generation before releasing so delayed callbacks on the old
+         * generation see an invalid handle.
+         */
+        close(handle) {
+          const entry = this.slots.get(handle.slot);
+          if (entry === void 0) {
+            return;
+          }
+          if (entry.generation !== handle.generation) {
+            return;
+          }
+          entry.generation += 1;
+          entry.active = false;
+          this.freeSlots.push(handle.slot);
+        }
+        /** Number of currently active connections. */
+        get activeCount() {
+          let count = 0;
+          for (const entry of this.slots.values()) {
+            if (entry.active) {
+              count += 1;
+            }
+          }
+          return count;
+        }
+        /** Close all active connections. */
+        destroy() {
+          for (const [slot, entry] of this.slots) {
+            if (entry.active) {
+              entry.generation += 1;
+              entry.active = false;
+              this.freeSlots.push(slot);
+            }
+          }
+        }
+      };
+      exports.ConnectionRegistry = ConnectionRegistry;
+    }
+  });
+
+  // node_modules/@signageos/brightsign-decoder/dist/tcp/TCP.js
+  var require_TCP = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/tcp/TCP.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.TCP = void 0;
+      exports.narrowSocketLike = narrowSocketLike;
+      var contracts_1 = require_contracts();
+      var FrameCollector_1 = require_FrameCollector();
+      var FrameReferenceRegistry_1 = require_FrameReferenceRegistry();
+      var ConnectionRegistry_1 = require_ConnectionRegistry();
+      var PacketParser_1 = require_PacketParser();
+      var DEFAULT_MAX_PACKET_SIZE = 32 * 1024;
+      var DEFAULT_MAX_QUEUED_BYTES = 1024 * 1024;
+      var DEFAULT_MAX_QUEUED_PACKETS = 64;
+      var ManagedConnection = class {
+        constructor(net, registry, handle, maxQueuedPackets, inputMode, maxPacketSize, maxQueuedBytes, referenceRegistry2, unregister) {
+          this.net = net;
+          this.registry = registry;
+          this.handle = handle;
+          this.maxQueuedPackets = maxQueuedPackets;
+          this.inputMode = inputMode;
+          this.maxQueuedBytes = maxQueuedBytes;
+          this.unregister = unregister;
+          this.pendingPackets = [];
+          this.pendingRawBytes = 0;
+          this.byteWaiters = [];
+          this.frameWaiters = [];
+          this.pendingWrites = [];
+          this.paused = false;
+          this.closed = false;
+          this.cleanEof = false;
+          this.collectorFinished = false;
+          this.resourcesReleased = false;
+          this.stateValue = contracts_1.ConnectionState.Connecting;
+          this.parser = new PacketParser_1.PacketParser({ maxPacketSize, maxQueuedBytes });
+          this.collector = new FrameCollector_1.FrameCollector(referenceRegistry2, { maxPacketSize });
+        }
+        get state() {
+          return this.stateValue;
+        }
+        async connect(options) {
+          await new Promise((resolve, reject) => {
+            this.connectResolve = resolve;
+            this.connectReject = reject;
+            let connectedSynchronously = false;
+            try {
+              const created = this.net.createConnection({ host: options.host, port: options.port }, () => {
+                if (this.socket === void 0) {
+                  connectedSynchronously = true;
+                  return;
+                }
+                this.markConnected();
+              });
+              this.socket = created;
+              this.installSocketListeners(created);
+              if (connectedSynchronously) {
+                this.markConnected();
+              }
+            } catch (error) {
+              this.fail(toError(error, "TCP connection creation failed"));
+            }
+          });
+        }
+        readBytes(signal) {
+          var _a;
+          this.selectMode("raw");
+          const queued = this.pendingPackets.shift();
+          if (queued !== void 0) {
+            this.pendingRawBytes -= this.inputMode === "raw" ? queued.byteLength : 0;
+            this.updateBackpressure();
+            this.finalizeCleanEofIfDrained();
+            return Promise.resolve(queued);
+          }
+          if (this.closed) {
+            this.finalizeCleanEofIfDrained();
+            return Promise.reject((_a = this.closeError) != null ? _a : new Error("TCP connection is closed"));
+          }
+          return new Promise((resolve, reject) => {
+            if ((signal == null ? void 0 : signal.aborted) === true) {
+              reject(abortError());
+              return;
+            }
+            let waiter;
+            const abort = signal === void 0 ? void 0 : () => {
+              this.removeByteWaiter(waiter);
+              this.settleByteWaiter(waiter, void 0, abortError());
+            };
+            waiter = { resolve, reject, signal, abort, settled: false };
+            this.byteWaiters.push(waiter);
+            if (signal !== void 0 && abort !== void 0) {
+              signal.addEventListener("abort", abort, { once: true });
+            }
+          });
+        }
+        readReference(signal) {
+          return this.readFrame(signal).then((frame) => frame.reference);
+        }
+        readFrame(signal) {
+          var _a;
+          this.selectMode("frames");
+          const pumpError = this.pumpFrameDataSafely();
+          if (pumpError !== void 0) {
+            return Promise.reject(pumpError);
+          }
+          const completed = this.collector.take();
+          if (completed !== void 0) {
+            this.pumpFrameDataSafely();
+            this.updateBackpressure();
+            this.finalizeCleanEofIfDrained();
+            return Promise.resolve(completed);
+          }
+          if (this.closed) {
+            this.finalizeCleanEofIfDrained();
+            return Promise.reject((_a = this.closeError) != null ? _a : new Error("TCP connection is closed"));
+          }
+          return new Promise((resolve, reject) => {
+            if ((signal == null ? void 0 : signal.aborted) === true) {
+              reject(abortError());
+              return;
+            }
+            let waiter;
+            const abort = signal === void 0 ? void 0 : () => {
+              this.removeFrameWaiter(waiter);
+              this.settleFrameWaiter(waiter, void 0, abortError());
+            };
+            waiter = { resolve, reject, signal, abort, settled: false };
+            this.frameWaiters.push(waiter);
+            if (signal !== void 0 && abort !== void 0) {
+              signal.addEventListener("abort", abort, { once: true });
+            }
+            this.pumpFrameDataSafely();
+          });
+        }
+        write(data) {
+          var _a;
+          if (this.closed || this.stateValue !== contracts_1.ConnectionState.Connected) {
+            return Promise.reject((_a = this.closeError) != null ? _a : new Error("TCP connection is not connected"));
+          }
+          let owned;
+          try {
+            owned = narrowBytes(data);
+          } catch (error) {
+            return Promise.reject(toError(error, "TCP write data must be bytes"));
+          }
+          return new Promise((resolve, reject) => {
+            this.pendingWrites.push({ data: owned, resolve, reject, settled: false });
+            this.startNextWrite();
+          });
+        }
+        close(reason) {
+          if (this.closed && !this.cleanEof) {
+            return;
+          }
+          this.closed = true;
+          this.cleanEof = false;
+          this.closeError = reason != null ? reason : new Error("TCP connection is closed");
+          this.stateValue = reason === void 0 ? contracts_1.ConnectionState.Closed : contracts_1.ConnectionState.Error;
+          this.registry.close(this.handle);
+          this.pendingPackets.length = 0;
+          this.pendingRawBytes = 0;
+          this.parser.reset();
+          for (const waiter of this.byteWaiters.splice(0)) {
+            this.settleByteWaiter(waiter, void 0, this.closeError);
+          }
+          for (const waiter of this.frameWaiters.splice(0)) {
+            this.settleFrameWaiter(waiter, void 0, this.closeError);
+          }
+          this.rejectWrites(this.closeError);
+          const rejectConnect = this.connectReject;
+          this.connectResolve = void 0;
+          this.connectReject = void 0;
+          if (rejectConnect !== void 0) {
+            rejectConnect(this.closeError);
+          }
+          const socket = this.socket;
+          if (socket !== void 0) {
+            socket.removeAllListeners();
+            if (!socket.destroyed) {
+              socket.destroy();
+            }
+          }
+          this.releaseResources();
+        }
+        installSocketListeners(socket) {
+          socket.on("data", (value) => {
+            if (!this.registry.isValid(this.handle) || this.closed) {
+              return;
+            }
+            try {
+              const bytes = narrowBytes(value);
+              if (this.inputMode === "raw") {
+                this.pendingPackets.push(bytes);
+                this.pendingRawBytes += bytes.byteLength;
+              } else {
+                const packets = this.parser.push(bytes);
+                this.pendingPackets.push(...packets);
+              }
+              this.deliverPending();
+              if (this.pendingRawBytes > this.maxQueuedBytes) {
+                throw new Error("TCP raw byte queue capacity exceeded");
+              }
+              if (this.pendingPackets.length > this.maxQueuedPackets) {
+                throw new Error("TCP packet queue capacity exceeded");
+              }
+            } catch (error) {
+              this.fail(toError(error, "TCP packet processing failed"));
+            }
+          });
+          socket.on("error", (error) => {
+            if (this.registry.isValid(this.handle)) {
+              this.fail(toError(error, "TCP socket error"));
+            }
+          });
+          socket.on("close", () => {
+            if (!this.registry.isValid(this.handle)) {
+              return;
+            }
+            try {
+              if (this.inputMode === "framed") {
+                this.parser.finish();
+              }
+              this.handleCleanEof();
+            } catch (error) {
+              this.fail(toError(error, "TCP socket closed with an incomplete packet"));
+            }
+          });
+        }
+        markConnected() {
+          if (this.closed || this.stateValue !== contracts_1.ConnectionState.Connecting) {
+            return;
+          }
+          this.stateValue = contracts_1.ConnectionState.Connected;
+          const resolveConnect = this.connectResolve;
+          this.connectResolve = void 0;
+          this.connectReject = void 0;
+          resolveConnect == null ? void 0 : resolveConnect();
+        }
+        fail(error) {
+          this.close(error);
+        }
+        selectMode(mode) {
+          if (mode === "frames" && this.inputMode === "raw") {
+            throw new Error("Raw TCP streams do not support frame collection");
+          }
+          if (this.mode !== void 0 && this.mode !== mode) {
+            throw new Error("TCP stream cannot mix raw packet reads and frame-reference reads");
+          }
+          if (this.mode === void 0) {
+            this.mode = mode;
+          }
+        }
+        deliverPending() {
+          if (this.mode === "raw") {
+            while (this.pendingPackets.length > 0 && this.byteWaiters.length > 0) {
+              const packet = this.pendingPackets.shift();
+              const waiter = this.byteWaiters.shift();
+              if (packet !== void 0 && waiter !== void 0) {
+                this.pendingRawBytes -= this.inputMode === "raw" ? packet.byteLength : 0;
+                this.settleByteWaiter(waiter, packet, void 0);
+              }
+            }
+            if (this.cleanEof && this.pendingPackets.length === 0) {
+              this.rejectByteWaitersAtEof();
+            }
+          } else if (this.mode === "frames") {
+            this.pumpFrameData();
+          }
+          this.updateBackpressure();
+          this.finalizeCleanEofIfDrained();
+        }
+        drainFramePackets() {
+          while (this.pendingPackets.length > 0 && !this.collector.isCompletedFull) {
+            const packet = this.pendingPackets[0];
+            if (packet === void 0) {
+              break;
+            }
+            this.collector.accept(packet);
+            this.pendingPackets.shift();
+          }
+        }
+        deliverFrames() {
+          while (this.frameWaiters.length > 0) {
+            const completed = this.collector.take();
+            if (completed === void 0) {
+              return;
+            }
+            const waiter = this.frameWaiters.shift();
+            if (waiter !== void 0) {
+              this.settleFrameWaiter(waiter, completed, void 0);
+            }
+          }
+        }
+        pumpFrameData() {
+          let progressed = true;
+          while (progressed) {
+            const packetCount = this.pendingPackets.length;
+            const completedCount = this.collector.completedCount;
+            const waiterCount = this.frameWaiters.length;
+            this.drainFramePackets();
+            if (this.cleanEof && this.pendingPackets.length === 0 && !this.collectorFinished) {
+              this.collector.finish();
+              this.collectorFinished = true;
+            }
+            this.deliverFrames();
+            progressed = packetCount !== this.pendingPackets.length || completedCount !== this.collector.completedCount || waiterCount !== this.frameWaiters.length;
+          }
+          if (this.cleanEof && this.pendingPackets.length === 0 && this.collector.completedCount === 0) {
+            this.rejectFrameWaitersAtEof();
+          }
+        }
+        pumpFrameDataSafely() {
+          try {
+            this.pumpFrameData();
+            return void 0;
+          } catch (error) {
+            const failure = toError(error, "TCP frame processing failed");
+            this.fail(failure);
+            return failure;
+          }
+        }
+        handleCleanEof() {
+          this.closed = true;
+          this.cleanEof = true;
+          this.closeError = new Error("TCP connection reached end of stream");
+          this.stateValue = contracts_1.ConnectionState.Closed;
+          this.registry.close(this.handle);
+          const socket = this.socket;
+          if (socket !== void 0) {
+            socket.removeAllListeners();
+          }
+          const rejectConnect = this.connectReject;
+          this.connectResolve = void 0;
+          this.connectReject = void 0;
+          if (rejectConnect !== void 0) {
+            rejectConnect(this.closeError);
+          }
+          this.rejectWrites(this.closeError);
+          this.deliverPending();
+        }
+        rejectByteWaitersAtEof() {
+          var _a;
+          const error = (_a = this.closeError) != null ? _a : new Error("TCP connection reached end of stream");
+          for (const waiter of this.byteWaiters.splice(0)) {
+            this.settleByteWaiter(waiter, void 0, error);
+          }
+        }
+        rejectFrameWaitersAtEof() {
+          var _a;
+          const error = (_a = this.closeError) != null ? _a : new Error("TCP connection reached end of stream");
+          for (const waiter of this.frameWaiters.splice(0)) {
+            this.settleFrameWaiter(waiter, void 0, error);
+          }
+        }
+        finalizeCleanEofIfDrained() {
+          if (!this.cleanEof) {
+            return;
+          }
+          const rawDrained = this.mode !== "frames" && this.pendingPackets.length === 0;
+          const framesDrained = this.mode === "frames" && this.pendingPackets.length === 0 && this.collectorFinished && this.collector.completedCount === 0;
+          if (rawDrained || framesDrained) {
+            this.releaseResources();
+          }
+        }
+        releaseResources() {
+          if (this.resourcesReleased) {
+            return;
+          }
+          this.resourcesReleased = true;
+          this.parser.destroy();
+          this.collector.destroy();
+          this.unregister(this);
+        }
+        startNextWrite() {
+          if (this.activeWrite !== void 0 || this.closed) {
+            return;
+          }
+          const operation = this.pendingWrites.shift();
+          if (operation === void 0) {
+            return;
+          }
+          const socket = this.socket;
+          if (socket === void 0) {
+            this.rejectWrite(operation, new Error("TCP socket is unavailable"));
+            this.startNextWrite();
+            return;
+          }
+          this.activeWrite = operation;
+          try {
+            socket.write(operation.data, (error) => {
+              if (this.activeWrite !== operation || operation.settled) {
+                return;
+              }
+              if (error !== void 0 && error !== null) {
+                this.fail(toError(error, "TCP socket write failed"));
+                return;
+              }
+              operation.settled = true;
+              this.activeWrite = void 0;
+              operation.resolve();
+              this.startNextWrite();
+            });
+          } catch (error) {
+            this.fail(toError(error, "TCP socket write failed"));
+          }
+        }
+        rejectWrites(error) {
+          const active = this.activeWrite;
+          this.activeWrite = void 0;
+          if (active !== void 0) {
+            this.rejectWrite(active, error);
+          }
+          for (const operation of this.pendingWrites.splice(0)) {
+            this.rejectWrite(operation, error);
+          }
+        }
+        rejectWrite(operation, error) {
+          if (operation.settled) {
+            return;
+          }
+          operation.settled = true;
+          operation.reject(error);
+        }
+        updateBackpressure() {
+          const socket = this.socket;
+          if (socket === void 0 || this.closed) {
+            return;
+          }
+          const shouldPause = this.pendingPackets.length >= this.maxQueuedPackets || this.pendingRawBytes >= this.maxQueuedBytes || this.mode === "frames" && this.collector.isCompletedFull;
+          if (shouldPause && !this.paused) {
+            socket.pause();
+            this.paused = true;
+          } else if (!shouldPause && this.paused) {
+            socket.resume();
+            this.paused = false;
+          }
+        }
+        removeByteWaiter(waiter) {
+          const index = this.byteWaiters.indexOf(waiter);
+          if (index >= 0) {
+            this.byteWaiters.splice(index, 1);
+          }
+        }
+        removeFrameWaiter(waiter) {
+          const index = this.frameWaiters.indexOf(waiter);
+          if (index >= 0) {
+            this.frameWaiters.splice(index, 1);
+          }
+        }
+        settleByteWaiter(waiter, value, error) {
+          if (waiter.settled) {
+            return;
+          }
+          waiter.settled = true;
+          if (waiter.signal !== void 0 && waiter.abort !== void 0) {
+            waiter.signal.removeEventListener("abort", waiter.abort);
+          }
+          if (error !== void 0) {
+            waiter.reject(error);
+          } else if (value !== void 0) {
+            waiter.resolve(value);
+          }
+        }
+        settleFrameWaiter(waiter, value, error) {
+          if (waiter.settled) {
+            return;
+          }
+          waiter.settled = true;
+          if (waiter.signal !== void 0 && waiter.abort !== void 0) {
+            waiter.signal.removeEventListener("abort", waiter.abort);
+          }
+          if (error !== void 0) {
+            waiter.reject(error);
+          } else if (value !== void 0) {
+            waiter.resolve(value);
+          }
+        }
+      };
+      var TCP = class {
+        constructor(options) {
+          var _a, _b, _c, _d;
+          this.options = options;
+          this.registry = new ConnectionRegistry_1.ConnectionRegistry();
+          this.connections = /* @__PURE__ */ new Set();
+          this.destroyed = false;
+          this.maxPacketSize = (_a = options.maxPacketSize) != null ? _a : DEFAULT_MAX_PACKET_SIZE;
+          this.maxQueuedBytes = (_b = options.maxQueuedBytes) != null ? _b : DEFAULT_MAX_QUEUED_BYTES;
+          this.maxQueuedPackets = (_c = options.maxQueuedPackets) != null ? _c : DEFAULT_MAX_QUEUED_PACKETS;
+          this.referenceRegistry = (_d = options.referenceRegistry) != null ? _d : new FrameReferenceRegistry_1.FrameReferenceRegistry();
+          if (!Number.isSafeInteger(this.maxQueuedPackets) || this.maxQueuedPackets <= 0) {
+            throw new RangeError("maxQueuedPackets must be a positive integer");
+          }
+        }
+        async createPacket(options) {
+          const connection = await this.createConnection(options, "framed");
+          return {
+            read(signal) {
+              return connection.readBytes(signal);
+            },
+            write(data) {
+              const body = narrowBytes(data);
+              if (body.byteLength > 65535) {
+                return Promise.reject(new RangeError("TCP packet body exceeds the u16 length limit"));
+              }
+              const packet = new Uint8Array(body.byteLength + 2);
+              packet[0] = body.byteLength >>> 8;
+              packet[1] = body.byteLength & 255;
+              packet.set(body, 2);
+              return connection.write(packet);
+            },
+            readFrame(signal) {
+              return connection.readFrame(signal);
+            },
+            readFrameRef(signal) {
+              return connection.readReference(signal);
+            },
+            close() {
+              connection.close();
+            },
+            get state() {
+              return connection.state;
+            }
+          };
+        }
+        async createStream(options) {
+          const connection = await this.createConnection(options, "framed");
+          return {
+            read(signal) {
+              return connection.readBytes(signal);
+            },
+            write(data) {
+              return connection.write(data);
+            },
+            readFrame(signal) {
+              return connection.readFrame(signal);
+            },
+            readFrameRef(signal) {
+              return connection.readReference(signal);
+            },
+            close() {
+              connection.close();
+            },
+            get state() {
+              return connection.state;
+            }
+          };
+        }
+        async createRawStream(options) {
+          const connection = await this.createConnection(options, "raw");
+          return {
+            read(signal) {
+              return connection.readBytes(signal);
+            },
+            write(data) {
+              return connection.write(data);
+            },
+            close() {
+              connection.close();
+            },
+            get state() {
+              return connection.state;
+            }
+          };
+        }
+        async destroy() {
+          if (this.destroyed) {
+            return;
+          }
+          this.destroyed = true;
+          for (const connection of Array.from(this.connections)) {
+            connection.close();
+          }
+          this.registry.destroy();
+        }
+        async createConnection(options, inputMode) {
+          if (this.destroyed) {
+            throw new Error("TCP communication is destroyed");
+          }
+          if (options.secure === true) {
+            throw new Error("secure: true is not supported until a tested TLS contract exists");
+          }
+          if (!Number.isSafeInteger(options.port) || options.port <= 0 || options.port > 65535) {
+            throw new RangeError("TCP port must be an integer in 1..65535");
+          }
+          if (options.host.length === 0) {
+            throw new RangeError("TCP host must not be empty");
+          }
+          const connection = new ManagedConnection(this.options.net, this.registry, this.registry.allocate(), this.maxQueuedPackets, inputMode, this.maxPacketSize, this.maxQueuedBytes, this.referenceRegistry, (value) => this.connections.delete(value));
+          this.connections.add(connection);
+          try {
+            await connection.connect(options);
+            return connection;
+          } catch (error) {
+            connection.close(toError(error, "TCP connection failed"));
+            throw error;
+          }
+        }
+      };
+      exports.TCP = TCP;
+      function narrowSocketLike(value) {
+        if (typeof value !== "object" || value === null) {
+          throw new TypeError("Expected a socket object");
+        }
+        const on = Reflect.get(value, "on");
+        const removeAllListeners = Reflect.get(value, "removeAllListeners");
+        const write = Reflect.get(value, "write");
+        const pause = Reflect.get(value, "pause");
+        const resume = Reflect.get(value, "resume");
+        const destroy = Reflect.get(value, "destroy");
+        if (typeof on !== "function" || typeof removeAllListeners !== "function" || typeof write !== "function" || typeof pause !== "function" || typeof resume !== "function" || typeof destroy !== "function") {
+          throw new TypeError("Object does not satisfy the socket contract");
+        }
+        return {
+          on(event, listener) {
+            Reflect.apply(on, value, [event, listener]);
+          },
+          removeAllListeners(event) {
+            Reflect.apply(removeAllListeners, value, event === void 0 ? [] : [event]);
+          },
+          write(data, callback) {
+            const args = callback === void 0 ? [data] : [data, callback];
+            return Reflect.apply(write, value, args) !== false;
+          },
+          pause() {
+            Reflect.apply(pause, value, []);
+          },
+          resume() {
+            Reflect.apply(resume, value, []);
+          },
+          destroy() {
+            Reflect.apply(destroy, value, []);
+          },
+          get destroyed() {
+            return Reflect.get(value, "destroyed") === true;
+          }
+        };
+      }
+      function narrowBytes(value) {
+        if (!ArrayBuffer.isView(value) || Reflect.get(value, "BYTES_PER_ELEMENT") !== 1) {
+          throw new TypeError("TCP data event did not contain a one-byte element view");
+        }
+        const byteLength = Reflect.get(value, "byteLength");
+        if (typeof byteLength !== "number" || !Number.isSafeInteger(byteLength) || byteLength < 0) {
+          throw new TypeError("TCP data event contained an invalid byte length");
+        }
+        const normalized = new Uint8Array(byteLength);
+        Reflect.apply(Uint8Array.prototype.set, normalized, [value]);
+        return normalized;
+      }
+      function toError(value, fallback) {
+        return value instanceof Error ? value : new Error(fallback);
+      }
+      function abortError() {
+        const error = new Error("Operation aborted");
+        error.name = "AbortError";
+        return error;
+      }
+    }
+  });
+
+  // node_modules/@signageos/brightsign-decoder/dist/remux/AnnexB.js
+  var require_AnnexB = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/remux/AnnexB.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.NalType = void 0;
+      exports.findStartCodes = findStartCodes;
+      exports.startCodeLength = startCodeLength;
+      exports.getNalType = getNalType;
+      exports.parseNalUnits = parseNalUnits;
+      exports.inspectAccessUnit = inspectAccessUnit;
+      var NalType;
+      (function(NalType2) {
+        NalType2[NalType2["NonIDRSlice"] = 1] = "NonIDRSlice";
+        NalType2[NalType2["IDRSlice"] = 5] = "IDRSlice";
+        NalType2[NalType2["SEI"] = 6] = "SEI";
+        NalType2[NalType2["SPS"] = 7] = "SPS";
+        NalType2[NalType2["PPS"] = 8] = "PPS";
+        NalType2[NalType2["AUD"] = 9] = "AUD";
+      })(NalType || (exports.NalType = NalType = {}));
+      function findStartCodes(data) {
+        const positions = [];
+        let index = 0;
+        while (index + 2 < data.byteLength) {
+          const b0 = data[index];
+          const b1 = data[index + 1];
+          const b2 = data[index + 2];
+          if (b0 === void 0 || b1 === void 0 || b2 === void 0) {
+            break;
+          }
+          if (b0 === 0 && b1 === 0) {
+            if (b2 === 1) {
+              positions.push(index);
+              index += 3;
+              continue;
+            }
+            const b3 = data[index + 3];
+            if (b2 === 0 && b3 === 1) {
+              positions.push(index);
+              index += 4;
+              continue;
+            }
+          }
+          index += 1;
+        }
+        return positions;
+      }
+      function startCodeLength(data, position) {
+        const b2 = data[position + 2];
+        if (b2 === 1) {
+          return 3;
+        }
+        return 4;
+      }
+      function getNalType(data, startCodePosition) {
+        const prefixLen = startCodeLength(data, startCodePosition);
+        const nalByte = data[startCodePosition + prefixLen];
+        if (nalByte === void 0) {
+          throw new RangeError("NAL unit header byte is missing");
+        }
+        return nalByte & 31;
+      }
+      function parseNalUnits(data) {
+        if (data.byteLength === 0) {
+          throw new RangeError("Annex-B access unit is empty");
+        }
+        const positions = findStartCodes(data);
+        const firstPosition = positions[0];
+        if (firstPosition === void 0) {
+          throw new RangeError("Annex-B access unit has no start code");
+        }
+        for (let index = 0; index < firstPosition; index += 1) {
+          if (data[index] !== 0) {
+            throw new RangeError("Annex-B access unit has non-zero bytes before its first start code");
+          }
+        }
+        const units = [];
+        for (let i = 0; i < positions.length; i += 1) {
+          const pos = positions[i];
+          if (pos === void 0) {
+            continue;
+          }
+          const nextPos = positions[i + 1];
+          const end = nextPos !== void 0 ? nextPos : data.byteLength;
+          const prefixLength = startCodeLength(data, pos);
+          if (end <= pos + prefixLength) {
+            throw new RangeError("Annex-B access unit contains an empty NAL unit");
+          }
+          const type = getNalType(data, pos);
+          units.push({ type, offset: pos, length: end - pos });
+        }
+        return units;
+      }
+      function inspectAccessUnit(data) {
+        const nalUnits = parseNalUnits(data);
+        let isIDR = false;
+        let hasSPS = false;
+        let hasPPS = false;
+        let spsData;
+        let ppsData;
+        for (const unit of nalUnits) {
+          if (unit.type === NalType.IDRSlice) {
+            isIDR = true;
+          }
+          if (unit.type === NalType.SPS) {
+            hasSPS = true;
+            spsData = data.slice(unit.offset, unit.offset + unit.length);
+          }
+          if (unit.type === NalType.PPS) {
+            hasPPS = true;
+            ppsData = data.slice(unit.offset, unit.offset + unit.length);
+          }
+        }
+        return { isIDR, hasSPS, hasPPS, nalUnits, spsData, ppsData };
+      }
+    }
+  });
+
+  // node_modules/@signageos/brightsign-decoder/dist/remux/TransportClock.js
+  var require_TransportClock = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/remux/TransportClock.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.TransportClock = void 0;
+      exports.u64ToBigInt = u64ToBigInt;
+      exports.u64Sub = u64Sub;
+      var PTS_MASK_N = BigInt("0x1FFFFFFFF");
+      var NINE = BigInt(9);
+      var ONE_HUNDRED_THOUSAND = BigInt(1e5);
+      var ZERO = BigInt(0);
+      function u64ToBigInt(ts) {
+        validateU32(ts.hi, "timestamp.hi");
+        validateU32(ts.lo, "timestamp.lo");
+        return BigInt(ts.hi) << BigInt(32) | BigInt(ts.lo);
+      }
+      var TransportClock = class {
+        constructor(initialPts = 0) {
+          if (!Number.isSafeInteger(initialPts) || initialPts < 0 || initialPts > Number(PTS_MASK_N)) {
+            throw new RangeError("initialPts must be an integer in the 33-bit MPEG timestamp range");
+          }
+          this.initialPts = BigInt(initialPts);
+        }
+        /**
+         * Convert a source timestamp to a 33-bit 90 kHz PTS value.
+         * First call establishes the base and returns the configured initial PTS.
+         * Subsequent calls compute monotonic offsets; regression throws.
+         */
+        toPts(timestamp) {
+          const tsBig = u64ToBigInt(timestamp);
+          if (this.baseTimestamp === void 0) {
+            this.baseTimestamp = tsBig;
+            this.lastInputBig = tsBig;
+            return Number(this.initialPts);
+          }
+          const lastInput = this.lastInputBig;
+          if (lastInput !== void 0 && tsBig < lastInput) {
+            throw new RangeError(`Timestamp regression: ${tsBig} < previous ${lastInput}`);
+          }
+          this.lastInputBig = tsBig;
+          const deltaNs = tsBig - this.baseTimestamp;
+          const ticks = deltaNs * NINE / ONE_HUNDRED_THOUSAND;
+          const pts33 = ticks + this.initialPts & PTS_MASK_N;
+          return Number(pts33);
+        }
+        /** Capture immutable timestamp state for an access-unit transaction. */
+        captureState() {
+          return {
+            baseTimestamp: this.baseTimestamp,
+            lastInput: this.lastInputBig
+          };
+        }
+        /** Restore timestamp state when an access unit was not delivered. */
+        restoreState(state) {
+          this.baseTimestamp = state.baseTimestamp;
+          this.lastInputBig = state.lastInput;
+        }
+        /** Reset clock to uninitialized state. */
+        reset() {
+          this.baseTimestamp = void 0;
+          this.lastInputBig = void 0;
+        }
+      };
+      exports.TransportClock = TransportClock;
+      function validateU32(value, name) {
+        if (!Number.isInteger(value) || !Number.isFinite(value) || value < 0 || value > 4294967295) {
+          throw new RangeError(`${name} must be an unsigned 32-bit integer`);
+        }
+      }
+      function u64Sub(a, b) {
+        const aBig = u64ToBigInt(a);
+        const bBig = u64ToBigInt(b);
+        const diff = aBig - bBig;
+        if (diff < ZERO) {
+          throw new RangeError(`u64Sub: a < b (${aBig} < ${bBig})`);
+        }
+        return diff;
+      }
+    }
+  });
+
+  // node_modules/@signageos/brightsign-decoder/dist/remux/MpegTsMuxer.js
+  var require_MpegTsMuxer = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/remux/MpegTsMuxer.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.MpegTsMuxer = void 0;
+      exports.computeCrc32 = computeCrc32;
+      exports.verifyCrc32 = verifyCrc32;
+      var AnnexB_1 = require_AnnexB();
+      var TransportClock_1 = require_TransportClock();
+      var TS_PACKET_SIZE = 188;
+      var PAT_PID = 0;
+      var PMT_PID = 4096;
+      var VIDEO_PID = 256;
+      var H264_STREAM_TYPE = 27;
+      var PES_STREAM_ID = 224;
+      var crcTable = [];
+      for (let i = 0; i < 256; i += 1) {
+        let crc = i << 24;
+        for (let bit = 0; bit < 8; bit += 1) {
+          if (crc & 2147483648) {
+            crc = (crc << 1 ^ 79764919) >>> 0;
+          } else {
+            crc = crc << 1 >>> 0;
+          }
+        }
+        crcTable.push(crc >>> 0);
+      }
+      function computeCrc32(data, start, end) {
+        let crc = 4294967295;
+        for (let i = start; i < end; i += 1) {
+          const byte = data[i];
+          if (byte === void 0) {
+            break;
+          }
+          const tableIndex = (crc >>> 24 ^ byte) & 255;
+          const tableValue = crcTable[tableIndex];
+          if (tableValue === void 0) {
+            throw new Error("CRC table index out of bounds");
+          }
+          crc = (crc << 8 ^ tableValue) >>> 0;
+        }
+        return crc >>> 0;
+      }
+      function verifyCrc32(data, sectionStart, sectionLength) {
+        if (sectionLength < 4) {
+          return false;
+        }
+        const crcOffset = sectionStart + sectionLength - 4;
+        const computed = computeCrc32(data, sectionStart, crcOffset);
+        const b0 = data[crcOffset];
+        const b1 = data[crcOffset + 1];
+        const b2 = data[crcOffset + 2];
+        const b3 = data[crcOffset + 3];
+        if (b0 === void 0 || b1 === void 0 || b2 === void 0 || b3 === void 0) {
+          return false;
+        }
+        const stored = (b0 << 24 | b1 << 16 | b2 << 8 | b3) >>> 0;
+        return computed === stored;
+      }
+      function encodePts(pts, target, offset) {
+        const pts30 = Math.floor(pts / 1073741824) & 7;
+        const pts22 = Math.floor(pts / 4194304) & 255;
+        const pts15 = Math.floor(pts / 32768) & 127;
+        const pts7 = Math.floor(pts / 128) & 255;
+        const pts0 = pts & 127;
+        target[offset] = 33 | pts30 << 1;
+        target[offset + 1] = pts22;
+        target[offset + 2] = pts15 << 1 | 1;
+        target[offset + 3] = pts7;
+        target[offset + 4] = pts0 << 1 | 1;
+      }
+      function encodePcr(pcrBase, target, offset) {
+        const b32 = Math.floor(pcrBase / 4294967296) & 1;
+        const b24 = Math.floor(pcrBase / 16777216) & 255;
+        const b16 = Math.floor(pcrBase / 65536) & 255;
+        const b8 = Math.floor(pcrBase / 256) & 255;
+        const b0 = pcrBase & 255;
+        target[offset] = b32 << 7 | b24 >>> 1;
+        target[offset + 1] = (b24 & 1) << 7 | b16 >>> 1;
+        target[offset + 2] = (b16 & 1) << 7 | b8 >>> 1;
+        target[offset + 3] = (b8 & 1) << 7 | b0 >>> 1;
+        target[offset + 4] = (b0 & 1) << 7 | 126;
+        target[offset + 5] = 0;
+      }
+      var RbspBitReader = class {
+        constructor(data) {
+          this.data = data;
+          this.byteOffset = 0;
+          this.bitOffset = 0;
+        }
+        readUnsignedExpGolomb() {
+          let leadingZeroBits = 0;
+          while (this.readBit() === 0) {
+            leadingZeroBits += 1;
+            if (leadingZeroBits > 52) {
+              throw new Error("unsigned Exp-Golomb value exceeds safe integer range");
+            }
+          }
+          let suffix = 0;
+          for (let index = 0; index < leadingZeroBits; index += 1) {
+            suffix = suffix * 2 + this.readBit();
+          }
+          const value = 2 ** leadingZeroBits - 1 + suffix;
+          if (!Number.isSafeInteger(value)) {
+            throw new Error("unsigned Exp-Golomb value exceeds safe integer range");
+          }
+          return value;
+        }
+        readBit() {
+          const byte = this.data[this.byteOffset];
+          if (byte === void 0) {
+            throw new Error("truncated unsigned Exp-Golomb value");
+          }
+          const bit = byte >> 7 - this.bitOffset & 1;
+          this.bitOffset += 1;
+          if (this.bitOffset === 8) {
+            this.bitOffset = 0;
+            this.byteOffset += 1;
+          }
+          return bit;
+        }
+      };
+      function ebspToRbsp(ebsp) {
+        const rbsp = [];
+        let consecutiveZeros = 0;
+        for (let index = 0; index < ebsp.byteLength; index += 1) {
+          const byte = ebsp[index];
+          if (byte === void 0) {
+            throw new Error("slice payload ended unexpectedly");
+          }
+          if (consecutiveZeros >= 2 && byte === 3) {
+            const followingByte = ebsp[index + 1];
+            if (followingByte === void 0 || followingByte > 3) {
+              throw new Error("invalid emulation-prevention sequence");
+            }
+            consecutiveZeros = 0;
+            continue;
+          }
+          rbsp.push(byte);
+          consecutiveZeros = byte === 0 ? consecutiveZeros + 1 : 0;
+        }
+        return new Uint8Array(rbsp);
+      }
+      function parseSliceType(data, unit) {
+        const nalHeaderOffset = unit.offset + (0, AnnexB_1.startCodeLength)(data, unit.offset);
+        const payloadOffset = nalHeaderOffset + 1;
+        const unitEnd = unit.offset + unit.length;
+        if (payloadOffset >= unitEnd) {
+          throw new Error("slice header is missing");
+        }
+        const reader = new RbspBitReader(ebspToRbsp(data.subarray(payloadOffset, unitEnd)));
+        reader.readUnsignedExpGolomb();
+        const sliceType = reader.readUnsignedExpGolomb();
+        if (sliceType > 9) {
+          throw new Error(`slice_type ${sliceType} is outside the valid range 0..9`);
+        }
+        return sliceType;
+      }
+      function validateSliceHeaders(data, nalUnits) {
+        for (const unit of nalUnits) {
+          if (unit.type !== AnnexB_1.NalType.NonIDRSlice && unit.type !== AnnexB_1.NalType.IDRSlice) {
+            continue;
+          }
+          let sliceType;
+          try {
+            sliceType = parseSliceType(data, unit);
+          } catch (error) {
+            const detail = error instanceof Error ? error.message : "unknown slice-header parse error";
+            throw new Error(`Invalid H.264 slice header in NAL type ${unit.type}: ${detail}`);
+          }
+          if (sliceType % 5 === 1) {
+            throw new Error("H.264 B slices are unsupported because the muxer cannot derive DTS separately from PTS");
+          }
+        }
+      }
+      var MpegTsMuxer = class {
+        constructor(options) {
+          var _a, _b;
+          this.patCc = 0;
+          this.pmtCc = 0;
+          this.videoCc = 0;
+          this.needPat = true;
+          this.waitingForIdr = true;
+          this.preparedTransactionOutstanding = false;
+          this.clock = new TransportClock_1.TransportClock((_a = options == null ? void 0 : options.initialPts) != null ? _a : 0);
+          this.pcrLeadTicks = (_b = options == null ? void 0 : options.pcrLeadTicks) != null ? _b : 0;
+          if (!Number.isSafeInteger(this.pcrLeadTicks) || this.pcrLeadTicks < 0 || this.pcrLeadTicks >= 8589934592) {
+            throw new RangeError("pcrLeadTicks must be an integer in the 33-bit MPEG timestamp range");
+          }
+        }
+        /**
+         * Prepare one access unit without exposing its state changes until transport accepts it.
+         * Decoder operations are serialized, so only one prepared unit may be unsettled at a time.
+         */
+        prepare(data, timestamp) {
+          this.assertNoPreparedTransaction("prepare another access unit");
+          const previous = this.captureState();
+          let packets;
+          try {
+            packets = this.mux(data, timestamp);
+          } catch (error) {
+            this.restoreState(previous);
+            throw error;
+          }
+          const next = this.captureState();
+          this.restoreState(previous);
+          this.preparedTransactionOutstanding = true;
+          let settled = false;
+          return {
+            packets,
+            commit: () => {
+              if (settled) {
+                return;
+              }
+              settled = true;
+              this.preparedTransactionOutstanding = false;
+              this.restoreState(next);
+            },
+            rejectBeforeWrite: () => {
+              if (settled) {
+                return;
+              }
+              settled = true;
+              this.preparedTransactionOutstanding = false;
+              this.restoreState(previous);
+              this.waitingForIdr = true;
+              this.needPat = true;
+            }
+          };
+        }
+        assertNoPreparedTransaction(operation) {
+          if (this.preparedTransactionOutstanding) {
+            throw new Error(`Cannot ${operation} while a prepared transaction is outstanding`);
+          }
+        }
+        captureState() {
+          return {
+            clock: this.clock.captureState(),
+            patContinuity: this.patCc,
+            pmtContinuity: this.pmtCc,
+            videoContinuity: this.videoCc,
+            needPat: this.needPat,
+            sps: this.lastSps,
+            pps: this.lastPps,
+            waitingForIdr: this.waitingForIdr
+          };
+        }
+        restoreState(state) {
+          this.clock.restoreState(state.clock);
+          this.patCc = state.patContinuity;
+          this.pmtCc = state.pmtContinuity;
+          this.videoCc = state.videoContinuity;
+          this.needPat = state.needPat;
+          this.lastSps = state.sps;
+          this.lastPps = state.pps;
+          this.waitingForIdr = state.waitingForIdr;
+        }
+        /** Reset counters for a new TS epoch (SPS/PPS change). */
+        resetEpoch() {
+          this.assertNoPreparedTransaction("reset the muxer epoch");
+          this.patCc = 0;
+          this.pmtCc = 0;
+          this.videoCc = 0;
+          this.needPat = true;
+          this.clock.reset();
+          this.lastSps = void 0;
+          this.lastPps = void 0;
+          this.waitingForIdr = true;
+        }
+        /**
+         * Mux an Annex-B access unit into aligned 188-byte TS packets.
+         * Returns array of TS packet buffers.
+         *
+         * PAT/PMT are emitted immediately before every IDR so each random-access
+         * access unit is a self-contained replay boundary. PCR is emitted on the
+         * first video packet of every access unit; random-access indication remains
+         * IDR-only.
+         */
+        mux(data, timestamp) {
+          var _a, _b;
+          this.assertNoPreparedTransaction("mux an access unit");
+          const info = (0, AnnexB_1.inspectAccessUnit)(data);
+          validateSliceHeaders(data, info.nalUnits);
+          const hasVcl = info.nalUnits.some((unit) => unit.type === AnnexB_1.NalType.NonIDRSlice || unit.type === AnnexB_1.NalType.IDRSlice);
+          const spsChanged = info.spsData !== void 0 && this.lastSps !== void 0 && !bytesEqual(this.lastSps, info.spsData);
+          const ppsChanged = info.ppsData !== void 0 && this.lastPps !== void 0 && !bytesEqual(this.lastPps, info.ppsData);
+          const candidateSps = (_a = info.spsData) != null ? _a : this.lastSps;
+          const candidatePps = (_b = info.ppsData) != null ? _b : this.lastPps;
+          const parameterChanged = spsChanged || ppsChanged;
+          if (!hasVcl) {
+            if (info.spsData !== void 0) {
+              this.lastSps = info.spsData.slice();
+            }
+            if (info.ppsData !== void 0) {
+              this.lastPps = info.ppsData.slice();
+            }
+            if (parameterChanged) {
+              this.waitingForIdr = true;
+              this.needPat = true;
+            }
+            return [];
+          }
+          const recoveryRequired = this.waitingForIdr || parameterChanged;
+          if (recoveryRequired && !info.isIDR) {
+            throw new Error("Waiting for an IDR access unit after startup or parameter change");
+          }
+          if (info.isIDR && (candidateSps === void 0 || candidatePps === void 0)) {
+            throw new Error("Cannot establish a random-access epoch without both SPS and PPS");
+          }
+          const payload = info.isIDR ? prependParameterSets(data, info.hasSPS, info.hasPPS, candidateSps, candidatePps) : data;
+          const pts = this.clock.toPts(timestamp);
+          if (info.spsData !== void 0) {
+            this.lastSps = info.spsData.slice();
+          }
+          if (info.ppsData !== void 0) {
+            this.lastPps = info.ppsData.slice();
+          }
+          if (recoveryRequired) {
+            this.waitingForIdr = false;
+            this.needPat = true;
+          }
+          const packets = [];
+          if (this.needPat || info.isIDR) {
+            packets.push(this.buildPat());
+            packets.push(this.buildPmt());
+            this.needPat = false;
+          }
+          const pesHeader = buildPesHeader(pts, payload.byteLength);
+          const pesLength = pesHeader.byteLength + payload.byteLength;
+          let offset = 0;
+          let first = true;
+          while (offset < pesLength) {
+            const packet = new Uint8Array(TS_PACKET_SIZE);
+            packet.fill(255);
+            packet[0] = 71;
+            const pusi = first ? 64 : 0;
+            packet[1] = pusi | VIDEO_PID >> 8 & 31;
+            packet[2] = VIDEO_PID & 255;
+            const remaining = pesLength - offset;
+            const maxPayload = TS_PACKET_SIZE - 4;
+            if (first) {
+              const adaptationFlags = 16 | (info.isIDR ? 64 : 0);
+              const minimumAdaptationLength = 7;
+              const payloadCapacity = TS_PACKET_SIZE - 4 - 1 - minimumAdaptationLength;
+              const bytesToCopy = Math.min(remaining, payloadCapacity);
+              const adaptationLength = bytesToCopy < payloadCapacity ? TS_PACKET_SIZE - 5 - bytesToCopy : minimumAdaptationLength;
+              const payloadStart = 5 + adaptationLength;
+              packet[3] = 48 | this.videoCc & 15;
+              this.videoCc = this.videoCc + 1 & 15;
+              packet[4] = adaptationLength;
+              packet[5] = adaptationFlags;
+              const pcr = (pts - this.pcrLeadTicks + 8589934592) % 8589934592;
+              encodePcr(pcr, packet, 6);
+              copyPesBytes(pesHeader, payload, offset, bytesToCopy, packet, payloadStart);
+              offset += bytesToCopy;
+            } else if (remaining >= maxPayload) {
+              packet[3] = 16 | this.videoCc & 15;
+              this.videoCc = this.videoCc + 1 & 15;
+              copyPesBytes(pesHeader, payload, offset, maxPayload, packet, 4);
+              offset += maxPayload;
+            } else {
+              const adaptFieldLength = 183 - remaining;
+              packet[3] = 48 | this.videoCc & 15;
+              this.videoCc = this.videoCc + 1 & 15;
+              packet[4] = adaptFieldLength;
+              if (adaptFieldLength > 0) {
+                packet[5] = 0;
+              }
+              const payloadStart = 5 + adaptFieldLength;
+              copyPesBytes(pesHeader, payload, offset, remaining, packet, payloadStart);
+              offset = pesLength;
+            }
+            first = false;
+            packets.push(packet);
+          }
+          return packets;
+        }
+        /** Build a PAT (Program Association Table) TS packet. */
+        buildPat() {
+          const packet = new Uint8Array(TS_PACKET_SIZE);
+          packet.fill(255);
+          packet[0] = 71;
+          packet[1] = 64 | PAT_PID >> 8 & 31;
+          packet[2] = PAT_PID & 255;
+          packet[3] = 16 | this.patCc & 15;
+          this.patCc = this.patCc + 1 & 15;
+          packet[4] = 0;
+          const sectionStart = 5;
+          packet[sectionStart] = 0;
+          packet[sectionStart + 1] = 176;
+          packet[sectionStart + 2] = 13;
+          packet[sectionStart + 3] = 0;
+          packet[sectionStart + 4] = 1;
+          packet[sectionStart + 5] = 193;
+          packet[sectionStart + 6] = 0;
+          packet[sectionStart + 7] = 0;
+          packet[sectionStart + 8] = 0;
+          packet[sectionStart + 9] = 1;
+          packet[sectionStart + 10] = 224 | PMT_PID >> 8 & 31;
+          packet[sectionStart + 11] = PMT_PID & 255;
+          const crc = computeCrc32(packet, sectionStart, sectionStart + 12);
+          const crcOffset = sectionStart + 12;
+          packet[crcOffset] = crc >>> 24 & 255;
+          packet[crcOffset + 1] = crc >>> 16 & 255;
+          packet[crcOffset + 2] = crc >>> 8 & 255;
+          packet[crcOffset + 3] = crc & 255;
+          return packet;
+        }
+        /** Build a PMT (Program Map Table) TS packet. */
+        buildPmt() {
+          const packet = new Uint8Array(TS_PACKET_SIZE);
+          packet.fill(255);
+          packet[0] = 71;
+          packet[1] = 64 | PMT_PID >> 8 & 31;
+          packet[2] = PMT_PID & 255;
+          packet[3] = 16 | this.pmtCc & 15;
+          this.pmtCc = this.pmtCc + 1 & 15;
+          packet[4] = 0;
+          const sectionStart = 5;
+          packet[sectionStart] = 2;
+          packet[sectionStart + 1] = 176;
+          packet[sectionStart + 2] = 18;
+          packet[sectionStart + 3] = 0;
+          packet[sectionStart + 4] = 1;
+          packet[sectionStart + 5] = 193;
+          packet[sectionStart + 6] = 0;
+          packet[sectionStart + 7] = 0;
+          packet[sectionStart + 8] = 224 | VIDEO_PID >> 8 & 31;
+          packet[sectionStart + 9] = VIDEO_PID & 255;
+          packet[sectionStart + 10] = 240;
+          packet[sectionStart + 11] = 0;
+          packet[sectionStart + 12] = H264_STREAM_TYPE;
+          packet[sectionStart + 13] = 224 | VIDEO_PID >> 8 & 31;
+          packet[sectionStart + 14] = VIDEO_PID & 255;
+          packet[sectionStart + 15] = 240;
+          packet[sectionStart + 16] = 0;
+          const crc = computeCrc32(packet, sectionStart, sectionStart + 17);
+          const crcOffset = sectionStart + 17;
+          packet[crcOffset] = crc >>> 24 & 255;
+          packet[crcOffset + 1] = crc >>> 16 & 255;
+          packet[crcOffset + 2] = crc >>> 8 & 255;
+          packet[crcOffset + 3] = crc & 255;
+          return packet;
+        }
+        /** Get current continuity counter state for diagnostics. */
+        get counters() {
+          return { pat: this.patCc, pmt: this.pmtCc, video: this.videoCc };
+        }
+      };
+      exports.MpegTsMuxer = MpegTsMuxer;
+      function buildPesHeader(pts, dataLength) {
+        const pesHeaderLength = 14;
+        const header = new Uint8Array(pesHeaderLength);
+        header[0] = 0;
+        header[1] = 0;
+        header[2] = 1;
+        header[3] = PES_STREAM_ID;
+        const pesPayloadLength = dataLength + 8;
+        if (pesPayloadLength > 65535) {
+          header[4] = 0;
+          header[5] = 0;
+        } else {
+          header[4] = pesPayloadLength >> 8 & 255;
+          header[5] = pesPayloadLength & 255;
+        }
+        header[6] = 128;
+        header[7] = 128;
+        header[8] = 5;
+        encodePts(pts, header, 9);
+        return header;
+      }
+      function prependParameterSets(data, hasSps, hasPps, sps, pps) {
+        if (sps === void 0 || pps === void 0) {
+          throw new Error("SPS/PPS state is unavailable");
+        }
+        const spsLength = hasSps ? 0 : sps.byteLength;
+        const ppsLength = hasPps ? 0 : pps.byteLength;
+        if (spsLength === 0 && ppsLength === 0) {
+          return data;
+        }
+        const result = new Uint8Array(spsLength + ppsLength + data.byteLength);
+        let offset = 0;
+        if (!hasSps) {
+          result.set(sps, offset);
+          offset += sps.byteLength;
+        }
+        if (!hasPps) {
+          result.set(pps, offset);
+          offset += pps.byteLength;
+        }
+        result.set(data, offset);
+        return result;
+      }
+      function copyPesBytes(header, payload, sourceOffset, length, destination, destinationOffset) {
+        let remaining = length;
+        let source = sourceOffset;
+        let target = destinationOffset;
+        if (source < header.byteLength && remaining > 0) {
+          const headerLength = Math.min(remaining, header.byteLength - source);
+          destination.set(header.subarray(source, source + headerLength), target);
+          source += headerLength;
+          target += headerLength;
+          remaining -= headerLength;
+        }
+        if (remaining > 0) {
+          const payloadOffset = source - header.byteLength;
+          destination.set(payload.subarray(payloadOffset, payloadOffset + remaining), target);
+        }
+      }
+      function bytesEqual(a, b) {
+        if (a.byteLength !== b.byteLength) {
+          return false;
+        }
+        for (let i = 0; i < a.byteLength; i += 1) {
+          if (a[i] !== b[i]) {
+            return false;
+          }
+        }
+        return true;
+      }
+    }
+  });
+
+  // node_modules/@signageos/brightsign-decoder/dist/decoder/NativeHttpServer.js
+  var require_NativeHttpServer = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/decoder/NativeHttpServer.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.NativeHttpServer = exports.NativeHttpPreWriteError = void 0;
+      var TS_PACKET_SIZE = 188;
+      var DEFAULT_MAX_REPLAY_PACKETS = 8192;
+      var DEFAULT_MAX_REPLAY_BYTES = 2 * 1024 * 1024;
+      var DEFAULT_PROBE_PROMOTION_DELAY_MS = 100;
+      var NativeHttpPreWriteError = class extends Error {
+        constructor(message) {
+          super(message);
+          this.name = "NativeHttpPreWriteError";
+        }
+      };
+      exports.NativeHttpPreWriteError = NativeHttpPreWriteError;
+      var NativeHttpServer = class {
+        constructor(options) {
+          var _a, _b, _c, _d;
+          this.requests = /* @__PURE__ */ new Set();
+          this.backpressureWaits = [];
+          this.totalRequests = 0;
+          this.closedRequests = 0;
+          this.responseCloseEvents = 0;
+          this.responseErrorEvents = 0;
+          this.rejectedRequests = 0;
+          this.probeReplacements = 0;
+          this.playbackPromotions = 0;
+          this.playbackReconnects = 0;
+          this.playbackClosures = 0;
+          this.backpressureEvents = 0;
+          this.totalBackpressureWaitMs = 0;
+          this.packetsWritten = 0;
+          this.bytesWritten = 0;
+          this.replayBoundaries = 0;
+          this.replayReplacements = 0;
+          this.replayFreezes = 0;
+          this.lastClosedRequestPackets = 0;
+          this.lastClosedRequestBytes = 0;
+          this.replayUnits = [];
+          this.replayPacketCount = 0;
+          this.replayByteLength = 0;
+          this.replayFrozen = false;
+          this.writeChain = Promise.resolve();
+          this.port = 0;
+          this.destroyed = false;
+          this.teardownComplete = false;
+          this.serverClosed = false;
+          this.maxReplayPackets = (_a = options == null ? void 0 : options.maxReplayPackets) != null ? _a : DEFAULT_MAX_REPLAY_PACKETS;
+          this.maxReplayBytes = (_b = options == null ? void 0 : options.maxReplayBytes) != null ? _b : DEFAULT_MAX_REPLAY_BYTES;
+          this.probePromotionDelayMs = (_c = options == null ? void 0 : options.probePromotionDelayMs) != null ? _c : DEFAULT_PROBE_PROMOTION_DELAY_MS;
+          this.now = (_d = options == null ? void 0 : options.now) != null ? _d : Date.now;
+          if (!Number.isSafeInteger(this.maxReplayPackets) || this.maxReplayPackets <= 0) {
+            throw new RangeError("maxReplayPackets must be a positive integer");
+          }
+          if (!Number.isSafeInteger(this.maxReplayBytes) || this.maxReplayBytes <= 0) {
+            throw new RangeError("maxReplayBytes must be a positive integer");
+          }
+          if (!Number.isFinite(this.probePromotionDelayMs) || this.probePromotionDelayMs < 0) {
+            throw new RangeError("probePromotionDelayMs must be a finite non-negative number");
+          }
+        }
+        async start(httpModule) {
+          if (this.destroyed) {
+            throw new Error("NativeHttpServer has been destroyed");
+          }
+          if (this.server !== void 0) {
+            throw new Error("NativeHttpServer is already started");
+          }
+          await new Promise((resolve, reject) => {
+            let settled = false;
+            try {
+              const created = httpModule.createServer((_request, response) => {
+                this.handleRequest(response);
+              });
+              const server = narrowToHttpServerLike(created);
+              this.server = server;
+              server.on("error", (value) => {
+                const error = toError(value, "Loopback HTTP server error");
+                if (!settled) {
+                  settled = true;
+                  reject(error);
+                  return;
+                }
+                this.recordServerFailure(error);
+              });
+              server.listen(0, "127.0.0.1", () => {
+                if (settled) {
+                  return;
+                }
+                const address = server.address();
+                if (typeof address !== "object" || address === null || !Number.isInteger(address.port)) {
+                  settled = true;
+                  reject(new Error("Loopback HTTP server did not report a bound port"));
+                  return;
+                }
+                this.port = address.port;
+                settled = true;
+                resolve();
+              });
+            } catch (error) {
+              settled = true;
+              reject(toError(error, "Loopback HTTP server creation failed"));
+            }
+          });
+          return this.port;
+        }
+        getDiagnostics() {
+          var _a;
+          const activeBackpressureWaitMs = this.backpressureWaits.reduce((total, wait) => total + Math.max(0, this.now() - wait.startedAtMs), 0);
+          return {
+            activeRequests: this.requests.size,
+            totalRequests: this.totalRequests,
+            closedRequests: this.closedRequests,
+            responseCloseEvents: this.responseCloseEvents,
+            responseErrorEvents: this.responseErrorEvents,
+            rejectedRequests: this.rejectedRequests,
+            probeReplacements: this.probeReplacements,
+            playbackPromotions: this.playbackPromotions,
+            playbackReconnects: this.playbackReconnects,
+            playbackClosures: this.playbackClosures,
+            backpressureEvents: this.backpressureEvents,
+            activeBackpressureWaits: this.backpressureWaits.length,
+            totalBackpressureWaitMs: this.totalBackpressureWaitMs + activeBackpressureWaitMs,
+            packetsWritten: this.packetsWritten,
+            bytesWritten: this.bytesWritten,
+            replayUnits: this.replayUnits.length,
+            replayPackets: this.replayPacketCount,
+            replayBytes: this.replayByteLength,
+            replayFrozen: this.replayFrozen,
+            replayBoundaries: this.replayBoundaries,
+            replayReplacements: this.replayReplacements,
+            replayFreezes: this.replayFreezes,
+            waitingForBoundary: ((_a = this.playbackRequest) == null ? void 0 : _a.waitingForBoundary) === true,
+            lastClosedRequestPackets: this.lastClosedRequestPackets,
+            lastClosedRequestBytes: this.lastClosedRequestBytes
+          };
+        }
+        async writeAccessUnit(packets) {
+          if (this.destroyed) {
+            throw new NativeHttpPreWriteError("NativeHttpServer has been destroyed");
+          }
+          if (this.serverFailure !== void 0) {
+            throw new NativeHttpPreWriteError(this.serverFailure.message);
+          }
+          if (packets.length === 0) {
+            return;
+          }
+          for (const packet of packets) {
+            if (packet.byteLength !== TS_PACKET_SIZE || packet[0] !== 71) {
+              throw new NativeHttpPreWriteError("Native HTTP transport accepts only aligned 188-byte TS packets");
+            }
+          }
+          const replayBoundary = packets.some(isPatPacket) && packets.some(isPmtPacket) && packets.some(hasRandomAccessIndicator);
+          await this.enqueueWrite(async () => {
+            if (this.destroyed) {
+              throw new NativeHttpPreWriteError("NativeHttpServer has been destroyed");
+            }
+            if (this.serverFailure !== void 0) {
+              throw new NativeHttpPreWriteError(this.serverFailure.message);
+            }
+            const replayState = this.captureReplayState();
+            let playback;
+            let packetsWrittenBefore = 0;
+            try {
+              this.retainReplayUnit(packets, replayBoundary);
+              playback = this.playbackRequest;
+              if (playback === void 0 || playback.closed) {
+                return;
+              }
+              if (playback.waitingForBoundary && !replayBoundary) {
+                return;
+              }
+              packetsWrittenBefore = playback.packetsWritten;
+              for (const packet of packets) {
+                await this.writePacketToRequest(playback, packet);
+              }
+              if (replayBoundary && !playback.closed) {
+                playback.waitingForBoundary = false;
+              }
+            } catch (error) {
+              const normalized = toError(error, "Native HTTP response failed during access-unit delivery");
+              if (playback !== void 0) {
+                this.retireRequest(playback, normalized);
+              }
+              if (playback === void 0 || playback.packetsWritten === packetsWrittenBefore) {
+                this.restoreReplayState(replayState);
+                throw new NativeHttpPreWriteError(normalized.message);
+              }
+              throw normalized;
+            }
+          });
+        }
+        async writePacket(packet) {
+          await this.writeAccessUnit([packet]);
+        }
+        get uri() {
+          if (this.port === 0) {
+            throw new Error("NativeHttpServer is not started");
+          }
+          return `http://127.0.0.1:${this.port}/stream.ts`;
+        }
+        destroy() {
+          if (this.teardownComplete) {
+            return Promise.resolve();
+          }
+          if (this.teardown !== void 0) {
+            return this.teardown;
+          }
+          this.destroyed = true;
+          const attempt = this.performTeardown();
+          const promise = attempt.then(() => {
+            this.teardownComplete = true;
+          }, (error) => {
+            if (this.teardown === promise) {
+              this.teardown = void 0;
+            }
+            throw error;
+          });
+          this.teardown = promise;
+          return promise;
+        }
+        async performTeardown() {
+          if (this.promotionTimer !== void 0) {
+            clearTimeout(this.promotionTimer);
+            this.promotionTimer = void 0;
+          }
+          for (const request of this.requests) {
+            this.closeRequest(request);
+            request.response.destroy();
+          }
+          this.requests.clear();
+          this.playbackRequest = void 0;
+          this.promotingRequest = void 0;
+          this.probeRequest = void 0;
+          this.replayUnits.length = 0;
+          this.replayPacketCount = 0;
+          this.replayByteLength = 0;
+          this.replayFrozen = false;
+          await this.writeChain;
+          const server = this.server;
+          if (!this.serverClosed && server !== void 0) {
+            await new Promise((resolve) => {
+              server.close(resolve);
+            });
+            this.serverClosed = true;
+            this.server = void 0;
+          }
+        }
+        handleRequest(value) {
+          if (this.destroyed) {
+            return;
+          }
+          let response;
+          try {
+            response = narrowToHttpResponseLike(value);
+          } catch {
+            return;
+          }
+          response.writeHead(200, {
+            "Cache-Control": "no-store",
+            Connection: "keep-alive",
+            "Content-Type": "video/mp2t",
+            "Transfer-Encoding": "chunked"
+          });
+          this.totalRequests += 1;
+          const request = {
+            response,
+            drainWaiters: /* @__PURE__ */ new Set(),
+            closed: false,
+            waitingForBoundary: false,
+            bytesWritten: 0,
+            packetsWritten: 0
+          };
+          this.requests.add(request);
+          response.once("close", () => {
+            this.responseCloseEvents += 1;
+            this.closeRequest(request, new Error("Native HTTP response closed before delivery completed"));
+          });
+          response.once("error", (...args) => {
+            this.responseErrorEvents += 1;
+            this.closeRequest(request, toError(args[0], "Native HTTP response failed before delivery completed"));
+          });
+          if (this.hasConnectedPlaybackRequest()) {
+            if (this.probeRequest !== void 0 && !this.probeRequest.closed) {
+              this.probeReplacements += 1;
+              this.probeRequest.response.end();
+              this.closeRequest(this.probeRequest);
+            }
+            this.probeRequest = request;
+            return;
+          }
+          if (this.probeRequest === void 0 || this.probeRequest.closed) {
+            this.probeRequest = request;
+            this.scheduleProbePromotion(request, this.playbackPromotions > 0 ? 0 : this.probePromotionDelayMs);
+            return;
+          }
+          const probe = this.probeRequest;
+          if (!probe.closed) {
+            this.probeReplacements += 1;
+            probe.response.end();
+            this.closeRequest(probe);
+          }
+          this.promoteToPlayback(request);
+        }
+        scheduleProbePromotion(request, delayMs) {
+          this.promotionTimer = setTimeout(() => {
+            this.promotionTimer = void 0;
+            if (!request.closed && this.playbackRequest === void 0 && this.probeRequest === request) {
+              this.promoteToPlayback(request);
+            }
+          }, delayMs);
+        }
+        promoteToPlayback(request) {
+          if (request.closed || this.destroyed || this.playbackRequest !== void 0 || this.promotingRequest !== void 0) {
+            return;
+          }
+          if (this.promotionTimer !== void 0) {
+            clearTimeout(this.promotionTimer);
+            this.promotionTimer = void 0;
+          }
+          if (this.probeRequest === request) {
+            this.probeRequest = void 0;
+          }
+          this.promotingRequest = request;
+          void this.enqueueWrite(async () => {
+            if (request.closed || this.destroyed || this.promotingRequest !== request || this.playbackRequest !== void 0) {
+              if (this.promotingRequest === request) {
+                this.promotingRequest = void 0;
+              }
+              return;
+            }
+            if (this.replayFrozen || this.replayUnits.length === 0) {
+              this.promotingRequest = void 0;
+              this.recordPlaybackPromotion();
+              this.playbackRequest = request;
+              request.waitingForBoundary = true;
+              return;
+            }
+            const replay = this.replayUnits.slice();
+            try {
+              for (const unit of replay) {
+                for (const packet of unit.packets) {
+                  await this.writePacketToRequest(request, packet);
+                }
+              }
+            } catch (error) {
+              this.retireRequest(request, toError(error, "Native HTTP response failed during replay"));
+              return;
+            }
+            if (request.closed || this.destroyed || this.promotingRequest !== request || this.playbackRequest !== void 0) {
+              if (this.promotingRequest === request) {
+                this.promotingRequest = void 0;
+              }
+              return;
+            }
+            this.promotingRequest = void 0;
+            this.recordPlaybackPromotion();
+            this.playbackRequest = request;
+          });
+        }
+        recordPlaybackPromotion() {
+          if (this.playbackPromotions > 0) {
+            this.playbackReconnects += 1;
+          }
+          this.playbackPromotions += 1;
+        }
+        hasConnectedPlaybackRequest() {
+          return this.playbackRequest !== void 0 && !this.playbackRequest.closed || this.promotingRequest !== void 0 && !this.promotingRequest.closed;
+        }
+        captureReplayState() {
+          return {
+            units: this.replayUnits.slice(),
+            packetCount: this.replayPacketCount,
+            byteLength: this.replayByteLength,
+            frozen: this.replayFrozen
+          };
+        }
+        restoreReplayState(state) {
+          this.replayUnits.length = 0;
+          this.replayUnits.push(...state.units);
+          this.replayPacketCount = state.packetCount;
+          this.replayByteLength = state.byteLength;
+          this.replayFrozen = state.frozen;
+        }
+        retainReplayUnit(packets, replayBoundary) {
+          const byteLength = packets.reduce((total, packet) => total + packet.byteLength, 0);
+          if (replayBoundary) {
+            if (packets.length > this.maxReplayPackets || byteLength > this.maxReplayBytes) {
+              throw new NativeHttpPreWriteError("A replay-boundary access unit exceeds the replay capacity");
+            }
+            this.replayBoundaries += 1;
+            if (this.replayUnits.length > 0) {
+              this.replayReplacements += 1;
+            }
+            const replacement = copyPackets(packets);
+            this.replayUnits.length = 0;
+            this.replayUnits.push({ packets: replacement, byteLength });
+            this.replayPacketCount = packets.length;
+            this.replayByteLength = byteLength;
+            this.replayFrozen = false;
+            return;
+          }
+          if (this.replayUnits.length === 0 || this.replayFrozen) {
+            return;
+          }
+          if (this.replayPacketCount + packets.length > this.maxReplayPackets || this.replayByteLength + byteLength > this.maxReplayBytes) {
+            this.replayFrozen = true;
+            this.replayFreezes += 1;
+            return;
+          }
+          this.replayUnits.push({ packets: copyPackets(packets), byteLength });
+          this.replayPacketCount += packets.length;
+          this.replayByteLength += byteLength;
+        }
+        enqueueWrite(operation) {
+          const next = this.writeChain.then(operation);
+          this.writeChain = next.catch(() => void 0);
+          return next;
+        }
+        async writePacketToRequest(request, packet) {
+          if (request.closed) {
+            throw new Error("Native HTTP response closed before packet submission");
+          }
+          if (this.destroyed) {
+            return;
+          }
+          const accepted = request.response.write(packet);
+          request.bytesWritten += packet.byteLength;
+          request.packetsWritten += 1;
+          this.bytesWritten += packet.byteLength;
+          this.packetsWritten += 1;
+          if (accepted) {
+            return;
+          }
+          this.backpressureEvents += 1;
+          const wait = { startedAtMs: this.now() };
+          this.backpressureWaits.push(wait);
+          await new Promise((resolve, reject) => {
+            let settled = false;
+            const settle = (error) => {
+              if (settled) {
+                return;
+              }
+              settled = true;
+              request.drainWaiters.delete(settle);
+              const waitIndex = this.backpressureWaits.indexOf(wait);
+              if (waitIndex >= 0) {
+                this.backpressureWaits.splice(waitIndex, 1);
+              }
+              this.totalBackpressureWaitMs += Math.max(0, this.now() - wait.startedAtMs);
+              if (error === void 0) {
+                resolve();
+              } else {
+                reject(error);
+              }
+            };
+            request.drainWaiters.add(settle);
+            request.response.once("drain", () => settle(void 0));
+            if (request.closed) {
+              settle(new Error("Native HTTP response closed before backpressure drained"));
+            } else if (this.destroyed) {
+              settle(void 0);
+            }
+          });
+        }
+        recordServerFailure(error) {
+          if (this.destroyed || this.serverFailure !== void 0) {
+            return;
+          }
+          this.serverFailure = error;
+          for (const request of this.requests) {
+            this.retireRequest(request, error);
+          }
+        }
+        retireRequest(request, error) {
+          this.closeRequest(request, error);
+          request.response.destroy();
+        }
+        closeRequest(request, error) {
+          if (request.closed) {
+            return;
+          }
+          const wasPlaybackRequest = this.playbackRequest === request;
+          request.closed = true;
+          this.closedRequests += 1;
+          this.lastClosedRequestPackets = request.packetsWritten;
+          this.lastClosedRequestBytes = request.bytesWritten;
+          if (wasPlaybackRequest) {
+            this.playbackClosures += 1;
+          }
+          for (const settle of request.drainWaiters) {
+            settle(error);
+          }
+          request.drainWaiters.clear();
+          this.requests.delete(request);
+          if (this.playbackRequest === request) {
+            this.playbackRequest = void 0;
+          }
+          if (this.promotingRequest === request) {
+            this.promotingRequest = void 0;
+          }
+          if (this.probeRequest === request) {
+            this.probeRequest = void 0;
+          }
+          if (wasPlaybackRequest && this.probeRequest !== void 0 && !this.probeRequest.closed) {
+            this.promoteToPlayback(this.probeRequest);
+          }
+        }
+      };
+      exports.NativeHttpServer = NativeHttpServer;
+      function copyPackets(packets) {
+        return packets.map((packet) => {
+          const copy = new Uint8Array(packet.byteLength);
+          copy.set(packet);
+          return copy;
+        });
+      }
+      function packetPid(packet) {
+        const high = packet[1];
+        const low = packet[2];
+        if (high === void 0 || low === void 0) {
+          return void 0;
+        }
+        return (high & 31) << 8 | low;
+      }
+      function isPatPacket(packet) {
+        return packetPid(packet) === 0;
+      }
+      function isPmtPacket(packet) {
+        return packetPid(packet) === 4096;
+      }
+      function hasRandomAccessIndicator(packet) {
+        const control = packet[3];
+        const flags = packet[5];
+        if (control === void 0 || flags === void 0) {
+          return false;
+        }
+        const hasAdaptation = (control & 32) !== 0;
+        return packetPid(packet) === 256 && hasAdaptation && (flags & 64) !== 0;
+      }
+      function narrowToHttpServerLike(value) {
+        if (typeof value !== "object" || value === null) {
+          throw new TypeError("Expected an HTTP server object");
+        }
+        const listen = Reflect.get(value, "listen");
+        const close = Reflect.get(value, "close");
+        const address = Reflect.get(value, "address");
+        const on = Reflect.get(value, "on");
+        if (typeof listen !== "function" || typeof close !== "function" || typeof address !== "function" || typeof on !== "function") {
+          throw new TypeError("Object does not satisfy the HTTP server contract");
+        }
+        return {
+          listen(port, host, callback) {
+            Reflect.apply(listen, value, [port, host, callback]);
+          },
+          close(callback) {
+            Reflect.apply(close, value, callback === void 0 ? [] : [callback]);
+          },
+          address() {
+            const result = Reflect.apply(address, value, []);
+            if (typeof result === "string" || result === null) {
+              return result;
+            }
+            if (typeof result === "object") {
+              const port = Reflect.get(result, "port");
+              if (typeof port === "number") {
+                return { port };
+              }
+            }
+            return null;
+          },
+          on(event, listener) {
+            Reflect.apply(on, value, [event, listener]);
+          }
+        };
+      }
+      function narrowToHttpResponseLike(value) {
+        if (typeof value !== "object" || value === null) {
+          throw new TypeError("Expected an HTTP response object");
+        }
+        const writeHead = Reflect.get(value, "writeHead");
+        const write = Reflect.get(value, "write");
+        const end = Reflect.get(value, "end");
+        const destroy = Reflect.get(value, "destroy");
+        const on = Reflect.get(value, "on");
+        const once = Reflect.get(value, "once");
+        if (typeof writeHead !== "function" || typeof write !== "function" || typeof end !== "function" || typeof destroy !== "function" || typeof on !== "function" || typeof once !== "function") {
+          throw new TypeError("Object does not satisfy the HTTP response contract");
+        }
+        return {
+          writeHead(statusCode, headers) {
+            Reflect.apply(writeHead, value, [statusCode, headers]);
+          },
+          write(chunk) {
+            return Reflect.apply(write, value, [chunk]) !== false;
+          },
+          end() {
+            Reflect.apply(end, value, []);
+          },
+          destroy() {
+            Reflect.apply(destroy, value, []);
+          },
+          on(event, listener) {
+            Reflect.apply(on, value, [event, listener]);
+          },
+          once(event, listener) {
+            Reflect.apply(once, value, [event, listener]);
+          }
+        };
+      }
+      function toError(value, fallback) {
+        return value instanceof Error ? value : new Error(fallback);
+      }
+    }
+  });
+
+  // node_modules/@signageos/brightsign-decoder/dist/decoder/PlaybackSession.js
+  var require_PlaybackSession = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/decoder/PlaybackSession.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.PlaybackSession = void 0;
+      var bridgesWithErrorListener = /* @__PURE__ */ new WeakSet();
+      var PlaybackSession = class {
+        constructor(bridge) {
+          this.playing = false;
+          this.bridge = bridge;
+          if (this.bridge.onError !== void 0 && !bridgesWithErrorListener.has(this.bridge)) {
+            bridgesWithErrorListener.add(this.bridge);
+            this.bridge.onError((event) => {
+              console.error("BrightSign native stream playback error", event);
+            });
+          }
+        }
+        /** Start native playback at the given URI and coordinates. */
+        async start(uri, coords, protocol, options = {}) {
+          if (this.playing) {
+            await this.stop();
+          }
+          this.uri = uri;
+          this.coordinates = coords;
+          await this.bridge.play(uri, coords.x, coords.y, coords.width, coords.height, { protocol, ...options });
+          this.playing = true;
+        }
+        /**
+         * Stop native playback. Idempotent after success.
+         *
+         * If bridge.stop fails, playback state (uri, coordinates, playing flag) is
+         * preserved so a subsequent stop() retries the bridge teardown rather than
+         * silently no-oping with lost context.
+         */
+        async stop() {
+          if (!this.playing || this.uri === void 0 || this.coordinates === void 0) {
+            return;
+          }
+          await this.bridge.stop(this.uri, this.coordinates.x, this.coordinates.y, this.coordinates.width, this.coordinates.height);
+          this.playing = false;
+          this.uri = void 0;
+          this.coordinates = void 0;
+        }
+        /** Whether playback is active. */
+        get isPlaying() {
+          return this.playing;
+        }
+      };
+      exports.PlaybackSession = PlaybackSession;
+    }
+  });
+
+  // node_modules/@signageos/brightsign-decoder/dist/decoder/NativeUdpSender.js
+  var require_NativeUdpSender = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/decoder/NativeUdpSender.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.NativeUdpSender = exports.NativeUdpPreWriteError = void 0;
+      var TS_PACKET_SIZE = 188;
+      var DEFAULT_MAX_DATAGRAM_BYTES = 7 * TS_PACKET_SIZE;
+      var DEFAULT_STARTUP_REPEAT_COUNT = 3;
+      var DEFAULT_STARTUP_REPEAT_INTERVAL_MS = 20;
+      var NativeUdpPreWriteError = class extends Error {
+        constructor(message) {
+          super(message);
+          this.name = "NativeUdpPreWriteError";
+        }
+      };
+      exports.NativeUdpPreWriteError = NativeUdpPreWriteError;
+      var NativeUdpSender = class {
+        constructor(options) {
+          var _a, _b, _c;
+          this.pendingWarmupDelays = /* @__PURE__ */ new Set();
+          this.writeChain = Promise.resolve();
+          this.sourcePort = 0;
+          this.destinationPort = 0;
+          this.datagramsSent = 0;
+          this.bytesSent = 0;
+          this.accessUnitsSent = 0;
+          this.warmupAccessUnits = 0;
+          this.warmupRepeats = 0;
+          this.socketErrors = 0;
+          this.sendErrors = 0;
+          this.destroyed = false;
+          this.teardownComplete = false;
+          this.maxDatagramBytes = (_a = options == null ? void 0 : options.maxDatagramBytes) != null ? _a : DEFAULT_MAX_DATAGRAM_BYTES;
+          this.maxPacketsPerDatagram = Math.floor(this.maxDatagramBytes / TS_PACKET_SIZE);
+          this.startupRepeatCount = (_b = options == null ? void 0 : options.startupRepeatCount) != null ? _b : DEFAULT_STARTUP_REPEAT_COUNT;
+          this.startupRepeatIntervalMs = (_c = options == null ? void 0 : options.startupRepeatIntervalMs) != null ? _c : DEFAULT_STARTUP_REPEAT_INTERVAL_MS;
+          if (!Number.isSafeInteger(this.maxDatagramBytes) || this.maxDatagramBytes < TS_PACKET_SIZE) {
+            throw new RangeError("maxDatagramBytes must be an integer greater than or equal to one TS packet");
+          }
+          if (this.maxPacketsPerDatagram <= 0) {
+            throw new RangeError("maxDatagramBytes must allow at least one 188-byte TS packet");
+          }
+          if (!Number.isSafeInteger(this.startupRepeatCount) || this.startupRepeatCount <= 0) {
+            throw new RangeError("startupRepeatCount must be a positive integer");
+          }
+          if (!Number.isFinite(this.startupRepeatIntervalMs) || this.startupRepeatIntervalMs < 0) {
+            throw new RangeError("startupRepeatIntervalMs must be a finite non-negative number");
+          }
+        }
+        async start(dgramModule) {
+          if (this.destroyed) {
+            throw new Error("NativeUdpSender has been destroyed");
+          }
+          if (this.socket !== void 0 || this.destinationSocket !== void 0) {
+            throw new Error("NativeUdpSender is already started");
+          }
+          let destinationSocket;
+          let socket;
+          try {
+            destinationSocket = narrowToDgramSocketLike(dgramModule.createSocket("udp4"));
+            destinationSocket.on("error", (value) => {
+              this.socketErrors += 1;
+              if (!this.destroyed && this.socketFailure === void 0) {
+                this.socketFailure = toError(value, "Loopback UDP destination reservation error");
+              }
+            });
+            await bindDgramSocket(destinationSocket, 0, "127.0.0.1");
+            const destinationAddress = destinationSocket.address();
+            if (typeof destinationAddress !== "object" || destinationAddress === null || !Number.isInteger(destinationAddress.port)) {
+              throw new Error("Loopback UDP reservation did not report a bound destination port");
+            }
+            socket = narrowToDgramSocketLike(dgramModule.createSocket("udp4"));
+            socket.on("error", (value) => {
+              this.socketErrors += 1;
+              if (!this.destroyed && this.socketFailure === void 0) {
+                this.socketFailure = toError(value, "Loopback UDP sender socket error");
+              }
+            });
+            await bindDgramSocket(socket, 0, "127.0.0.1");
+            if (this.destroyed) {
+              throw new Error("NativeUdpSender was destroyed during initialization");
+            }
+            const address = socket.address();
+            if (typeof address !== "object" || address === null || !Number.isInteger(address.port)) {
+              throw new Error("Loopback UDP sender did not report a bound source port");
+            }
+            this.destinationSocket = destinationSocket;
+            this.socket = socket;
+            this.sourcePort = address.port;
+            this.destinationPort = destinationAddress.port;
+            return this.destinationPort;
+          } catch (error) {
+            if (socket !== void 0) {
+              await closeDgramSocket(socket);
+            }
+            if (destinationSocket !== void 0) {
+              await closeDgramSocket(destinationSocket);
+            }
+            this.sourcePort = 0;
+            this.destinationPort = 0;
+            throw toError(error, "Loopback UDP sender creation failed");
+          }
+        }
+        getDiagnostics() {
+          return {
+            sourcePort: this.sourcePort,
+            destinationPort: this.destinationPort,
+            destinationReserved: this.destinationSocket !== void 0,
+            datagramsSent: this.datagramsSent,
+            bytesSent: this.bytesSent,
+            accessUnitsSent: this.accessUnitsSent,
+            warmupAccessUnits: this.warmupAccessUnits,
+            warmupRepeats: this.warmupRepeats,
+            pendingWarmupDelays: this.pendingWarmupDelays.size,
+            socketErrors: this.socketErrors,
+            sendErrors: this.sendErrors
+          };
+        }
+        async writeAccessUnit(packets) {
+          if (packets.length === 0) {
+            return;
+          }
+          await this.enqueueWrite(async () => {
+            const datagrams = buildDatagrams(packets, this.maxPacketsPerDatagram);
+            await this.performDatagramBurst(datagrams);
+            this.accessUnitsSent += 1;
+          });
+        }
+        async releaseDestinationReservation() {
+          const destinationSocket = this.destinationSocket;
+          if (destinationSocket === void 0) {
+            if (this.destinationPort === 0) {
+              throw new Error("NativeUdpSender is not started");
+            }
+            return;
+          }
+          await closeDgramSocket(destinationSocket);
+          this.destinationSocket = void 0;
+        }
+        async warmupAccessUnit(packets) {
+          if (packets.length === 0) {
+            return;
+          }
+          await this.enqueueWrite(async () => {
+            const datagrams = buildDatagrams(packets, this.maxPacketsPerDatagram);
+            let sentDatagrams = 0;
+            for (let attempt = 0; attempt < this.startupRepeatCount; attempt += 1) {
+              if (this.destroyed) {
+                return;
+              }
+              try {
+                sentDatagrams += await this.performDatagramBurst(datagrams);
+                this.warmupRepeats += 1;
+              } catch (error) {
+                const normalized = toError(error, "Loopback UDP startup warmup failed");
+                if (sentDatagrams === 0) {
+                  if (normalized instanceof NativeUdpPreWriteError) {
+                    throw normalized;
+                  }
+                  throw new NativeUdpPreWriteError(normalized.message);
+                }
+                throw normalized;
+              }
+              if (attempt + 1 < this.startupRepeatCount) {
+                await this.waitWarmupInterval();
+              }
+            }
+            this.warmupAccessUnits += 1;
+          });
+        }
+        get uri() {
+          if (this.destinationPort === 0) {
+            throw new Error("NativeUdpSender is not started");
+          }
+          return `udp://127.0.0.1:${this.destinationPort}`;
+        }
+        destroy() {
+          if (this.teardownComplete) {
+            return Promise.resolve();
+          }
+          if (this.teardown !== void 0) {
+            return this.teardown;
+          }
+          this.destroyed = true;
+          for (const pending of this.pendingWarmupDelays) {
+            clearTimeout(pending.timer);
+            pending.resolve();
+          }
+          this.pendingWarmupDelays.clear();
+          const attempt = this.performTeardown();
+          const promise = attempt.then(() => {
+            this.teardownComplete = true;
+          }, (error) => {
+            if (this.teardown === promise) {
+              this.teardown = void 0;
+            }
+            throw error;
+          });
+          this.teardown = promise;
+          return promise;
+        }
+        async performTeardown() {
+          await this.writeChain;
+          const destinationSocket = this.destinationSocket;
+          if (destinationSocket !== void 0) {
+            await closeDgramSocket(destinationSocket);
+            this.destinationSocket = void 0;
+          }
+          const socket = this.socket;
+          if (socket !== void 0) {
+            await closeDgramSocket(socket);
+            this.socket = void 0;
+          }
+          this.sourcePort = 0;
+          this.destinationPort = 0;
+        }
+        enqueueWrite(operation) {
+          const next = this.writeChain.then(operation);
+          this.writeChain = next.catch(() => void 0);
+          return next;
+        }
+        async performDatagramBurst(datagrams) {
+          if (this.destroyed) {
+            return 0;
+          }
+          const socket = this.socket;
+          if (socket === void 0) {
+            throw new NativeUdpPreWriteError("NativeUdpSender is not started");
+          }
+          const initialSocketFailure = this.getSocketFailure();
+          if (initialSocketFailure !== void 0) {
+            throw new NativeUdpPreWriteError(initialSocketFailure.message);
+          }
+          let sent = 0;
+          for (const datagram of datagrams) {
+            if (this.destroyed) {
+              return sent;
+            }
+            const socketFailure = this.getSocketFailure();
+            if (socketFailure !== void 0) {
+              if (sent === 0) {
+                throw new NativeUdpPreWriteError(socketFailure.message);
+              }
+              throw socketFailure;
+            }
+            try {
+              await sendDatagram(socket, datagram, this.destinationPort, () => this.destroyed);
+              if (this.destroyed) {
+                return sent;
+              }
+              this.datagramsSent += 1;
+              this.bytesSent += datagram.byteLength;
+              sent += 1;
+            } catch (error) {
+              const normalized = toError(error, "Loopback UDP datagram send failed");
+              this.sendErrors += 1;
+              if (this.destroyed) {
+                return sent;
+              }
+              if (sent === 0) {
+                throw new NativeUdpPreWriteError(normalized.message);
+              }
+              throw normalized;
+            }
+          }
+          return sent;
+        }
+        async waitWarmupInterval() {
+          if (this.destroyed || this.startupRepeatIntervalMs === 0) {
+            return;
+          }
+          await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+              this.pendingWarmupDelays.delete(pending);
+              resolve();
+            }, this.startupRepeatIntervalMs);
+            const pending = {
+              timer,
+              resolve: () => {
+                this.pendingWarmupDelays.delete(pending);
+                resolve();
+              }
+            };
+            this.pendingWarmupDelays.add(pending);
+          });
+        }
+        getSocketFailure() {
+          return this.socketFailure;
+        }
+      };
+      exports.NativeUdpSender = NativeUdpSender;
+      async function bindDgramSocket(socket, port, address) {
+        await new Promise((resolve, reject) => {
+          let settled = false;
+          const onError = (value) => {
+            if (settled) {
+              return;
+            }
+            settled = true;
+            reject(toError(value, "Loopback UDP bind failed"));
+          };
+          socket.on("error", onError);
+          try {
+            socket.bind(port, address, () => {
+              if (settled) {
+                return;
+              }
+              settled = true;
+              socket.removeListener("error", onError);
+              resolve();
+            });
+          } catch (error) {
+            if (!settled) {
+              settled = true;
+              socket.removeListener("error", onError);
+              reject(toError(error, "Loopback UDP bind failed"));
+            }
+          }
+        });
+      }
+      async function closeDgramSocket(socket) {
+        await new Promise((resolve) => {
+          try {
+            socket.close(resolve);
+          } catch {
+            resolve();
+          }
+        });
+      }
+      async function sendDatagram(socket, datagram, destinationPort, isDestroyed) {
+        if (isDestroyed()) {
+          return;
+        }
+        await new Promise((resolve, reject) => {
+          try {
+            socket.send(datagram, destinationPort, "127.0.0.1", (error) => {
+              if (error === void 0 || error === null || isDestroyed()) {
+                resolve();
+                return;
+              }
+              reject(toError(error, "Loopback UDP datagram send failed"));
+            });
+          } catch (error) {
+            if (isDestroyed()) {
+              resolve();
+              return;
+            }
+            reject(toError(error, "Loopback UDP datagram send failed"));
+          }
+        });
+      }
+      function buildDatagrams(packets, maxPacketsPerDatagram) {
+        if (packets.length === 0) {
+          return [];
+        }
+        for (const packet of packets) {
+          if (packet.byteLength !== TS_PACKET_SIZE || packet[0] !== 71) {
+            throw new NativeUdpPreWriteError("Native UDP transport accepts only aligned 188-byte TS packets");
+          }
+        }
+        const datagrams = [];
+        for (let start = 0; start < packets.length; start += maxPacketsPerDatagram) {
+          const end = Math.min(start + maxPacketsPerDatagram, packets.length);
+          const datagram = new Uint8Array((end - start) * TS_PACKET_SIZE);
+          let offset = 0;
+          for (let index = start; index < end; index += 1) {
+            const packet = packets[index];
+            if (packet === void 0) {
+              continue;
+            }
+            datagram.set(packet, offset);
+            offset += TS_PACKET_SIZE;
+          }
+          datagrams.push(datagram);
+        }
+        return datagrams;
+      }
+      function narrowToDgramSocketLike(value) {
+        if (typeof value !== "object" || value === null) {
+          throw new TypeError("Expected a dgram socket object");
+        }
+        const on = Reflect.get(value, "on");
+        const once = Reflect.get(value, "once");
+        const removeListener = Reflect.get(value, "removeListener");
+        const bind = Reflect.get(value, "bind");
+        const send = Reflect.get(value, "send");
+        const address = Reflect.get(value, "address");
+        const close = Reflect.get(value, "close");
+        if (typeof on !== "function" || typeof once !== "function" || typeof removeListener !== "function" || typeof bind !== "function" || typeof send !== "function" || typeof address !== "function" || typeof close !== "function") {
+          throw new TypeError("Object does not satisfy the UDP socket contract");
+        }
+        return {
+          on(event, listener) {
+            Reflect.apply(on, value, [event, listener]);
+          },
+          once(event, listener) {
+            Reflect.apply(once, value, [event, listener]);
+          },
+          removeListener(event, listener) {
+            Reflect.apply(removeListener, value, [event, listener]);
+          },
+          bind(port, addressValue, callback) {
+            Reflect.apply(bind, value, [port, addressValue, callback]);
+          },
+          send(buffer, port, addressValue, callback) {
+            Reflect.apply(send, value, [buffer, port, addressValue, callback]);
+          },
+          address() {
+            const result = Reflect.apply(address, value, []);
+            if (typeof result === "string" || result === null) {
+              return result;
+            }
+            if (typeof result === "object") {
+              const port = Reflect.get(result, "port");
+              if (typeof port === "number") {
+                return { port };
+              }
+            }
+            return null;
+          },
+          close(callback) {
+            Reflect.apply(close, value, callback === void 0 ? [] : [callback]);
+          }
+        };
+      }
+      function toError(value, fallback) {
+        return value instanceof Error ? value : new Error(fallback);
+      }
+    }
+  });
+
+  // node_modules/@signageos/brightsign-decoder/dist/decoder/NativeH264Decoder.js
+  var require_NativeH264Decoder = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/decoder/NativeH264Decoder.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.NativeH264Decoder = void 0;
+      var FrameReferenceRegistry_1 = require_FrameReferenceRegistry();
+      var MpegTsMuxer_1 = require_MpegTsMuxer();
+      var NativeHttpServer_1 = require_NativeHttpServer();
+      var PlaybackSession_1 = require_PlaybackSession();
+      var NativeUdpSender_1 = require_NativeUdpSender();
+      var DEFAULT_MAX_QUEUED_ACCESS_UNITS = 16;
+      var DEFAULT_MAX_QUEUED_BYTES = 8 * 1024 * 1024;
+      var NativeH264Decoder = class {
+        constructor(dependencies) {
+          var _a, _b, _c, _d, _e, _f, _g;
+          this.dependencies = dependencies;
+          this.queuedAtMs = [];
+          this.operationChain = Promise.resolve();
+          this.teardownComplete = false;
+          this.queuedAccessUnits = 0;
+          this.queuedBytes = 0;
+          this.highWaterAccessUnits = 0;
+          this.highWaterBytes = 0;
+          this.admittedAccessUnits = 0;
+          this.completedAccessUnits = 0;
+          this.failedAccessUnits = 0;
+          this.capacityRejections = 0;
+          this.destroyed = false;
+          this.httpServerStarted = false;
+          this.httpServerDestroyed = false;
+          this.udpSenderStarted = false;
+          this.udpSenderDestroyed = false;
+          this.playbackStopped = false;
+          this.initialized = false;
+          this.httpServer = (_a = dependencies.httpServer) != null ? _a : new NativeHttpServer_1.NativeHttpServer();
+          this.udpSender = (_b = dependencies.udpSender) != null ? _b : dependencies.dgramModule === void 0 ? void 0 : new NativeUdpSender_1.NativeUdpSender();
+          this.playback = new PlaybackSession_1.PlaybackSession(dependencies.streamBridge);
+          this.muxer = (_c = dependencies.muxer) != null ? _c : new MpegTsMuxer_1.MpegTsMuxer();
+          this.referenceRegistry = (_d = dependencies.refRegistry) != null ? _d : new FrameReferenceRegistry_1.FrameReferenceRegistry();
+          this.maxQueuedAccessUnits = (_e = dependencies.maxQueuedAccessUnits) != null ? _e : DEFAULT_MAX_QUEUED_ACCESS_UNITS;
+          this.maxQueuedBytes = (_f = dependencies.maxQueuedBytes) != null ? _f : DEFAULT_MAX_QUEUED_BYTES;
+          this.now = (_g = dependencies.now) != null ? _g : Date.now;
+          if (!Number.isSafeInteger(this.maxQueuedAccessUnits) || this.maxQueuedAccessUnits <= 0) {
+            throw new RangeError("maxQueuedAccessUnits must be a positive integer");
+          }
+          if (!Number.isSafeInteger(this.maxQueuedBytes) || this.maxQueuedBytes <= 0) {
+            throw new RangeError("maxQueuedBytes must be a positive integer");
+          }
+        }
+        async initialize(options) {
+          if (this.destroyed) {
+            throw new Error("Decoder has been destroyed");
+          }
+          if (this.initialized) {
+            return;
+          }
+          if (this.initialization === void 0) {
+            validateDecoderOptions(options);
+            this.options = options;
+            this.initialization = this.performInitialization();
+          }
+          await this.initialization;
+        }
+        decodeAndRender(frame, signal) {
+          this.assertReady();
+          try {
+            return this.admitFrame(frame, signal);
+          } catch (error) {
+            return Promise.reject(error);
+          }
+        }
+        async decodeAndRenderRef(reference, signal) {
+          this.assertReady();
+          const frame = this.referenceRegistry.claim(reference);
+          let operation;
+          try {
+            operation = this.admitFrame({
+              data: frame.data,
+              frameType: frame.frameType,
+              timestamp: frame.timestamp
+            }, signal);
+          } catch (error) {
+            this.referenceRegistry.restoreClaim(reference);
+            throw error;
+          }
+          this.referenceRegistry.release(reference);
+          await operation;
+        }
+        async flush(signal) {
+          this.assertReady();
+          await waitForPromise(this.operationChain, signal);
+          if (this.pendingError !== void 0) {
+            const error = this.pendingError;
+            this.pendingError = void 0;
+            throw error;
+          }
+        }
+        getDiagnostics() {
+          var _a;
+          const oldest = this.queuedAtMs[0];
+          return {
+            protocol: this.getConfiguredProtocol(),
+            queuedAccessUnits: this.queuedAccessUnits,
+            queuedBytes: this.queuedBytes,
+            highWaterAccessUnits: this.highWaterAccessUnits,
+            highWaterBytes: this.highWaterBytes,
+            oldestQueuedAgeMs: oldest === void 0 ? 0 : Math.max(0, this.now() - oldest),
+            admittedAccessUnits: this.admittedAccessUnits,
+            completedAccessUnits: this.completedAccessUnits,
+            failedAccessUnits: this.failedAccessUnits,
+            capacityRejections: this.capacityRejections,
+            pendingError: this.pendingError !== void 0,
+            httpTransport: this.httpServer.getDiagnostics(),
+            udpTransport: (_a = this.udpSender) == null ? void 0 : _a.getDiagnostics()
+          };
+        }
+        destroy() {
+          if (this.teardownComplete) {
+            return Promise.resolve();
+          }
+          if (this.teardown !== void 0) {
+            return this.teardown;
+          }
+          this.destroyed = true;
+          const attempt = this.performTeardown();
+          const promise = attempt.then(() => {
+            this.teardownComplete = true;
+          }, (error) => {
+            if (this.teardown === promise) {
+              this.teardown = void 0;
+            }
+            throw error;
+          });
+          this.teardown = promise;
+          return promise;
+        }
+        async performTeardown() {
+          let firstError;
+          if (this.initialization !== void 0) {
+            try {
+              await this.initialization;
+            } catch {
+            }
+          }
+          if (this.httpServerStarted && !this.httpServerDestroyed) {
+            try {
+              await this.httpServer.destroy();
+              this.httpServerDestroyed = true;
+            } catch (error) {
+              firstError = firstError != null ? firstError : toError(error, "HTTP transport teardown failed");
+            }
+          }
+          if (this.udpSenderStarted && !this.udpSenderDestroyed && this.udpSender !== void 0) {
+            try {
+              await this.udpSender.destroy();
+              this.udpSenderDestroyed = true;
+            } catch (error) {
+              firstError = firstError != null ? firstError : toError(error, "UDP transport teardown failed");
+            }
+          }
+          try {
+            await this.operationChain;
+          } catch (error) {
+            firstError = firstError != null ? firstError : toError(error, "Decoder queue teardown failed");
+          }
+          if (!this.playbackStopped) {
+            try {
+              await this.playback.stop();
+              this.playbackStopped = true;
+            } catch (error) {
+              firstError = firstError != null ? firstError : toError(error, "Native playback teardown failed");
+            }
+          }
+          this.initialized = false;
+          if (firstError !== void 0) {
+            throw firstError;
+          }
+        }
+        async performInitialization() {
+          try {
+            const options = this.options;
+            if (options === void 0) {
+              throw new Error("Decoder options are unavailable");
+            }
+            if (this.getConfiguredProtocol() === "UDP") {
+              const dgramModule = this.dependencies.dgramModule;
+              if (dgramModule === void 0 || this.udpSender === void 0) {
+                throw new Error("UDP playback requires a dgram module");
+              }
+              await this.udpSender.start(dgramModule);
+              this.udpSenderStarted = true;
+            } else {
+              await this.httpServer.start(this.dependencies.httpModule);
+              this.httpServerStarted = true;
+            }
+            if (this.destroyed) {
+              throw new Error("Decoder was destroyed during initialization");
+            }
+            if (this.getConfiguredProtocol() === "HTTP") {
+              await this.startPlayback(this.httpServer.uri, "HTTP");
+            }
+            if (this.destroyed) {
+              throw new Error("Decoder was destroyed during initialization");
+            }
+            this.initialized = true;
+          } catch (error) {
+            let result = toError(error, "Decoder initialization failed");
+            try {
+              if (this.getConfiguredProtocol() === "HTTP" && !this.httpServerDestroyed) {
+                await this.httpServer.destroy();
+                this.httpServerDestroyed = true;
+              }
+            } catch (cleanupError) {
+              result = new Error(`${result.message}; HTTP cleanup failed: ${toError(cleanupError, "unknown error").message}`);
+            }
+            try {
+              if (this.getConfiguredProtocol() === "UDP" && !this.udpSenderDestroyed && this.udpSender !== void 0) {
+                await this.udpSender.destroy();
+                this.udpSenderDestroyed = true;
+              }
+            } catch (cleanupError) {
+              result = new Error(`${result.message}; UDP cleanup failed: ${toError(cleanupError, "unknown error").message}`);
+            }
+            try {
+              await this.playback.stop();
+            } catch (cleanupError) {
+              result = new Error(`${result.message}; playback cleanup failed: ${toError(cleanupError, "unknown error").message}`);
+            }
+            throw result;
+          }
+        }
+        assertReady() {
+          if (this.destroyed) {
+            throw new Error("Decoder has been destroyed");
+          }
+          if (!this.initialized) {
+            throw new Error("Decoder is not initialized");
+          }
+        }
+        /**
+         * Validate and synchronously copy a frame into the bounded queue. Once this
+         * method returns, decoder ownership has transferred even if the returned wait
+         * later rejects because transport failed or the caller aborted its wait.
+         */
+        admitFrame(frame, signal) {
+          if ((signal == null ? void 0 : signal.aborted) === true) {
+            throw abortError();
+          }
+          if (frame.data.byteLength === 0) {
+            throw new RangeError("Cannot decode an empty access unit");
+          }
+          if (this.queuedAccessUnits >= this.maxQueuedAccessUnits || this.queuedBytes + frame.data.byteLength > this.maxQueuedBytes) {
+            this.capacityRejections += 1;
+            throw new Error("Decoder remux queue capacity exceeded");
+          }
+          const ownedData = frame.data.slice();
+          const ownedTimestamp = { hi: frame.timestamp.hi, lo: frame.timestamp.lo };
+          this.queuedAccessUnits += 1;
+          this.queuedBytes += ownedData.byteLength;
+          this.admittedAccessUnits += 1;
+          this.highWaterAccessUnits = Math.max(this.highWaterAccessUnits, this.queuedAccessUnits);
+          this.highWaterBytes = Math.max(this.highWaterBytes, this.queuedBytes);
+          this.queuedAtMs.push(this.now());
+          const operation = this.operationChain.then(async () => {
+            const prepared = this.muxer.prepare(ownedData, ownedTimestamp);
+            try {
+              await this.deliverAccessUnit(prepared.packets);
+              prepared.commit();
+            } catch (error) {
+              if (isPreWriteError(error)) {
+                prepared.rejectBeforeWrite();
+              } else {
+                prepared.commit();
+              }
+              throw error;
+            }
+          });
+          this.operationChain = operation.then(() => {
+            this.completedAccessUnits += 1;
+            this.releaseQueueCapacity(ownedData.byteLength);
+          }, (error) => {
+            this.failedAccessUnits += 1;
+            this.releaseQueueCapacity(ownedData.byteLength);
+            const normalized = toError(error, "Native decoder operation failed");
+            if (this.pendingError === void 0) {
+              this.pendingError = normalized;
+            }
+          });
+          return waitForPromise(operation, signal);
+        }
+        releaseQueueCapacity(byteLength) {
+          this.queuedAtMs.shift();
+          this.queuedAccessUnits -= 1;
+          this.queuedBytes -= byteLength;
+        }
+        getConfiguredProtocol() {
+          var _a, _b;
+          return (_b = (_a = this.options) == null ? void 0 : _a.streamProtocol) != null ? _b : "HTTP";
+        }
+        async startPlayback(uri, protocol) {
+          var _a, _b;
+          const options = this.options;
+          if (options === void 0) {
+            throw new Error("Decoder options are unavailable");
+          }
+          await this.playback.start(uri, {
+            x: (_a = options.x) != null ? _a : 0,
+            y: (_b = options.y) != null ? _b : 0,
+            width: options.width,
+            height: options.height
+          }, protocol, options.streamOptions);
+        }
+        async deliverAccessUnit(packets) {
+          if (this.getConfiguredProtocol() === "UDP") {
+            await this.deliverUdpAccessUnit(packets);
+            return;
+          }
+          await this.httpServer.writeAccessUnit(packets);
+        }
+        async deliverUdpAccessUnit(packets) {
+          if (packets.length === 0) {
+            return;
+          }
+          const udpSender = this.udpSender;
+          if (udpSender === void 0) {
+            throw new NativeUdpSender_1.NativeUdpPreWriteError("UDP transport is unavailable");
+          }
+          if (!this.playback.isPlaying) {
+            await this.startUdpPlayback(udpSender, packets);
+            return;
+          }
+          await udpSender.writeAccessUnit(packets);
+        }
+        async startUdpPlayback(udpSender, packets) {
+          let playbackStarted = false;
+          try {
+            await udpSender.releaseDestinationReservation();
+            await this.startPlayback(udpSender.uri, "UDP");
+            playbackStarted = true;
+            await udpSender.warmupAccessUnit(packets);
+          } catch (error) {
+            const preWriteFailure = error instanceof NativeUdpSender_1.NativeUdpPreWriteError || !playbackStarted;
+            let result = toError(error, "UDP startup failed");
+            if (playbackStarted) {
+              try {
+                await this.playback.stop();
+              } catch (cleanupError) {
+                result = new Error(`${result.message}; UDP playback cleanup failed: ${toError(cleanupError, "unknown error").message}`);
+              }
+            }
+            if (preWriteFailure) {
+              throw new NativeUdpSender_1.NativeUdpPreWriteError(result.message);
+            }
+            throw result;
+          }
+        }
+      };
+      exports.NativeH264Decoder = NativeH264Decoder;
+      function validateDecoderOptions(options) {
+        if (!Number.isFinite(options.width) || options.width <= 0 || !Number.isFinite(options.height) || options.height <= 0) {
+          throw new RangeError("Decoder width and height must be finite positive numbers");
+        }
+        if (options.x !== void 0 && !Number.isFinite(options.x)) {
+          throw new RangeError("Decoder x coordinate must be finite");
+        }
+        if (options.y !== void 0 && !Number.isFinite(options.y)) {
+          throw new RangeError("Decoder y coordinate must be finite");
+        }
+      }
+      function waitForPromise(promise, signal) {
+        if (signal === void 0) {
+          return promise;
+        }
+        if (signal.aborted) {
+          return Promise.reject(abortError());
+        }
+        return new Promise((resolve, reject) => {
+          let settled = false;
+          const finish = (error) => {
+            if (settled) {
+              return;
+            }
+            settled = true;
+            signal.removeEventListener("abort", onAbort);
+            if (error === void 0) {
+              resolve();
+            } else {
+              reject(error);
+            }
+          };
+          const onAbort = () => finish(abortError());
+          signal.addEventListener("abort", onAbort, { once: true });
+          promise.then(() => finish(), (error) => finish(toError(error, "Flush failed")));
+        });
+      }
+      function abortError() {
+        const error = new Error("The operation was aborted");
+        error.name = "AbortError";
+        return error;
+      }
+      function toError(value, fallback) {
+        return value instanceof Error ? value : new Error(fallback);
+      }
+      function isPreWriteError(error) {
+        return error instanceof NativeHttpServer_1.NativeHttpPreWriteError || error instanceof NativeUdpSender_1.NativeUdpPreWriteError;
+      }
+    }
+  });
+
+  // node_modules/@signageos/brightsign-decoder/dist/decoder/WebCodecsH264Decoder.js
+  var require_WebCodecsH264Decoder = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/decoder/WebCodecsH264Decoder.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.WebCodecsH264Decoder = void 0;
+      var WebCodecsH264Decoder = class {
+        async initialize(_options) {
+          throw new Error("WebCodecs H.264 decoder is not yet implemented. Measured 40.2 ms median decode latency missed the performance target.");
+        }
+        async decodeAndRender(_frame, _signal) {
+          throw new Error("WebCodecs decoder is not initialized");
+        }
+        async decodeAndRenderRef(_reference, _signal) {
+          throw new Error("WebCodecs decoder is not initialized");
+        }
+        async flush(_signal) {
+        }
+        async destroy() {
+        }
+      };
+      exports.WebCodecsH264Decoder = WebCodecsH264Decoder;
+    }
+  });
+
+  // node_modules/@signageos/brightsign-decoder/dist/runtime/support.js
+  var require_support = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/runtime/support.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.detectCapabilities = detectCapabilities;
+      exports.isBrightSignDecoderSupported = isBrightSignDecoderSupported2;
+      function detectCapabilities() {
+        const hasNativeNode = probeParentNode();
+        const hasStreamBridge = probeStreamBridge();
+        const native = hasNativeNode && hasStreamBridge;
+        const reasons = [];
+        if (!hasNativeNode) {
+          reasons.push("no parent-realm Node http module");
+        }
+        if (!hasStreamBridge) {
+          reasons.push("no signageOS stream bridge");
+        }
+        if (native) {
+          reasons.push("native player available");
+        }
+        return {
+          native,
+          webcodecs: false,
+          reason: reasons.join("; ") || "unsupported runtime"
+        };
+      }
+      function safeGet(target, key) {
+        try {
+          if (typeof target !== "object" || target === null) {
+            return void 0;
+          }
+          return Reflect.get(target, key);
+        } catch {
+          return void 0;
+        }
+      }
+      function probeParentNode() {
+        try {
+          if (typeof globalThis === "undefined") {
+            return false;
+          }
+          const localRequire = safeGet(globalThis, "require");
+          if (probeHttpModule(localRequire, globalThis)) {
+            return true;
+          }
+          const parentWindow = safeGet(globalThis, "parent");
+          return probeHttpModule(safeGet(parentWindow, "require"), parentWindow);
+        } catch {
+          return false;
+        }
+      }
+      function probeHttpModule(requireFunction, receiver) {
+        if (typeof requireFunction !== "function") {
+          return false;
+        }
+        const http = Reflect.apply(requireFunction, receiver, ["http"]);
+        if (typeof http !== "object" || http === null) {
+          return false;
+        }
+        return typeof Reflect.get(http, "createServer") === "function";
+      }
+      function probeStreamBridge() {
+        try {
+          if (typeof globalThis === "undefined") {
+            return false;
+          }
+          const sos = safeGet(globalThis, "sos");
+          if (typeof sos !== "object" || sos === null) {
+            return false;
+          }
+          const stream = Reflect.get(sos, "stream");
+          if (typeof stream !== "object" || stream === null) {
+            return false;
+          }
+          return typeof Reflect.get(stream, "play") === "function" && typeof Reflect.get(stream, "stop") === "function";
+        } catch {
+          return false;
+        }
+      }
+      function isBrightSignDecoderSupported2() {
+        const caps = detectCapabilities();
+        return caps.native;
+      }
+    }
+  });
+
+  // node_modules/@signageos/brightsign-decoder/dist/runtime/parentNode.js
+  var require_parentNode = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/runtime/parentNode.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.discoverParentRequire = discoverParentRequire;
+      exports.validateNetModule = validateNetModule;
+      exports.validateHttpModule = validateHttpModule;
+      exports.validateDgramModule = validateDgramModule;
+      function safeGet(target, key) {
+        try {
+          if (typeof target !== "object" || target === null) {
+            return void 0;
+          }
+          return Reflect.get(target, key);
+        } catch {
+          return void 0;
+        }
+      }
+      function wrapRequire(fn, receiver) {
+        return (moduleName) => {
+          if (typeof fn !== "function") {
+            return void 0;
+          }
+          return Reflect.apply(fn, receiver, [moduleName]);
+        };
+      }
+      function discoverParentRequire() {
+        if (typeof globalThis === "undefined") {
+          return void 0;
+        }
+        const localRequire = safeGet(globalThis, "require");
+        if (typeof localRequire === "function") {
+          return wrapRequire(localRequire, globalThis);
+        }
+        const parentWindow = safeGet(globalThis, "parent");
+        if (parentWindow !== void 0 && parentWindow !== null) {
+          const parentRequire = safeGet(parentWindow, "require");
+          if (typeof parentRequire === "function") {
+            return wrapRequire(parentRequire, parentWindow);
+          }
+        }
+        const topWindow = safeGet(globalThis, "top");
+        if (topWindow !== void 0 && topWindow !== null && topWindow !== parentWindow) {
+          const topRequire = safeGet(topWindow, "require");
+          if (typeof topRequire === "function") {
+            return wrapRequire(topRequire, topWindow);
+          }
+        }
+        return void 0;
+      }
+      function validateNetModule(mod) {
+        if (typeof mod !== "object" || mod === null) {
+          return false;
+        }
+        const cc = Reflect.get(mod, "createConnection");
+        return typeof cc === "function";
+      }
+      function validateHttpModule(mod) {
+        if (typeof mod !== "object" || mod === null) {
+          return false;
+        }
+        const cs = Reflect.get(mod, "createServer");
+        return typeof cs === "function";
+      }
+      function validateDgramModule(mod) {
+        if (typeof mod !== "object" || mod === null) {
+          return false;
+        }
+        const createSocket = Reflect.get(mod, "createSocket");
+        return typeof createSocket === "function";
+      }
+    }
+  });
+
+  // node_modules/@signageos/brightsign-decoder/dist/index.js
+  var require_dist = __commonJS({
+    "node_modules/@signageos/brightsign-decoder/dist/index.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.validateHttpModule = exports.validateNetModule = exports.validateDgramModule = exports.discoverParentRequire = exports.detectCapabilities = exports.isBrightSignDecoderSupported = exports.NativeHttpServer = exports.PlaybackSession = exports.WebCodecsH264Decoder = exports.NativeH264Decoder = exports.parseNalUnits = exports.NalType = exports.inspectAccessUnit = exports.getNalType = exports.findStartCodes = exports.u64Sub = exports.u64ToBigInt = exports.TransportClock = exports.verifyCrc32 = exports.computeCrc32 = exports.MpegTsMuxer = exports.TCP = exports.ConnectionRegistry = exports.FrameReferenceRegistry = exports.FrameCollector = exports.PacketParser = exports.FrameType = exports.ConnectionState = void 0;
+      exports.createBrightSignDecoder = createBrightSignDecoder2;
+      exports.createBrightSignTCP = createBrightSignTCP2;
+      var contracts_1 = require_contracts();
+      Object.defineProperty(exports, "ConnectionState", { enumerable: true, get: function() {
+        return contracts_1.ConnectionState;
+      } });
+      Object.defineProperty(exports, "FrameType", { enumerable: true, get: function() {
+        return contracts_1.FrameType;
+      } });
+      var PacketParser_1 = require_PacketParser();
+      Object.defineProperty(exports, "PacketParser", { enumerable: true, get: function() {
+        return PacketParser_1.PacketParser;
+      } });
+      var FrameCollector_1 = require_FrameCollector();
+      Object.defineProperty(exports, "FrameCollector", { enumerable: true, get: function() {
+        return FrameCollector_1.FrameCollector;
+      } });
+      var FrameReferenceRegistry_1 = require_FrameReferenceRegistry();
+      Object.defineProperty(exports, "FrameReferenceRegistry", { enumerable: true, get: function() {
+        return FrameReferenceRegistry_1.FrameReferenceRegistry;
+      } });
+      var ConnectionRegistry_1 = require_ConnectionRegistry();
+      Object.defineProperty(exports, "ConnectionRegistry", { enumerable: true, get: function() {
+        return ConnectionRegistry_1.ConnectionRegistry;
+      } });
+      var TCP_1 = require_TCP();
+      Object.defineProperty(exports, "TCP", { enumerable: true, get: function() {
+        return TCP_1.TCP;
+      } });
+      var MpegTsMuxer_1 = require_MpegTsMuxer();
+      Object.defineProperty(exports, "MpegTsMuxer", { enumerable: true, get: function() {
+        return MpegTsMuxer_1.MpegTsMuxer;
+      } });
+      Object.defineProperty(exports, "computeCrc32", { enumerable: true, get: function() {
+        return MpegTsMuxer_1.computeCrc32;
+      } });
+      Object.defineProperty(exports, "verifyCrc32", { enumerable: true, get: function() {
+        return MpegTsMuxer_1.verifyCrc32;
+      } });
+      var TransportClock_1 = require_TransportClock();
+      Object.defineProperty(exports, "TransportClock", { enumerable: true, get: function() {
+        return TransportClock_1.TransportClock;
+      } });
+      Object.defineProperty(exports, "u64ToBigInt", { enumerable: true, get: function() {
+        return TransportClock_1.u64ToBigInt;
+      } });
+      Object.defineProperty(exports, "u64Sub", { enumerable: true, get: function() {
+        return TransportClock_1.u64Sub;
+      } });
+      var AnnexB_1 = require_AnnexB();
+      Object.defineProperty(exports, "findStartCodes", { enumerable: true, get: function() {
+        return AnnexB_1.findStartCodes;
+      } });
+      Object.defineProperty(exports, "getNalType", { enumerable: true, get: function() {
+        return AnnexB_1.getNalType;
+      } });
+      Object.defineProperty(exports, "inspectAccessUnit", { enumerable: true, get: function() {
+        return AnnexB_1.inspectAccessUnit;
+      } });
+      Object.defineProperty(exports, "NalType", { enumerable: true, get: function() {
+        return AnnexB_1.NalType;
+      } });
+      Object.defineProperty(exports, "parseNalUnits", { enumerable: true, get: function() {
+        return AnnexB_1.parseNalUnits;
+      } });
+      var NativeH264Decoder_1 = require_NativeH264Decoder();
+      Object.defineProperty(exports, "NativeH264Decoder", { enumerable: true, get: function() {
+        return NativeH264Decoder_1.NativeH264Decoder;
+      } });
+      var WebCodecsH264Decoder_1 = require_WebCodecsH264Decoder();
+      Object.defineProperty(exports, "WebCodecsH264Decoder", { enumerable: true, get: function() {
+        return WebCodecsH264Decoder_1.WebCodecsH264Decoder;
+      } });
+      var PlaybackSession_1 = require_PlaybackSession();
+      Object.defineProperty(exports, "PlaybackSession", { enumerable: true, get: function() {
+        return PlaybackSession_1.PlaybackSession;
+      } });
+      var NativeHttpServer_1 = require_NativeHttpServer();
+      Object.defineProperty(exports, "NativeHttpServer", { enumerable: true, get: function() {
+        return NativeHttpServer_1.NativeHttpServer;
+      } });
+      var support_1 = require_support();
+      Object.defineProperty(exports, "isBrightSignDecoderSupported", { enumerable: true, get: function() {
+        return support_1.isBrightSignDecoderSupported;
+      } });
+      Object.defineProperty(exports, "detectCapabilities", { enumerable: true, get: function() {
+        return support_1.detectCapabilities;
+      } });
+      var parentNode_1 = require_parentNode();
+      Object.defineProperty(exports, "discoverParentRequire", { enumerable: true, get: function() {
+        return parentNode_1.discoverParentRequire;
+      } });
+      Object.defineProperty(exports, "validateDgramModule", { enumerable: true, get: function() {
+        return parentNode_1.validateDgramModule;
+      } });
+      Object.defineProperty(exports, "validateNetModule", { enumerable: true, get: function() {
+        return parentNode_1.validateNetModule;
+      } });
+      Object.defineProperty(exports, "validateHttpModule", { enumerable: true, get: function() {
+        return parentNode_1.validateHttpModule;
+      } });
+      var parentNode_2 = require_parentNode();
+      var NativeH264Decoder_2 = require_NativeH264Decoder();
+      var TCP_2 = require_TCP();
+      var FrameReferenceRegistry_2 = require_FrameReferenceRegistry();
+      var discoveredStreamBridges = /* @__PURE__ */ new WeakMap();
+      function createBrightSignDecoder2(deps) {
+        var _a;
+        const resolved = deps != null ? deps : {};
+        let dgramModule = resolved.dgramModule;
+        let httpModule = resolved.httpModule;
+        let streamBridge = resolved.streamBridge;
+        const refRegistry = (_a = resolved.refRegistry) != null ? _a : new FrameReferenceRegistry_2.FrameReferenceRegistry();
+        if (dgramModule === void 0) {
+          const parentRequire = (0, parentNode_2.discoverParentRequire)();
+          if (parentRequire !== void 0) {
+            try {
+              const dgram = parentRequire("dgram");
+              if ((0, parentNode_2.validateDgramModule)(dgram) && typeof dgram === "object" && dgram !== null) {
+                const createSocket = Reflect.get(dgram, "createSocket");
+                if (typeof createSocket === "function") {
+                  dgramModule = {
+                    createSocket(type) {
+                      return Reflect.apply(createSocket, dgram, [type]);
+                    }
+                  };
+                }
+              }
+            } catch {
+            }
+          }
+        }
+        if (httpModule === void 0) {
+          const parentRequire = (0, parentNode_2.discoverParentRequire)();
+          if (parentRequire !== void 0) {
+            const http = parentRequire("http");
+            if ((0, parentNode_2.validateHttpModule)(http) && typeof http === "object" && http !== null) {
+              const createServer = Reflect.get(http, "createServer");
+              if (typeof createServer === "function") {
+                httpModule = {
+                  createServer(handler) {
+                    return Reflect.apply(createServer, http, [handler]);
+                  }
+                };
+              }
+            }
+          }
+        }
+        if (httpModule === void 0) {
+          throw new Error("No http module available \u2014 provide httpModule or ensure parent-realm Node is accessible");
+        }
+        if (streamBridge === void 0) {
+          streamBridge = discoverStreamBridge();
+        }
+        if (streamBridge === void 0) {
+          throw new Error("No stream bridge available \u2014 provide streamBridge or ensure sos.stream is accessible");
+        }
+        const fullDeps = {
+          dgramModule,
+          httpModule,
+          streamBridge,
+          refRegistry
+        };
+        return new NativeH264Decoder_2.NativeH264Decoder(fullDeps);
+      }
+      function createBrightSignTCP2(options) {
+        const resolved = options != null ? options : {};
+        let net = resolved.net;
+        if (net === void 0) {
+          const parentRequire = (0, parentNode_2.discoverParentRequire)();
+          if (parentRequire !== void 0) {
+            const netMod = parentRequire("net");
+            if ((0, parentNode_2.validateNetModule)(netMod) && typeof netMod === "object" && netMod !== null) {
+              const createConnection = Reflect.get(netMod, "createConnection");
+              if (typeof createConnection === "function") {
+                net = {
+                  createConnection(connOpts, callback) {
+                    return (0, TCP_2.narrowSocketLike)(Reflect.apply(createConnection, netMod, [connOpts, callback]));
+                  }
+                };
+              }
+            }
+          }
+        }
+        if (net === void 0) {
+          throw new Error("No net module available \u2014 provide net or ensure parent-realm Node is accessible");
+        }
+        const tcpOptions = {
+          net,
+          maxPacketSize: resolved.maxPacketSize,
+          maxQueuedBytes: resolved.maxQueuedBytes,
+          maxQueuedPackets: resolved.maxQueuedPackets,
+          referenceRegistry: resolved.refRegistry
+        };
+        return new TCP_2.TCP(tcpOptions);
+      }
+      function discoverStreamBridge() {
+        try {
+          if (typeof globalThis === "undefined") {
+            return void 0;
+          }
+          const sos = Reflect.get(globalThis, "sos");
+          if (typeof sos !== "object" || sos === null) {
+            return void 0;
+          }
+          const stream = Reflect.get(sos, "stream");
+          if (typeof stream !== "object" || stream === null) {
+            return void 0;
+          }
+          const cachedBridge = discoveredStreamBridges.get(stream);
+          if (cachedBridge !== void 0) {
+            return cachedBridge;
+          }
+          const play = Reflect.get(stream, "play");
+          const stop = Reflect.get(stream, "stop");
+          const onError = Reflect.get(stream, "onError");
+          if (typeof play !== "function" || typeof stop !== "function") {
+            return void 0;
+          }
+          const bridge = {
+            play(uri, x, y, width, height, opts) {
+              return Promise.resolve(Reflect.apply(play, stream, [uri, x, y, width, height, opts]));
+            },
+            stop(uri, x, y, width, height) {
+              return Promise.resolve(Reflect.apply(stop, stream, [uri, x, y, width, height]));
+            }
+          };
+          if (typeof onError !== "function") {
+            discoveredStreamBridges.set(stream, bridge);
+            return bridge;
+          }
+          const bridgeWithErrorListener = {
+            ...bridge,
+            onError(listener) {
+              Reflect.apply(onError, stream, [listener]);
+            }
+          };
+          discoveredStreamBridges.set(stream, bridgeWithErrorListener);
+          return bridgeWithErrorListener;
+        } catch {
+          return void 0;
+        }
+      }
+    }
+  });
+
   // node_modules/@signageos/nacl-decoder/dist/NaClDecoder/messageListeners.js
   var require_messageListeners = __commonJS({
     "node_modules/@signageos/nacl-decoder/dist/NaClDecoder/messageListeners.js"(exports) {
@@ -17206,6 +21192,37 @@
     }
   });
 
+  // node_modules/@signageos/nacl-decoder/dist/NaClDecoder/geometry.js
+  var require_geometry = __commonJS({
+    "node_modules/@signageos/nacl-decoder/dist/NaClDecoder/geometry.js"(exports) {
+      "use strict";
+      var __assign = exports && exports.__assign || function() {
+        __assign = Object.assign || function(t) {
+          for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
+          }
+          return t;
+        };
+        return __assign.apply(this, arguments);
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.normalizeGeometry = normalizeGeometry2;
+      function normalizeGeometry2(geometry) {
+        if (!Number.isFinite(geometry.x) || !Number.isFinite(geometry.y) || !Number.isFinite(geometry.width) || !Number.isFinite(geometry.height)) {
+          throw new RangeError("NaCl module geometry values must be finite.");
+        }
+        var width = Math.floor(geometry.width);
+        var height = Math.floor(geometry.height);
+        if (width <= 0 || height <= 0) {
+          throw new RangeError("NaCl module geometry width and height must be positive.");
+        }
+        return __assign(__assign({}, geometry), { width, height });
+      }
+    }
+  });
+
   // node_modules/@signageos/nacl-decoder/dist/NaClDecoder/module.js
   var require_module = __commonJS({
     "node_modules/@signageos/nacl-decoder/dist/NaClDecoder/module.js"(exports) {
@@ -17213,14 +21230,17 @@
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.createNaClModule = createNaClModule;
       exports.removeNaClModule = removeNaClModule;
+      var geometry_1 = require_geometry();
       function handleLoad(event) {
         console.log("nacl load", event);
       }
       function handleCrash(event) {
         console.log("nacl crash", event);
       }
-      function createNaClModule(handleMessage) {
-        var _a, _b;
+      var messageListeners = /* @__PURE__ */ new WeakMap();
+      function createNaClModule(handleMessage, geometry) {
+        var _a, _b, _c, _d;
+        var normalizedGeometry = geometry ? (0, geometry_1.normalizeGeometry)(geometry) : void 0;
         var listenerEl = document.createElement("div");
         listenerEl.setAttribute("id", "listener");
         listenerEl.addEventListener("message", handleMessage, true);
@@ -17230,22 +21250,34 @@
         var baseHref = (_b = (_a = document.getElementsByTagName("base")[0]) === null || _a === void 0 ? void 0 : _a.href) !== null && _b !== void 0 ? _b : location.href;
         var nmpPath = new URL("nacl-decoder.nmf", baseHref).href;
         var naclModuleEl = document.createElement("embed");
-        naclModuleEl.setAttribute("width", "".concat(window.screen.width));
-        naclModuleEl.setAttribute("height", "".concat(window.screen.height));
+        var width = (_c = normalizedGeometry === null || normalizedGeometry === void 0 ? void 0 : normalizedGeometry.width) !== null && _c !== void 0 ? _c : window.screen.width;
+        var height = (_d = normalizedGeometry === null || normalizedGeometry === void 0 ? void 0 : normalizedGeometry.height) !== null && _d !== void 0 ? _d : window.screen.height;
+        naclModuleEl.setAttribute("width", "".concat(width));
+        naclModuleEl.setAttribute("height", "".concat(height));
+        if (normalizedGeometry) {
+          naclModuleEl.style.position = "absolute";
+          naclModuleEl.style.left = "".concat(normalizedGeometry.x, "px");
+          naclModuleEl.style.top = "".concat(normalizedGeometry.y, "px");
+        }
         naclModuleEl.setAttribute("src", nmpPath);
         naclModuleEl.setAttribute("type", "application/x-nacl");
         naclModuleEl.setAttribute("id", "nacl_module");
         listenerEl.appendChild(naclModuleEl);
+        messageListeners.set(naclModuleEl, handleMessage);
         return naclModuleEl;
       }
       function removeNaClModule(naclModuleEl) {
         var listenerEl = naclModuleEl.parentElement;
         if (listenerEl) {
-          listenerEl.removeEventListener("message", handleLoad, true);
+          var handleMessage = messageListeners.get(naclModuleEl);
+          if (handleMessage) {
+            listenerEl.removeEventListener("message", handleMessage, true);
+          }
           listenerEl.removeEventListener("load", handleLoad, true);
           listenerEl.removeEventListener("crash", handleCrash, true);
           listenerEl.remove();
         }
+        messageListeners.delete(naclModuleEl);
         naclModuleEl.remove();
       }
     }
@@ -17969,14 +22001,17 @@
       var NaClDecoder = (
         /** @class */
         function() {
-          function NaClDecoder2(messageSender, naclModuleEl) {
+          function NaClDecoder2(messageSender, naclModuleEl, onDestroy) {
             this.messageSender = messageSender;
             this.naclModuleEl = naclModuleEl;
+            this.onDestroy = onDestroy;
           }
           NaClDecoder2.prototype.destroy = function() {
             return __awaiter(this, void 0, void 0, function() {
-              return __generator(this, function(_a) {
+              var _a;
+              return __generator(this, function(_b) {
                 (0, module_1.removeNaClModule)(this.naclModuleEl);
+                (_a = this.onDestroy) === null || _a === void 0 ? void 0 : _a.call(this);
                 return [
                   2
                   /*return*/
@@ -18262,9 +22297,28 @@
   });
 
   // node_modules/@signageos/nacl-decoder/dist/index.js
-  var require_dist = __commonJS({
+  var require_dist2 = __commonJS({
     "node_modules/@signageos/nacl-decoder/dist/index.js"(exports) {
       "use strict";
+      var __extends = exports && exports.__extends || /* @__PURE__ */ function() {
+        var extendStatics = function(d, b) {
+          extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+            d2.__proto__ = b2;
+          } || function(d2, b2) {
+            for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+          };
+          return extendStatics(d, b);
+        };
+        return function(d, b) {
+          if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+          extendStatics(d, b);
+          function __() {
+            this.constructor = d;
+          }
+          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+        };
+      }();
       var __assign = exports && exports.__assign || function() {
         __assign = Object.assign || function(t) {
           for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -18276,6 +22330,102 @@
         };
         return __assign.apply(this, arguments);
       };
+      var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+        function adopt(value) {
+          return value instanceof P ? value : new P(function(resolve) {
+            resolve(value);
+          });
+        }
+        return new (P || (P = Promise))(function(resolve, reject) {
+          function fulfilled(value) {
+            try {
+              step(generator.next(value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function rejected(value) {
+            try {
+              step(generator["throw"](value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+      };
+      var __generator = exports && exports.__generator || function(thisArg, body) {
+        var _ = { label: 0, sent: function() {
+          if (t[0] & 1) throw t[1];
+          return t[1];
+        }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+        return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+          return this;
+        }), g;
+        function verb(n) {
+          return function(v) {
+            return step([n, v]);
+          };
+        }
+        function step(op) {
+          if (f) throw new TypeError("Generator is already executing.");
+          while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+              case 0:
+              case 1:
+                t = op;
+                break;
+              case 4:
+                _.label++;
+                return { value: op[1], done: false };
+              case 5:
+                _.label++;
+                y = op[1];
+                op = [0];
+                continue;
+              case 7:
+                op = _.ops.pop();
+                _.trys.pop();
+                continue;
+              default:
+                if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                  _ = 0;
+                  continue;
+                }
+                if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                  _.label = op[1];
+                  break;
+                }
+                if (op[0] === 6 && _.label < t[1]) {
+                  _.label = t[1];
+                  t = op;
+                  break;
+                }
+                if (t && _.label < t[2]) {
+                  _.label = t[2];
+                  _.ops.push(op);
+                  break;
+                }
+                if (t[2]) _.ops.pop();
+                _.trys.pop();
+                continue;
+            }
+            op = body.call(thisArg, _);
+          } catch (e) {
+            op = [6, e];
+            y = 0;
+          } finally {
+            f = t = 0;
+          }
+          if (op[0] & 5) throw op[1];
+          return { value: op[0] ? op[1] : void 0, done: true };
+        }
+      };
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.NaClTCPStreamConnection = exports.NaClTCPStream = exports.NaClTCPPacketConnection = exports.NaClTCPPacket = exports.NaClFrameCollector = exports.VideoProfile = exports.ResultStatus = exports.HWAcceleration = exports.NaClDecoder = void 0;
       exports.isNaClSupported = isNaClSupported3;
@@ -18318,6 +22468,29 @@
       var DEFAULT_OPTIONS = {
         timeoutMs: 1e3
       };
+      var RuntimeOwnedNaClDecoder = (
+        /** @class */
+        function(_super) {
+          __extends(RuntimeOwnedNaClDecoder2, _super);
+          function RuntimeOwnedNaClDecoder2(messageSender, naclModuleEl, releaseRuntime) {
+            var _this = _super.call(this, messageSender, naclModuleEl) || this;
+            _this.releaseRuntime = releaseRuntime;
+            return _this;
+          }
+          RuntimeOwnedNaClDecoder2.prototype.destroy = function() {
+            return __awaiter(this, void 0, void 0, function() {
+              return __generator(this, function(_a) {
+                this.releaseRuntime();
+                return [
+                  2
+                  /*return*/
+                ];
+              });
+            });
+          };
+          return RuntimeOwnedNaClDecoder2;
+        }(naclDecoder_1.NaClDecoder)
+      );
       var naclRuntime = null;
       function isNaClSupported3() {
         return (
@@ -18330,26 +22503,48 @@
         if (!isNaClSupported3()) {
           throw new Error("NaCl is not supported in this browser.");
         }
-        var runtime = getNaClRuntime(requiredOptions.timeoutMs);
-        return new naclDecoder_1.NaClDecoder(runtime.messageSender, runtime.naclModuleEl);
+        var _a = acquireNaClRuntime(requiredOptions.timeoutMs, options === null || options === void 0 ? void 0 : options.geometry), runtime = _a.runtime, release = _a.release;
+        return new RuntimeOwnedNaClDecoder(runtime.messageSender, runtime.naclModuleEl, release);
       }
       function createNaClTCP2(options) {
         var decoder = createNaClDecoder2(options);
-        return decoder.createTCP();
+        return __assign(__assign({}, decoder.createTCP()), { destroy: function() {
+          return decoder.destroy();
+        } });
       }
-      function getNaClRuntime(timeoutMs) {
-        if (naclRuntime) {
-          return naclRuntime;
-        }
-        var messageListeners = (0, messageListeners_1.createMessageListeners)();
-        var messageReceiver = new messageReceiver_1.MessageReceiver(messageListeners);
-        var naclModuleEl = (0, module_1.createNaClModule)(messageReceiver.handleMessage.bind(messageReceiver));
-        var messageSender = new messageSender_1.MessageSender(naclModuleEl, messageListeners, timeoutMs);
-        naclRuntime = {
-          messageSender,
-          naclModuleEl
+      function acquireNaClRuntime(timeoutMs, geometry) {
+        var runtime = naclRuntime;
+        if (!runtime) {
+          var messageListeners = (0, messageListeners_1.createMessageListeners)();
+          var messageReceiver = new messageReceiver_1.MessageReceiver(messageListeners);
+          var naclModuleEl = (0, module_1.createNaClModule)(messageReceiver.handleMessage.bind(messageReceiver), geometry);
+          var messageSender = new messageSender_1.MessageSender(naclModuleEl, messageListeners, timeoutMs);
+          runtime = {
+            messageSender,
+            naclModuleEl,
+            ownerCount: 0
+          };
+          naclRuntime = runtime;
+        }
+        runtime.ownerCount += 1;
+        var released = false;
+        return {
+          runtime,
+          release: function() {
+            if (released) {
+              return;
+            }
+            released = true;
+            runtime.ownerCount -= 1;
+            if (runtime.ownerCount > 0) {
+              return;
+            }
+            (0, module_1.removeNaClModule)(runtime.naclModuleEl);
+            if (naclRuntime === runtime) {
+              naclRuntime = null;
+            }
+          }
         };
-        return naclRuntime;
       }
     }
   });
@@ -18376,6 +22571,36 @@
     }
   });
 
+  // node_modules/@signageos/samsung-wasm-decoder/dist/WasmDecoder/videoElementGeometry.js
+  var require_videoElementGeometry = __commonJS({
+    "node_modules/@signageos/samsung-wasm-decoder/dist/WasmDecoder/videoElementGeometry.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.normalizeVideoElementGeometry = normalizeVideoElementGeometry;
+      function normalizeDimension(name, value) {
+        var normalizedValue = Math.floor(value);
+        if (!Number.isFinite(value) || normalizedValue <= 0) {
+          throw new RangeError("".concat(name, " must be a finite positive number."));
+        }
+        return normalizedValue;
+      }
+      function normalizeCoordinate(name, value) {
+        if (!Number.isFinite(value)) {
+          throw new RangeError("".concat(name, " must be a finite number."));
+        }
+        return value;
+      }
+      function normalizeVideoElementGeometry(geometry) {
+        return {
+          x: normalizeCoordinate("x", geometry.x),
+          y: normalizeCoordinate("y", geometry.y),
+          width: normalizeDimension("width", geometry.width),
+          height: normalizeDimension("height", geometry.height)
+        };
+      }
+    }
+  });
+
   // node_modules/@signageos/samsung-wasm-decoder/dist/dom/script.js
   var require_script = __commonJS({
     "node_modules/@signageos/samsung-wasm-decoder/dist/dom/script.js"(exports) {
@@ -19660,6 +23885,7 @@
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.SamsungWasmDecoder = void 0;
       var videoDecoder_1 = require_videoDecoder2();
+      var videoElementGeometry_1 = require_videoElementGeometry();
       var wasmLoader_1 = require_wasmLoader();
       var wasmTCP_1 = require_wasmTCP();
       function detectKeyFrameAnnexB(bytes) {
@@ -19690,19 +23916,25 @@
         }
         return false;
       }
-      function ensureVideoElement(videoElementId) {
+      function ensureVideoElement(videoElementId, geometry) {
+        var normalizedGeometry = (0, videoElementGeometry_1.normalizeVideoElementGeometry)(geometry !== null && geometry !== void 0 ? geometry : {
+          x: 0,
+          y: 0,
+          width: screen.width,
+          height: screen.height
+        });
         var el = document.getElementById(videoElementId);
         if (!el) {
           el = document.createElement("video");
           el.id = videoElementId;
-          el.style.position = "absolute";
-          el.style.top = "0";
-          el.style.left = "0";
-          el.style.width = "1920px";
-          el.style.height = "1080px";
           el.style.backgroundColor = "#000";
           document.body.appendChild(el);
         }
+        el.style.position = "absolute";
+        el.style.top = "".concat(normalizedGeometry.y, "px");
+        el.style.left = "".concat(normalizedGeometry.x, "px");
+        el.style.width = "".concat(normalizedGeometry.width, "px");
+        el.style.height = "".concat(normalizedGeometry.height, "px");
         el.autoplay = true;
         el.muted = true;
         el.playsInline = true;
@@ -19711,14 +23943,14 @@
       var SamsungWasmDecoder2 = (
         /** @class */
         function() {
-          function SamsungWasmDecoder3(videoElementId) {
+          function SamsungWasmDecoder3(videoElementId, geometry) {
             this.videoElementId = videoElementId;
             this.initialized = false;
             this.destroyed = false;
             this.decoderHandle = 0;
             this.ptsSeconds = 0;
             this.frameDurationSeconds = 0;
-            this.videoElement = ensureVideoElement(videoElementId);
+            this.videoElement = ensureVideoElement(videoElementId, geometry);
           }
           SamsungWasmDecoder3.prototype.destroy = function() {
             return __awaiter(this, void 0, void 0, function() {
@@ -19947,7 +24179,7 @@
   });
 
   // node_modules/@signageos/samsung-wasm-decoder/dist/index.js
-  var require_dist2 = __commonJS({
+  var require_dist3 = __commonJS({
     "node_modules/@signageos/samsung-wasm-decoder/dist/index.js"(exports) {
       "use strict";
       var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
@@ -20091,7 +24323,7 @@
                 return [4, (0, wasmLoader_1.loadWasmModule)()];
               case 1:
                 _a.sent();
-                return [2, new wasmDecoder_1.SamsungWasmDecoder(options.videoElementId)];
+                return [2, new wasmDecoder_1.SamsungWasmDecoder(options.videoElementId, options.geometry)];
             }
           });
         });
@@ -20222,14 +24454,14 @@
   async function injectScript(url) {
     return new Promise((resolve, reject) => {
       const scriptEl = document.createElement("script");
-      scriptEl.src = url;
-      document.head.appendChild(scriptEl);
-      scriptEl.onerror = async function(error) {
-        reject(error);
+      scriptEl.onerror = function() {
+        reject(new Error(`Failed to load script: ${url}`));
       };
-      scriptEl.onload = async function() {
+      scriptEl.onload = function() {
         resolve();
       };
+      scriptEl.src = url;
+      document.head.appendChild(scriptEl);
     });
   }
 
@@ -20240,7 +24472,7 @@
     options: {}
   };
   async function initBrowserFS() {
-    BrowserFS.install(window);
+    installBrowserFSGlobals();
     await new Promise((resolve, reject) => {
       BrowserFS.configure(config, (error) => {
         if (error) {
@@ -20254,6 +24486,73 @@
     shim(fs);
     return fs;
   }
+  var installedBrowserFSRequire;
+  function installBrowserFSGlobals() {
+    const browserFSProcess = BrowserFS.BFSRequire("process");
+    if (!window.process) {
+      Object.defineProperty(window, "process", {
+        configurable: true,
+        enumerable: true,
+        value: {},
+        writable: true
+      });
+    }
+    const processPolyfills = /* @__PURE__ */ new Map([
+      ["browser", true],
+      ["env", {}],
+      ["getuid", browserFSProcess.getuid.bind(browserFSProcess)],
+      ["getgid", browserFSProcess.getgid.bind(browserFSProcess)],
+      ["geteuid", browserFSProcess.getuid.bind(browserFSProcess)],
+      ["getegid", browserFSProcess.getgid.bind(browserFSProcess)],
+      ["getgroups", () => {
+        throw createNotImplementedError();
+      }],
+      ["pid", browserFSProcess.pid],
+      ["ppid", -1],
+      ["umask", browserFSProcess.umask.bind(browserFSProcess)],
+      ["cwd", browserFSProcess.cwd.bind(browserFSProcess)],
+      ["chdir", browserFSProcess.chdir.bind(browserFSProcess)]
+    ]);
+    for (const [property, value] of processPolyfills) {
+      if (Reflect.get(window.process, property) === void 0) {
+        Object.defineProperty(window.process, property, {
+          configurable: true,
+          value,
+          writable: true
+        });
+      }
+    }
+    if (!installedBrowserFSRequire) {
+      const previousRequire = window.require;
+      installedBrowserFSRequire = (moduleName) => {
+        const browserFSModule = BrowserFS.BFSRequire(moduleName);
+        if (browserFSModule) {
+          return browserFSModule;
+        }
+        if (previousRequire) {
+          return previousRequire(moduleName);
+        }
+        throw new Error(`Cannot find module '${moduleName}'`);
+      };
+    }
+    Object.defineProperty(window, "Buffer", {
+      configurable: true,
+      enumerable: true,
+      value: BrowserFS.BFSRequire("buffer").Buffer,
+      writable: true
+    });
+    Object.defineProperty(window, "require", {
+      configurable: true,
+      enumerable: true,
+      value: installedBrowserFSRequire,
+      writable: true
+    });
+  }
+  function createNotImplementedError() {
+    const error = new Error("not implemented");
+    Object.defineProperty(error, "code", { value: "ENOSYS" });
+    return error;
+  }
   function getStringFlagsByNumber(fs, origFlags) {
     if ((origFlags & (fs.constants.O_APPEND | fs.constants.O_CREAT)) !== 0) {
       return "a";
@@ -20445,11 +24744,82 @@
     }
   }
 
+  // screen/brightsign.ts
+  var import_brightsign_decoder = __toESM(require_dist());
+  var referenceRegistry;
+  var streamErrorListenerRegistered = false;
+  var teardownRegistered = false;
+  function isBrightSignRuntimeAvailable() {
+    return (0, import_brightsign_decoder.isBrightSignDecoderSupported)();
+  }
+  function initBrightSignTCP() {
+    registerStreamErrorListener();
+    if (window.brightSignTCP) {
+      return true;
+    }
+    try {
+      const registry = getReferenceRegistry();
+      window.brightSignTCP = (0, import_brightsign_decoder.createBrightSignTCP)({
+        refRegistry: registry,
+        maxPacketSize: 65535
+      });
+      registerTeardown();
+      return true;
+    } catch (error) {
+      console.log("BrightSign TCP is not available", error);
+      return false;
+    }
+  }
+  function registerStreamErrorListener() {
+    if (streamErrorListenerRegistered) {
+      return;
+    }
+    const sos = Reflect.get(globalThis, "sos");
+    if (typeof sos !== "object" || sos === null) {
+      return;
+    }
+    const stream = Reflect.get(sos, "stream");
+    if (typeof stream !== "object" || stream === null) {
+      return;
+    }
+    const onError = Reflect.get(stream, "onError");
+    if (typeof onError !== "function") {
+      return;
+    }
+    Reflect.apply(onError, stream, [
+      (event) => console.error("BrightSign native stream error", event)
+    ]);
+    streamErrorListenerRegistered = true;
+  }
+  function getReferenceRegistry() {
+    if (!referenceRegistry) {
+      referenceRegistry = new import_brightsign_decoder.FrameReferenceRegistry();
+      window.brightSignReleaseFrameReference = (reference) => {
+        referenceRegistry == null ? void 0 : referenceRegistry.release(reference);
+      };
+    }
+    return referenceRegistry;
+  }
+  function registerTeardown() {
+    if (teardownRegistered) {
+      return;
+    }
+    teardownRegistered = true;
+    window.addEventListener("unload", () => {
+      const decoder = window.brightSignDecoder;
+      const tcp = window.brightSignTCP;
+      window.brightSignDecoder = void 0;
+      window.brightSignTCP = void 0;
+      void (decoder == null ? void 0 : decoder.destroy());
+      void (tcp == null ? void 0 : tcp.destroy());
+    });
+  }
+
   // screen/nacltcp.ts
-  var import_nacl_decoder = __toESM(require_dist());
-  async function initNaClTCP() {
+  var import_nacl_decoder = __toESM(require_dist2());
+  async function initNaClTCP(options) {
     if ((0, import_nacl_decoder.isNaClSupported)()) {
-      const { tcpPacket, tcpStream } = (0, import_nacl_decoder.createNaClTCP)();
+      const { tcpPacket, tcpStream } = (0, import_nacl_decoder.createNaClTCP)({ geometry: options == null ? void 0 : options.geometry });
       if (!window.naclTCPPacket) {
         window.naclTCPPacket = tcpPacket;
       }
@@ -20460,7 +24830,7 @@
   }
 
   // screen/samsungwasmtcp.ts
-  var import_samsung_wasm_decoder = __toESM(require_dist2());
+  var import_samsung_wasm_decoder = __toESM(require_dist3());
   async function initSamsungWasmTCP() {
     if ((0, import_samsung_wasm_decoder.isSamsungWasmSupported)()) {
       const { tcpPacket, tcpStream } = await (0, import_samsung_wasm_decoder.createSamsungWasmTCP)();
@@ -20474,8 +24844,9 @@
   }
 
   // daemon/plain.ts
-  var DAEMON_JS_URL = "supra-client-daemon.js?v=0.0.1";
+  var DAEMON_JS_URL = "supra-client-daemon.js?v=1.0.0-mzbrightsigndecoder.477";
   async function startPlainDaemon() {
+    initBrightSignTCP();
     await initNaClTCP();
     await initSamsungWasmTCP();
     const fs = await initBrowserFS();
@@ -20487,8 +24858,9 @@
   }
 
   // daemon/wasm.ts
-  var DAEMON_WASM_URL = "supra-client-daemon.wasm?v=0.0.1";
+  var DAEMON_WASM_URL = "supra-client-daemon.wasm?v=1.0.0-mzbrightsigndecoder.477";
   async function startWasmDaemon() {
+    initBrightSignTCP();
     await initNaClTCP();
     await initSamsungWasmTCP();
     await initGoEnvironment();
@@ -20508,10 +24880,10 @@
   }
 
   // screen/nacldecoder.ts
-  var import_nacl_decoder2 = __toESM(require_dist());
+  var import_nacl_decoder2 = __toESM(require_dist2());
 
   // screen/samsungwasmdecoder.ts
-  var import_samsung_wasm_decoder2 = __toESM(require_dist2());
+  var import_samsung_wasm_decoder2 = __toESM(require_dist3());
   var import_videoDecoder = __toESM(require_videoDecoder2());
 
   // screen/shared.ts
@@ -20519,10 +24891,13 @@
 
   // sdk.ts
   async function startDaemon(options) {
+    if ((options == null ? void 0 : options.requireBrightSignRuntime) && !isBrightSignRuntimeAvailable()) {
+      throw new Error("BrightSign TCP requires a native controller with Node.js capabilities");
+    }
     if (shouldUsePlainJS(options)) {
-      startPlainDaemon();
+      await startPlainDaemon();
     } else {
-      startWasmDaemon();
+      await startWasmDaemon();
     }
   }
   function shouldUsePlainJS(options) {