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

package/daemon.js

@@ -19501,13 +19501,13 @@
           }
         }
         /** 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;
         }
         /**
@@ -19535,6 +19535,438 @@
     }
   });
 
+  // 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) {
@@ -19545,11 +19977,12 @@
       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();
@@ -19563,16 +19996,20 @@
           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");
           }
@@ -19629,8 +20066,10 @@
           }
         }
         getDiagnostics() {
+          var _a;
           const oldest = this.queuedAtMs[0];
           return {
+            protocol: this.getConfiguredProtocol(),
             queuedAccessUnits: this.queuedAccessUnits,
             queuedBytes: this.queuedBytes,
             highWaterAccessUnits: this.highWaterAccessUnits,
@@ -19641,7 +20080,8 @@
             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() {
@@ -19672,7 +20112,7 @@
             } catch {
             }
           }
-          if (!this.httpServerDestroyed) {
+          if (this.httpServerStarted && !this.httpServerDestroyed) {
             try {
               await this.httpServer.destroy();
               this.httpServerDestroyed = true;
@@ -19680,6 +20120,14 @@
               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) {
@@ -19699,22 +20147,28 @@
           }
         }
         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");
             }
@@ -19722,14 +20176,23 @@
           } 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}`);
             }
@@ -19771,10 +20234,10 @@
           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();
@@ -19800,6 +20263,67 @@
           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) {
@@ -19847,6 +20371,9 @@
       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;
+      }
     }
   });
 
@@ -19917,23 +20444,26 @@
           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") {
@@ -19967,6 +20497,7 @@
       exports.discoverParentRequire = discoverParentRequire;
       exports.validateNetModule = validateNetModule;
       exports.validateHttpModule = validateHttpModule;
+      exports.validateDgramModule = validateDgramModule;
       function safeGet(target, key) {
         try {
           if (typeof target !== "object" || target === null) {
@@ -19989,6 +20520,10 @@
         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");
@@ -20019,6 +20554,13 @@
         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";
+      }
     }
   });
 
@@ -20027,7 +20569,7 @@
     "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();
@@ -20120,6 +20662,9 @@
       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;
       } });
@@ -20134,9 +20679,29 @@
       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) {
@@ -20163,6 +20728,7 @@
           throw new Error("No stream bridge available \u2014 provide streamBridge or ensure sos.stream is accessible");
         }
         const fullDeps = {
+          dgramModule,
           httpModule,
           streamBridge,
           refRegistry
@@ -24278,7 +24844,7 @@
   }
 
   // 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.477";
   async function startPlainDaemon() {
     initBrightSignTCP();
     await initNaClTCP();
@@ -24292,7 +24858,7 @@
   }
 
   // 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.477";
   async function startWasmDaemon() {
     initBrightSignTCP();
     await initNaClTCP();