@supraio/client-daemon-js 1.0.0-mzbrightsigndecoder.489 → 1.0.0-mzbrightsigndecoder.491

package/sdk.js

@@ -26293,6 +26293,22 @@ async function initGoEnvironment() {
 var import_brightsign_decoder = __toESM(require_dist());
 var BRIGHTSIGN_TCP_DRIVER = "brightsign_tcp";
 var teardownRegistered = false;
+var backendInitialization;
+var ownedDecoder;
+var ownedTCP;
+var unloading = false;
+var teardownPromise;
+function resolvePlaybackProtocol(streamProtocol) {
+  switch (streamProtocol) {
+    case void 0:
+    case "udp":
+      return "udp";
+    case "http":
+      return "http";
+    default:
+      throw new RangeError(`Unsupported BrightSign playback protocol: ${streamProtocol}`);
+  }
+}
 function isBrightSignRuntimeAvailable() {
   return (0, import_brightsign_decoder.detectCapabilities)().native;
 }
@@ -26301,7 +26317,8 @@ function initBrightSignTCP() {
     return true;
   }
   try {
-    window.brightSignTCP = (0, import_brightsign_decoder.createBrightSignTCP)();
+    ownedTCP = (0, import_brightsign_decoder.createBrightSignTCP)();
+    window.brightSignTCP = ownedTCP;
     registerTeardown();
     return true;
   } catch (error) {
@@ -26310,16 +26327,64 @@ function initBrightSignTCP() {
   }
 }
 async function initBrightSignBackend(options) {
-  var _a;
   if (options.screenDriver !== BRIGHTSIGN_TCP_DRIVER) {
     return false;
   }
+  if (unloading) {
+    console.error("BrightSign backend cannot initialize during unload");
+    return false;
+  }
+  let streamProtocol;
+  try {
+    streamProtocol = resolvePlaybackProtocol(options.streamProtocol);
+  } catch (error) {
+    console.error("Failed to initialize BrightSign backend", error);
+    return false;
+  }
+  if (backendInitialization) {
+    if (backendInitialization.protocol !== streamProtocol) {
+      console.error(`BrightSign backend is already initializing with protocol ${backendInitialization.protocol}`);
+      return false;
+    }
+    return backendInitialization.promise;
+  }
+  if (ownedTCP && window.brightSignTCP !== ownedTCP || ownedDecoder && window.brightSignDecoder !== ownedDecoder) {
+    console.error("BrightSign backend resources owned by the adapter were externally replaced");
+    return false;
+  }
   if (window.brightSignTCP && window.brightSignDecoder) {
+    let existingProtocol;
+    try {
+      existingProtocol = window.brightSignDecoder.getDiagnostics().protocol;
+    } catch (error) {
+      console.error("Failed to inspect existing BrightSign backend", error);
+      return false;
+    }
+    if (existingProtocol !== streamProtocol) {
+      console.error(`BrightSign backend is already initialized with protocol ${existingProtocol}`);
+      return false;
+    }
     return true;
   }
+  if (window.brightSignDecoder) {
+    console.error("BrightSign decoder exists without its transport");
+    return false;
+  }
   if (!isBrightSignRuntimeAvailable()) {
     return false;
   }
+  const promise = initializeBrightSignBackend(options, streamProtocol);
+  backendInitialization = { protocol: streamProtocol, promise };
+  try {
+    return await promise;
+  } finally {
+    backendInitialization = void 0;
+  }
+}
+async function initializeBrightSignBackend(options, streamProtocol) {
+  var _a;
+  let decoder;
+  let createdTCP;
   try {
     const geometry = (_a = options.geometry) != null ? _a : {
       x: 0,
@@ -26327,37 +26392,132 @@ async function initBrightSignBackend(options) {
       width: window.innerWidth,
       height: window.innerHeight
     };
+    const existingTCP = window.brightSignTCP;
     if (!initBrightSignTCP()) {
       return false;
     }
-    const decoder = (0, import_brightsign_decoder.createBrightSignDecoder)();
-    await decoder.initialize(geometry);
-    window.brightSignDecoder = decoder;
+    if (!existingTCP) {
+      createdTCP = window.brightSignTCP;
+    }
+    const tcp = window.brightSignTCP;
+    if (!tcp) {
+      throw new Error("BrightSign transport was not created");
+    }
+    decoder = (0, import_brightsign_decoder.createBrightSignDecoder)();
+    ownedDecoder = decoder;
     registerTeardown();
+    await decoder.initialize({
+      ...geometry,
+      streamProtocol
+    });
+    if (unloading || window.brightSignTCP !== tcp || window.brightSignDecoder || ownedDecoder !== decoder) {
+      throw new Error("BrightSign backend state changed during initialization");
+    }
+    window.brightSignDecoder = decoder;
     return true;
   } catch (error) {
-    window.brightSignDecoder = void 0;
+    if (unloading) {
+      await teardownPromise;
+      console.error("Failed to initialize BrightSign backend", error);
+      return false;
+    }
+    if (window.brightSignDecoder === decoder) {
+      window.brightSignDecoder = void 0;
+    }
+    if (createdTCP && window.brightSignTCP === createdTCP) {
+      window.brightSignTCP = void 0;
+    }
+    const destroyDecoder = ownedDecoder === decoder ? decoder : void 0;
+    const destroyTCP = ownedTCP === createdTCP ? createdTCP : void 0;
+    if (destroyDecoder) {
+      ownedDecoder = void 0;
+    }
+    if (destroyTCP) {
+      ownedTCP = void 0;
+    }
+    await Promise.all([
+      destroyAfterInitializationFailure(destroyDecoder, "decoder", () => {
+        ownedDecoder = destroyDecoder;
+      }),
+      destroyAfterInitializationFailure(destroyTCP, "transport", () => {
+        ownedTCP = destroyTCP;
+      })
+    ]);
     console.error("Failed to initialize BrightSign backend", error);
     return false;
   }
 }
+async function destroyAfterInitializationFailure(resource, resourceName, restoreOwnership) {
+  if (!resource) {
+    return;
+  }
+  const context = { deadlineMs: 1e3 };
+  try {
+    await resource.destroy(context);
+  } catch (cleanupError) {
+    console.error(`Failed to clean up BrightSign ${resourceName} after initialization failure`, cleanupError);
+    if (!unloading) {
+      restoreOwnership();
+      return;
+    }
+    try {
+      await resource.destroy(context);
+    } catch (retryError) {
+      console.error(`Failed to clean up BrightSign ${resourceName} during unload`, retryError);
+      restoreOwnership();
+    }
+  }
+}
+async function destroyOwnedResources() {
+  const context = { deadlineMs: 1e3 };
+  const decoder = ownedDecoder;
+  const destroyDecoder = async () => {
+    if (!decoder) {
+      return;
+    }
+    try {
+      await decoder.destroy(context);
+      if (ownedDecoder === decoder) {
+        ownedDecoder = void 0;
+      }
+      if (window.brightSignDecoder === decoder) {
+        window.brightSignDecoder = void 0;
+      }
+    } catch (error) {
+      console.error("Failed to destroy BrightSign decoder", error);
+    }
+  };
+  const tcp = ownedTCP;
+  const destroyTCP = async () => {
+    if (!tcp) {
+      return;
+    }
+    try {
+      await tcp.destroy(context);
+      if (ownedTCP === tcp) {
+        ownedTCP = void 0;
+      }
+      if (window.brightSignTCP === tcp) {
+        window.brightSignTCP = void 0;
+      }
+    } catch (error) {
+      console.error("Failed to destroy BrightSign transport", error);
+    }
+  };
+  await Promise.all([destroyDecoder(), destroyTCP()]);
+}
 function registerTeardown() {
   if (teardownRegistered) {
     return;
   }
   teardownRegistered = true;
   window.addEventListener("unload", () => {
-    const decoder = window.brightSignDecoder;
-    const tcp = window.brightSignTCP;
-    const context = { deadlineMs: Date.now() + 1e3 };
-    window.brightSignDecoder = void 0;
-    window.brightSignTCP = void 0;
-    void (decoder == null ? void 0 : decoder.destroy(context).catch((error) => {
-      console.error("Failed to destroy BrightSign decoder", error);
-    }));
-    void (tcp == null ? void 0 : tcp.destroy(context).catch((error) => {
-      console.error("Failed to destroy BrightSign transport", error);
-    }));
+    unloading = true;
+    if (!teardownPromise) {
+      teardownPromise = destroyOwnedResources().finally(() => {
+        teardownPromise = void 0;
+      });
+    }
   });
 }
 
@@ -26390,7 +26550,7 @@ async function initSamsungWasmTCP() {
 }
 
 // daemon/plain.ts
-var DAEMON_JS_URL = "supra-client-daemon.js?v=1.0.0-mzbrightsigndecoder.489";
+var DAEMON_JS_URL = "supra-client-daemon.js?v=1.0.0-mzbrightsigndecoder.491";
 async function startPlainDaemon() {
   initBrightSignTCP();
   await initNaClTCP();
@@ -26404,7 +26564,7 @@ async function startPlainDaemon() {
 }
 
 // daemon/wasm.ts
-var DAEMON_WASM_URL = "supra-client-daemon.wasm?v=1.0.0-mzbrightsigndecoder.489";
+var DAEMON_WASM_URL = "supra-client-daemon.wasm?v=1.0.0-mzbrightsigndecoder.491";
 async function startWasmDaemon() {
   initBrightSignTCP();
   await initNaClTCP();
@@ -26762,6 +26922,9 @@ function parseQueryOptions() {
     interactive: params.interactive === "true",
     netInWorker: params.netInWorker === "true"
   };
+  if (typeof params.streamProtocol === "string") {
+    options.streamProtocol = params.streamProtocol;
+  }
   if (typeof params.forceScreenSize === "string") {
     const sizeParts = params.forceScreenSize.split("x");
     if (sizeParts.length !== 2) {
@@ -26829,7 +26992,7 @@ function getGoArgv2(binFile, options) {
 }
 
 // screen/plain.ts
-var SCREEN_JS_URL = "supra-client-screen.js?v=1.0.0-mzbrightsigndecoder.489";
+var SCREEN_JS_URL = "supra-client-screen.js?v=1.0.0-mzbrightsigndecoder.491";
 async function startPlainScreen(options) {
   var _a, _b, _c;
   console.log("[Supra screen plain] initialization begin");
@@ -26883,7 +27046,7 @@ async function startPlainScreen(options) {
 }
 
 // screen/h264decoder.ts
-var H264_DECODER_URL = "h264decoder.js?v=1.0.0-mzbrightsigndecoder.489";
+var H264_DECODER_URL = "h264decoder.js?v=1.0.0-mzbrightsigndecoder.491";
 async function initH264Decoder() {
   if (window.VideoDecoder !== void 0) {
     return void 0;
@@ -26922,7 +27085,7 @@ function getProperty(value, property) {
 }
 
 // screen/wasm.ts
-var SCREEN_WASM_URL = "supra-client-screen.wasm?v=1.0.0-mzbrightsigndecoder.489";
+var SCREEN_WASM_URL = "supra-client-screen.wasm?v=1.0.0-mzbrightsigndecoder.491";
 async function initializePhase(name, initialize) {
   const startedAt = Date.now();
   console.log(`[Supra screen WASM] ${name} begin`);