@supraio/client-daemon-js 1.0.0-mzbrightsigndecoder.473 → 1.0.0-mzbrightsigndecoder.478

package/sdk.js

@@ -19505,13 +19505,13 @@ var require_PlaybackSession = __commonJS({
         }
       }
       /** Start native playback at the given URI and coordinates. */
-      async start(uri, coords, options = {}) {
+      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: "HTTP", ...options });
+        await this.bridge.play(uri, coords.x, coords.y, coords.width, coords.height, { protocol, ...options });
         this.playing = true;
       }
       /**
@@ -19539,6 +19539,438 @@ var require_PlaybackSession = __commonJS({
   }
 });
 
+// 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) {
@@ -19549,11 +19981,12 @@ var require_NativeH264Decoder = __commonJS({
     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;
+        var _a, _b, _c, _d, _e, _f, _g;
         this.dependencies = dependencies;
         this.queuedAtMs = [];
         this.operationChain = Promise.resolve();
@@ -19567,16 +20000,20 @@ var require_NativeH264Decoder = __commonJS({
         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 = (_b = dependencies.muxer) != null ? _b : new MpegTsMuxer_1.MpegTsMuxer();
-        this.referenceRegistry = (_c = dependencies.refRegistry) != null ? _c : new FrameReferenceRegistry_1.FrameReferenceRegistry();
-        this.maxQueuedAccessUnits = (_d = dependencies.maxQueuedAccessUnits) != null ? _d : DEFAULT_MAX_QUEUED_ACCESS_UNITS;
-        this.maxQueuedBytes = (_e = dependencies.maxQueuedBytes) != null ? _e : DEFAULT_MAX_QUEUED_BYTES;
-        this.now = (_f = dependencies.now) != null ? _f : Date.now;
+        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");
         }
@@ -19633,8 +20070,10 @@ var require_NativeH264Decoder = __commonJS({
         }
       }
       getDiagnostics() {
+        var _a;
         const oldest = this.queuedAtMs[0];
         return {
+          protocol: this.getConfiguredProtocol(),
           queuedAccessUnits: this.queuedAccessUnits,
           queuedBytes: this.queuedBytes,
           highWaterAccessUnits: this.highWaterAccessUnits,
@@ -19645,7 +20084,8 @@ var require_NativeH264Decoder = __commonJS({
           failedAccessUnits: this.failedAccessUnits,
           capacityRejections: this.capacityRejections,
           pendingError: this.pendingError !== void 0,
-          httpTransport: this.httpServer.getDiagnostics()
+          httpTransport: this.httpServer.getDiagnostics(),
+          udpTransport: (_a = this.udpSender) == null ? void 0 : _a.getDiagnostics()
         };
       }
       destroy() {
@@ -19676,7 +20116,7 @@ var require_NativeH264Decoder = __commonJS({
           } catch {
           }
         }
-        if (!this.httpServerDestroyed) {
+        if (this.httpServerStarted && !this.httpServerDestroyed) {
           try {
             await this.httpServer.destroy();
             this.httpServerDestroyed = true;
@@ -19684,6 +20124,14 @@ var require_NativeH264Decoder = __commonJS({
             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) {
@@ -19703,22 +20151,28 @@ var require_NativeH264Decoder = __commonJS({
         }
       }
       async performInitialization() {
-        var _a, _b;
         try {
           const options = this.options;
           if (options === void 0) {
             throw new Error("Decoder options are unavailable");
           }
-          await this.httpServer.start(this.dependencies.httpModule);
+          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");
           }
-          await this.playback.start(this.httpServer.uri, {
-            x: (_a = options.x) != null ? _a : 0,
-            y: (_b = options.y) != null ? _b : 0,
-            width: options.width,
-            height: options.height
-          }, options.streamOptions);
+          if (this.getConfiguredProtocol() === "HTTP") {
+            await this.startPlayback(this.httpServer.uri, "HTTP");
+          }
           if (this.destroyed) {
             throw new Error("Decoder was destroyed during initialization");
           }
@@ -19726,14 +20180,23 @@ var require_NativeH264Decoder = __commonJS({
         } catch (error) {
           let result = toError(error, "Decoder initialization failed");
           try {
-            await this.httpServer.destroy();
-            this.httpServerDestroyed = true;
+            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();
-            this.playbackStopped = true;
           } catch (cleanupError) {
             result = new Error(`${result.message}; playback cleanup failed: ${toError(cleanupError, "unknown error").message}`);
           }
@@ -19775,10 +20238,10 @@ var require_NativeH264Decoder = __commonJS({
         const operation = this.operationChain.then(async () => {
           const prepared = this.muxer.prepare(ownedData, ownedTimestamp);
           try {
-            await this.httpServer.writeAccessUnit(prepared.packets);
+            await this.deliverAccessUnit(prepared.packets);
             prepared.commit();
           } catch (error) {
-            if (error instanceof NativeHttpServer_1.NativeHttpPreWriteError) {
+            if (isPreWriteError(error)) {
               prepared.rejectBeforeWrite();
             } else {
               prepared.commit();
@@ -19804,6 +20267,67 @@ var require_NativeH264Decoder = __commonJS({
         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) {
@@ -19851,6 +20375,9 @@ var require_NativeH264Decoder = __commonJS({
     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;
+    }
   }
 });
 
@@ -19921,23 +20448,26 @@ var require_support = __commonJS({
         if (typeof globalThis === "undefined") {
           return false;
         }
-        const parentWindow = safeGet(globalThis, "parent");
-        if (parentWindow === void 0 || parentWindow === null) {
-          return false;
-        }
-        const parentRequire = safeGet(parentWindow, "require");
-        if (typeof parentRequire !== "function") {
-          return false;
-        }
-        const http = Reflect.apply(parentRequire, parentWindow, ["http"]);
-        if (typeof http !== "object" || http === null) {
-          return false;
+        const localRequire = safeGet(globalThis, "require");
+        if (probeHttpModule(localRequire, globalThis)) {
+          return true;
         }
-        return typeof Reflect.get(http, "createServer") === "function";
+        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") {
@@ -19971,6 +20501,7 @@ var require_parentNode = __commonJS({
     exports.discoverParentRequire = discoverParentRequire;
     exports.validateNetModule = validateNetModule;
     exports.validateHttpModule = validateHttpModule;
+    exports.validateDgramModule = validateDgramModule;
     function safeGet(target, key) {
       try {
         if (typeof target !== "object" || target === null) {
@@ -19993,6 +20524,10 @@ var require_parentNode = __commonJS({
       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");
@@ -20023,6 +20558,13 @@ var require_parentNode = __commonJS({
       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";
+    }
   }
 });
 
@@ -20031,7 +20573,7 @@ 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.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.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();
@@ -20124,6 +20666,9 @@ var require_dist = __commonJS({
     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;
     } });
@@ -20138,9 +20683,29 @@ var require_dist = __commonJS({
     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) {
@@ -20167,6 +20732,7 @@ var require_dist = __commonJS({
         throw new Error("No stream bridge available \u2014 provide streamBridge or ensure sos.stream is accessible");
       }
       const fullDeps = {
+        dgramModule,
         httpModule,
         streamBridge,
         refRegistry
@@ -24202,6 +24768,7 @@ function isBrightSignRuntimeAvailable() {
 function initBrightSignTCP() {
   registerStreamErrorListener();
   if (window.brightSignTCP) {
+    console.log("BrightSign TCP already initialized");
     return true;
   }
   try {
@@ -24211,6 +24778,7 @@ function initBrightSignTCP() {
       maxPacketSize: 65535
     });
     registerTeardown();
+    console.log("BrightSign TCP initialized");
     return true;
   } catch (error) {
     console.log("BrightSign TCP is not available", error);
@@ -24218,11 +24786,14 @@ function initBrightSignTCP() {
   }
 }
 async function initBrightSignDecoder(options) {
-  var _a;
+  var _a, _b, _c;
   if (window.brightSignDecoder) {
+    console.log("BrightSign decoder already initialized");
     return true;
   }
-  if (!(0, import_brightsign_decoder.isBrightSignDecoderSupported)()) {
+  const runtimeAvailable = (0, import_brightsign_decoder.isBrightSignDecoderSupported)();
+  console.log("BrightSign decoder runtime availability", runtimeAvailable);
+  if (!runtimeAvailable) {
     return false;
   }
   try {
@@ -24232,15 +24803,22 @@ async function initBrightSignDecoder(options) {
       width: window.innerWidth,
       height: window.innerHeight
     };
+    console.log("BrightSign decoder initialization begin", {
+      geometry,
+      streamProtocol: (_b = options.brightSignDecoderStreamProtocol) != null ? _b : "default",
+      streamOptions: (_c = options.brightSignStreamOptions) != null ? _c : null
+    });
     const decoder = (0, import_brightsign_decoder.createBrightSignDecoder)({
       refRegistry: getReferenceRegistry()
     });
     await decoder.initialize({
       ...geometry,
+      streamProtocol: options.brightSignDecoderStreamProtocol,
       streamOptions: options.brightSignStreamOptions ? { brightSign: options.brightSignStreamOptions } : void 0
     });
     window.brightSignDecoder = decoder;
     registerTeardown();
+    console.log("BrightSign decoder initialization complete");
     return true;
   } catch (error) {
     console.error("Failed to initialize BrightSign decoder", error);
@@ -24267,6 +24845,7 @@ function registerStreamErrorListener() {
     (event) => console.error("BrightSign native stream error", event)
   ]);
   streamErrorListenerRegistered = true;
+  console.log("BrightSign native stream error listener registered");
 }
 function getReferenceRegistry() {
   if (!referenceRegistry) {
@@ -24283,12 +24862,14 @@ function registerTeardown() {
   }
   teardownRegistered = true;
   window.addEventListener("unload", () => {
+    console.log("BrightSign teardown begin");
     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());
+    console.log("BrightSign teardown dispatched");
   });
 }
 
@@ -24321,7 +24902,7 @@ async function initSamsungWasmTCP() {
 }
 
 // daemon/plain.ts
-var DAEMON_JS_URL = "supra-client-daemon.js?v=1.0.0-mzbrightsigndecoder.473";
+var DAEMON_JS_URL = "supra-client-daemon.js?v=1.0.0-mzbrightsigndecoder.478";
 async function startPlainDaemon() {
   initBrightSignTCP();
   await initNaClTCP();
@@ -24335,7 +24916,7 @@ async function startPlainDaemon() {
 }
 
 // daemon/wasm.ts
-var DAEMON_WASM_URL = "supra-client-daemon.wasm?v=1.0.0-mzbrightsigndecoder.473";
+var DAEMON_WASM_URL = "supra-client-daemon.wasm?v=1.0.0-mzbrightsigndecoder.478";
 async function startWasmDaemon() {
   initBrightSignTCP();
   await initNaClTCP();
@@ -24760,15 +25341,41 @@ function getGoArgv2(binFile, options) {
 }
 
 // screen/plain.ts
-var SCREEN_JS_URL = "supra-client-screen.js?v=1.0.0-mzbrightsigndecoder.473";
+var SCREEN_JS_URL = "supra-client-screen.js?v=1.0.0-mzbrightsigndecoder.478";
 async function startPlainScreen(options) {
+  var _a, _b, _c, _d;
   console.log("[Supra screen plain] initialization begin");
   options = options != null ? options : parseQueryOptions();
   options = { ...options, geometry: normalizeGeometry(options.geometry) };
+  console.log("[Supra screen plain] resolved start options", {
+    screenID: options.screenID,
+    screenDriver: options.screenDriver,
+    metadataDriver: options.metadataDriver,
+    secure: options.secure,
+    interactive: options.interactive,
+    netInWorker: options.netInWorker === true,
+    forceScreenSize: (_a = options.forceScreenSize) != null ? _a : null,
+    geometry: (_b = options.geometry) != null ? _b : null,
+    brightSignDecoderStreamProtocol: (_c = options.brightSignDecoderStreamProtocol) != null ? _c : "default",
+    hasBrightSignStreamOptions: options.brightSignStreamOptions !== void 0,
+    encodingPreferences: (_d = options.encodingPreferences) != null ? _d : null
+  });
   initNaCLDecoder(options);
   initWorkerFrameConnection(options.netInWorker === true);
-  initBrightSignTCP();
-  await initBrightSignDecoder(options);
+  const brightSignTCPReady = initBrightSignTCP();
+  console.log("[Supra screen plain] BrightSign TCP ready", brightSignTCPReady);
+  const brightSignDecoderReady = await initBrightSignDecoder(options);
+  console.log("[Supra screen plain] BrightSign decoder ready", brightSignDecoderReady);
+  if (brightSignDecoderReady) {
+    const sos = Reflect.get(globalThis, "sos");
+    if (typeof sos === "object" && sos !== null) {
+      const config2 = Reflect.get(sos, "config");
+      if (typeof config2 === "object" && config2 !== null) {
+        Reflect.set(config2, "stream", false);
+        console.log("[Supra screen plain] disabled sos.stream fallback for native decoder");
+      }
+    }
+  }
   await initNaClTCP(options);
   await initSamsungWasmTCP();
   await initSamsungWasmDecoder(options);
@@ -24776,13 +25383,17 @@ async function startPlainScreen(options) {
   window.fs = fs;
   process.argv = ["go", ...getGoArgv2(SCREEN_JS_URL, options)];
   Object.assign(process.env, getGoEnv());
+  console.log("[Supra screen plain] Go argv prepared", {
+    argvLength: process.argv.length,
+    screenID: options.screenID
+  });
   console.log("[Supra screen plain] script injection begin");
   await injectScript(SCREEN_JS_URL);
   console.log("[Supra screen plain] script injection complete; waiting for close");
   await new Promise((resolve) => {
     const interval = setInterval(() => {
-      var _a;
-      if (((_a = window.__supra) == null ? void 0 : _a.screenStopCompleted) === true) {
+      var _a2;
+      if (((_a2 = window.__supra) == null ? void 0 : _a2.screenStopCompleted) === true) {
         clearInterval(interval);
         console.log("[Supra screen plain] lifecycle complete");
         resolve();
@@ -24792,7 +25403,7 @@ async function startPlainScreen(options) {
 }
 
 // screen/h264decoder.ts
-var H264_DECODER_URL = "h264decoder.js?v=1.0.0-mzbrightsigndecoder.473";
+var H264_DECODER_URL = "h264decoder.js?v=1.0.0-mzbrightsigndecoder.478";
 async function initH264Decoder() {
   if (window.VideoDecoder !== void 0) {
     return void 0;
@@ -24831,7 +25442,7 @@ function getProperty(value, property) {
 }
 
 // screen/wasm.ts
-var SCREEN_WASM_URL = "supra-client-screen.wasm?v=1.0.0-mzbrightsigndecoder.473";
+var SCREEN_WASM_URL = "supra-client-screen.wasm?v=1.0.0-mzbrightsigndecoder.478";
 async function initializePhase(name, initialize) {
   const startedAt = Date.now();
   console.log(`[Supra screen WASM] ${name} begin`);