Bump version to 5.8.3

This reverts commit 91ab57fa29.

.github/ISSUE_TEMPLATE/02-feature-request.yml

@@ -14,41 +14,12 @@ body:
     id: device_type
     attributes:
       label: Device
-      description: "Which device are you using?"
+      description: "Which device type is this feature for?"
       options:
+        - All devices
         - Phone/Tablet
-        - Laptop
         - Desktop
         - TV
-        - Other
-      multiple: false
-    validations:
-      required: true
-  - type: dropdown
-    id: os
-    attributes:
-      label: "Operating System"
-      description: "Which operating system is it running?"
-      options:
-        - Windows
-        - macOS
-        - Linux
-        - Android
-        - iOS/iPadOS
-        - Other
-      multiple: false
-    validations:
-      required: true
-  - type: dropdown
-    id: browser
-    attributes:
-      label: "Browser"
-      description: "Which browser are you using?"
-      options:
-        - Chrome/Edge/Chromium
-        - Kiwi Browser
-        - Safari
-        - Other
       multiple: false
     validations:
       required: true

README.md

@@ -5,7 +5,9 @@ Improve Xbox Cloud Gaming (xCloud) experience on [xbox.com/play](https://www.xbo
 > The Android app is in development at [redphx/better-xcloud-android](https://github.com/redphx/better-xcloud-android)
 
 > [!IMPORTANT]
-> I don't accept pull requests at the moment (except PR for custom touch controls)
+> I only accept pull requests for:
+> - Custom touch controls
+> - Bug fixes
 
 **Supported platforms:**  
 - Windows
@@ -21,50 +23,15 @@ If you like this project please give it a 🌟. Thank you 🙏.
 [![Total downloads](https://img.shields.io/github/downloads/redphx/better-xcloud/total?color=%23e15f2c)](https://github.com/redphx/better-xcloud/releases) 
 [![Total stars](https://img.shields.io/github/stars/redphx/better-xcloud?color=%23cca400)](https://github.com/redphx/better-xcloud/stargazers)  
 
+## How to install
+Visit the [home page](https://better-xcloud.github.io) to know how to install Better xCloud on your device.
+
 ## Full documentations
-- For the full details please visit: https://better-xcloud.github.io  
+- For the full details please visit: [**better-xcloud.github.io**](https://better-xcloud.github.io)  
 - [Demo video](https://youtu.be/hyp69Jrb2sQ)
 
 ⚠️ Please DO NOT report **Better xCloud**'s bugs on [/r/xcloud subreddit](https://reddit.com/r/xcloud/). Report bugs in [Issues](https://github.com/redphx/better-xcloud/issues) or [Telegram channel](https://t.me/betterxcloud) instead.
 
-## Table of Contents
-- [**How to install**](#how-to-install)
-- [**Features**](#features)
-- [**Donation**](#donation)
-- [**Acknowledgements**](#acknowledgements)
-- [**Disclaimers**](#disclaimers)
-
-## How to install
-Visit [this page](https://better-xcloud.github.io/browsers) to know how to install Better xCloud on your device.
-
-## Features
-
-<img width="400" alt="Settings UI" src="https://github.com/redphx/better-xcloud/assets/96280/4bec2d62-31df-499c-9aad-2485626b6925">
-<br>
-<img width="400" alt="Remote Play dialog" src="https://github.com/redphx/better-xcloud/assets/96280/daf7f698-a228-4f9c-8f23-9669e061a64c">
-<br>
-<img width="600" alt="Stream HUD" src="https://github.com/redphx/better-xcloud/assets/96280/51bdb96c-79ab-402f-902a-a9e6229973b2">
-<br>
-<img width="600" alt="Stream settings" src="https://github.com/redphx/better-xcloud/assets/96280/ed513cb3-6e6c-4e8e-9e06-c62e71e41c90">
-<br>
-<img width="600" alt="Remapper" src="https://github.com/redphx/better-xcloud/assets/96280/f2e2bc51-f673-4b24-b127-c7169b86462b">
-
-
-&nbsp;  
-  
-**Demo video:** [https://youtu.be/oDr5Eddp55E  ](https://youtu.be/AYb-EUcz72U)  
-- **🔥 Totally free and open-source**
-- **🔥 Allow playing with [Mouse & Keyboard](https://better-xcloud.github.io/mouse-and-keyboard)**
-- **🔥 Enable [Remote Play](https://better-xcloud.github.io/remote-play) support**  
-  > 1080p resolution and can stream Xbox 360 games.  
-- **🔥 [Improve visual quality](https://better-xcloud.github.io/ingame-features/#improve-streams-clarity) of the stream**  
-  > Similar to (but not as good as) the "Clarity Boost" of xCloud on Edge browser. [Demo video](https://youtu.be/ZhW2choAHUs). 
-- **🔥 Show [Stream stats](https://better-xcloud.github.io/stream-stats)**  
-- **🔥 [Screenshot capture](https://better-xcloud.github.io/screenshot-capture)**
-- **🔥 [Touch controller](https://better-xcloud.github.io/features/#touch-controller)**
-  > Enable touch controller support for all games.
-- [And more...](https://better-xcloud.github.io/features/)
-
 ## Donation
 If you think this project is useful and want to support future developments, please consider making a donate via [my Ko-fi page](https://ko-fi.com/redphx).  
 Or you can give this project a star, that's also helpful.  

build.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+build_all () {
+    # Clear screen
+    printf "\033c"
+
+    # Build all variants
+    bun build.ts --version $1 --variant full
+    bun build.ts --version $1 --variant lite
+
+    # Wait for key
+    read -p ">> Press Enter to build again..."
+    build_all $1
+}
+
+build_all $1

build.ts

@@ -2,16 +2,24 @@
 import { readFile } from "node:fs/promises";
 import { parseArgs } from "node:util";
 import { sys } from "typescript";
+// @ts-ignore
 import txtScriptHeader from "./src/assets/header_script.txt" with { type: "text" };
+// @ts-ignore
+import txtScriptHeaderLite from "./src/assets/header_script.lite.txt" with { type: "text" };
+// @ts-ignore
 import txtMetaHeader from "./src/assets/header_meta.txt" with { type: "text" };
+import { assert } from "node:console";
+import { ESLint } from "eslint";
 
 enum BuildTarget {
-	ALL = 'all',
+    ALL = 'all',
-	ANDROID_APP = 'android-app',
+    ANDROID_APP = 'android-app',
-	MOBILE = 'mobile',
+    MOBILE = 'mobile',
-	WEBOS = 'webos',
+    WEBOS = 'webos',
 }
 
+type BuildVariant = 'full' | 'lite';
+
 const postProcess = (str: string): string => {
     // Unescape unicode charaters
     str = unescape((str.replace(/\\u/g, '%u')));
@@ -21,83 +29,205 @@ const postProcess = (str: string): string => {
     // Replace "globalThis." with "var";
     str = str.replaceAll('globalThis.', 'var ');
 
-	// Add ADDITIONAL CODE block
+    // Remove enum's inlining comments
-	str = str.replace('var DEFAULT_FLAGS', '\n/* ADDITIONAL CODE */\n\nvar DEFAULT_FLAGS');
+    str = str.replaceAll(/ \/\* [A-Z0-9_]+ \*\//g, '');
+    str = str.replaceAll('/* @__PURE__ */ ', '');
+
+    // Remove comments from import
+    str = str.replaceAll(/\/\/ src.*\n/g, '');
+
+    // Add ADDITIONAL CODE block
+    str = str.replace('var DEFAULT_FLAGS', '\n/* ADDITIONAL CODE */\n\nvar DEFAULT_FLAGS');
+
+    str = str.replaceAll('(e) => `', 'e => `');
+
+    // Simplify object definitions
+    // {[1]: "a"} => {1: "a"}
+    str = str.replaceAll(/\[(\d+)\]: /g, '$1: ');
+    // {["a"]: 1, ["b-c"]: 2} => {a: 1, "b-c": 2}
+    str = str.replaceAll(/\["([^"]+)"\]: /g, function(match, p1) {
+        if (p1.includes('-') || p1.match(/^\d/)) {
+            p1 = `"${p1}"`;
+        }
+
+        return p1 + ': ';
+    });
+
+    // Minify SVG import code
+    const svgMap = {}
+    str = str.replaceAll(/var ([\w_]+) = ("<svg.*?");\n\n/g, (match, p1, p2) => {
+        // Remove new lines in SVG
+        p2 = p2.replaceAll(/\\n*\s*/g, '');
+
+        svgMap[p1] = p2;
+        return '';
+    });
+
+    for (const name in svgMap) {
+        str = str.replace(`: ${name}`, `: ${svgMap[name]}`);
+    }
+
+    // Collapse empty brackets
+    str = str.replaceAll(/\{[\s\n]+\}/g, '{}');
+
+    // Collapse if/else blocks without curly braces
+    str = str.replaceAll(/((if \(.*?\)|else)\n\s+)/g, '$2 ');
+
+    // Remove blank lines
+    str = str.replaceAll(/\n([\s]*)\n/g, "\n");
+
+    // Minify WebGL shaders & JS strings
+    // Replace "\n     " with "\n"
+    str = str.replaceAll(/\\n+\s*/g, '\\n');
+    // Remove comment line
+    str = str.replaceAll(/\\n\/\/.*?(?=\\n)/g, '');
+
+    // Replace ${"time".toUpperCase()} with "TIME"
+    str = str.replaceAll(/\$\{"([^"]+)"\.toUpperCase\(\)\}/g, (match, p1) => {
+        return p1.toUpperCase();
+    });
+
+    assert(str.includes('/* ADDITIONAL CODE */'));
+    assert(str.includes('window.BX_EXPOSED = BxExposed'));
+    assert(str.includes('window.BxEvent = BxEvent'));
+    assert(str.includes('window.BX_FETCH = window.fetch'));
 
     return str;
 }
 
-const build = async (target: BuildTarget, version: string, config: any={}) => {
+const build = async (target: BuildTarget, version: string, variant: BuildVariant, config: any={}) => {
-	console.log('-- Target:', target);
+    console.log('-- Target:', target);
-	const startTime = performance.now();
+    const startTime = performance.now();
 
-	let outputScriptName = 'better-xcloud';
+    let outputScriptName = 'better-xcloud';
-	if (target !== BuildTarget.ALL) {
+    if (target !== BuildTarget.ALL) {
-		outputScriptName += `.${target}`;
+        outputScriptName += `.${target}`;
-	}
+    }
-	let outputMetaName = outputScriptName;
-	outputScriptName += '.user.js';
-	outputMetaName += '.meta.js';
 
-	const outDir = './dist';
+    if (variant !== 'full') {
+        outputScriptName += `.${variant}`;
+    }
 
-	let output = await Bun.build({
+    let outputMetaName = outputScriptName;
-		entrypoints: ['src/index.ts'],
+    outputScriptName += '.user.js';
-		outdir: outDir,
+    outputMetaName += '.meta.js';
-		naming: outputScriptName,
-		define: {
-			'Bun.env.BUILD_TARGET': JSON.stringify(target),
-			'Bun.env.SCRIPT_VERSION': JSON.stringify(version),
-		},
-	});
 
-	if (!output.success) {
+    const outDir = './dist';
-		console.log(output);
-		process.exit(1);
-	}
 
-	const {path} = output.outputs[0];
+    let output = await Bun.build({
-	// Get generated file
+        entrypoints: ['src/index.ts'],
-	let result = postProcess(await readFile(path, 'utf-8'));
+        outdir: outDir,
+        naming: outputScriptName,
+        minify: {
+            syntax: true,
+        },
+        define: {
+            'Bun.env.BUILD_TARGET': JSON.stringify(target),
+            'Bun.env.BUILD_VARIANT': JSON.stringify(variant),
+            'Bun.env.SCRIPT_VERSION': JSON.stringify(version),
+        },
+    });
 
-	// Replace [[VERSION]] with real value
+    if (!output.success) {
-	const scriptHeader = txtScriptHeader.replace('[[VERSION]]', version);
+        console.log(output);
+        process.exit(1);
+    }
 
-	// Save to script
+    const {path} = output.outputs[0];
-	await Bun.write(path, scriptHeader + result);
+    // Get generated file
-	console.log(`---- [${target}] done in ${performance.now() - startTime} ms`);
+    let result = postProcess(await readFile(path, 'utf-8'));
 
-	// Create meta file
+    // Replace [[VERSION]] with real value
-	await Bun.write(outDir + '/' + outputMetaName, txtMetaHeader.replace('[[VERSION]]', version));
+    let scriptHeader: string;
+    if (variant === 'full') {
+        scriptHeader = txtScriptHeader;
+    } else {
+        scriptHeader = txtScriptHeaderLite;
+    }
+    scriptHeader = scriptHeader.replace('[[VERSION]]', version);
+
+    // Save to script
+    await Bun.write(path, scriptHeader + result);
+
+    // Create meta file (don't build if it's beta version)
+    if (!version.includes('beta') && variant === 'full') {
+        await Bun.write(outDir + '/' + outputMetaName, txtMetaHeader.replace('[[VERSION]]', version));
+    }
+
+    // Check with ESLint
+    const eslint = new ESLint();
+    const results = await eslint.lintFiles([path]);
+    results[0].messages.forEach((msg: any) => {
+        console.error(`${path}#${msg.line}: ${msg.message}`);
+    });
+
+    console.log(`---- [${target}] done in ${performance.now() - startTime} ms`);
+    console.log(`---- [${target}] ${new Date()}`);
 }
 
 const buildTargets = [
-	BuildTarget.ALL,
+    BuildTarget.ALL,
-	// BuildTarget.ANDROID_APP,
+    // BuildTarget.ANDROID_APP,
-	// BuildTarget.MOBILE,
+    // BuildTarget.MOBILE,
-	// BuildTarget.WEBOS,
+    // BuildTarget.WEBOS,
 ];
 
 const { values, positionals } = parseArgs({
-	args: Bun.argv,
+    args: Bun.argv,
-	options: {
+    options: {
-	  version: {
+        version: {
-		type: 'string',
+            type: 'string',
+        },
 
-	  },
+        variant: {
-	},
+            type: 'string',
-	strict: true,
+            default: 'full',
-	allowPositionals: true,
+        },
-  });
+    },
+    strict: true,
+    allowPositionals: true,
+}) as {
+    values: {
+        version: string,
+        variant: BuildVariant,
+    },
+    positionals: string[],
+};
 
 if (!values['version']) {
-	console.log('Missing --version param');
+    console.log('Missing --version param');
-	sys.exit(-1);
+    sys.exit(-1);
 }
 
-console.log('Building: ', values['version']);
+if (values['variant'] !== 'full' && values['variant'] !== 'lite') {
-
+    console.log('--variant param must be either "full" or "lite"');
-const config = {};
+    sys.exit(-1);
-for (const target of buildTargets) {
-	await build(target, values['version'], config);
 }
+
+async function main() {
+    const config = {};
+    console.log(`Building: VERSION=${values['version']}, VARIANT=${values['variant']}`);
+    for (const target of buildTargets) {
+        await build(target, values['version']!!, values['variant'], config);
+    }
+
+    console.log('')
+    // console.log('\n** Press Enter to build or Esc to exit');
+}
+
+function onKeyPress(data: any) {
+    const keyCode = data[0];
+    if (keyCode === 13) {  // Enter key
+        main();
+    } else if (keyCode === 27) {  // Esc key
+        process.exit(0);
+    }
+}
+
+main();
+
+/*
+process.stdin.setRawMode(true);
+process.stdin.resume();
+process.stdin.on('data', onKeyPress);
+*/

dist/better-xcloud.meta.js

@@ -1,5 +1,5 @@
 // ==UserScript==
 // @name         Better xCloud
 // @namespace    https://github.com/redphx
-// @version      5.0.0
+// @version      5.8.3
 // ==/UserScript==

eslint.config.mjs

@@ -0,0 +1,3 @@
+import compat from "eslint-plugin-compat";
+
+export default [compat.configs['flat/recommended']];

package.json

@@ -2,16 +2,22 @@
   "name": "better-xcloud",
   "module": "src/index.ts",
   "type": "module",
+  "sideEffects": false,
+  "browserslist": [
+    "Chrome >= 80"
+  ],
   "bin": {
     "build": "build.ts"
   },
   "devDependencies": {
-    "@types/bun": "^1.1.5",
+    "@types/bun": "^1.1.10",
-    "@types/node": "^20.14.7",
+    "@types/node": "^22.7.5",
-    "@types/stylus": "^0.48.42",
+    "@types/stylus": "^0.48.43",
+    "eslint": "^9.12.0",
+    "eslint-plugin-compat": "^6.0.1",
     "stylus": "^0.63.0"
   },
   "peerDependencies": {
-    "typescript": "^5.5.2"
+    "typescript": "^5.6.2"
   }
 }

src/assets/css/button.styl

@@ -1,5 +1,10 @@
 .bx-button {
-    background-color: var(--bx-default-button-color);
+    --button-rgb: var(--bx-default-button-rgb);
+    --button-hover-rgb: var(--bx-default-button-hover-rgb);
+    --button-active-rgb: var(--bx-default-button-active-rgb);
+    --button-disabled-rgb: var(--bx-default-button-disabled-rgb);
+
+    background-color: unquote('rgb(var(--button-rgb))');
     user-select: none;
     -webkit-user-select: none;
     color: #fff;
@@ -14,63 +19,101 @@
     cursor: pointer;
     overflow: hidden;
 
+    &:not([disabled]):active {
+        background-color: unquote('rgb(var(--button-active-rgb))');
+    }
+
     &:focus {
         outline: none !important;
     }
 
-    &:hover, &.bx-focusable:focus {
+    &:not([disabled]):not(:active) {
-        background-color: var(--bx-default-button-hover-color);
+        &:hover, &.bx-focusable:focus {
+            background-color: unquote('rgb(var(--button-hover-rgb))');
+        }
     }
 
+
     &:disabled {
         cursor: default;
-        background-color: var(--bx-default-button-disabled-color);
+        background-color: unquote('rgb(var(--button-disabled-rgb))');
     }
 
     &.bx-ghost {
         background-color: transparent;
 
-        &:hover, &.bx-focusable:focus {
+        &:not([disabled]):not(:active) {
-            background-color: var(--bx-default-button-hover-color);
+            &:hover, &.bx-focusable:focus {
+                background-color: unquote('rgb(var(--button-hover-rgb))');
+            }
         }
     }
 
     &.bx-primary {
-        background-color: var(--bx-primary-button-color);
+        --button-rgb: var(--bx-primary-button-rgb);
 
-        &:hover, &.bx-focusable:focus {
+        &:not([disabled]):active {
-            background-color: var(--bx-primary-button-hover-color);
+            --button-active-rgb: var(--bx-primary-button-active-rgb);
+        }
+
+        &:not([disabled]):not(:active) {
+            &:hover, &.bx-focusable:focus {
+                --button-hover-rgb: var(--bx-primary-button-hover-rgb);
+            }
         }
 
         &:disabled {
-            background-color: var(--bx-primary-button-disabled-color);
+            --button-disabled-rgb: var(--bx-primary-button-disabled-rgb);
         }
     }
 
     &.bx-danger {
-        background-color: var(--bx-danger-button-color);
+        --button-rgb: var(--bx-danger-button-rgb);
 
-        &:hover, &.bx-focusable:focus {
+        &:not([disabled]):active {
-            background-color: var(--bx-danger-button-hover-color);
+            --button-active-rgb: var(--bx-danger-button-active-rgb);
+        }
+
+        &:not([disabled]):not(:active) {
+            &:hover, &.bx-focusable:focus {
+                --button-hover-rgb: var(--bx-danger-button-hover-rgb);
+            }
         }
 
         &:disabled {
-            background-color: var(--bx-danger-button-disabled-color);
+            --button-disabled-rgb: var(--bx-danger-button-disabled-rgb);
         }
     }
 
+    &.bx-frosted {
+        --button-alpha: 0.2;
+        background-color: unquote('rgba(var(--button-rgb), var(--button-alpha))');
+        backdrop-filter: blur(4px) brightness(1.5);
+
+        &:not([disabled]):not(:active) {
+            &:hover, &.bx-focusable:focus {
+                background-color: unquote('rgba(var(--button-hover-rgb), var(--button-alpha))');
+            }
+        }
+    }
+
+    &.bx-drop-shadow {
+        box-shadow: 0 0 4px #00000080;
+    }
+
     &.bx-tall {
         height: calc(var(--bx-button-height) * 1.5) !important;
     }
 
+    &.bx-circular {
+        border-radius: var(--bx-button-height);
+        height: var(--bx-button-height);
+    }
+
     svg {
         display: inline-block;
         width: 16px;
         height: var(--bx-button-height);
-
-        &:not(:only-child) {
-            margin-right: 4px;
-        }
     }
 
     span {
@@ -82,24 +125,43 @@
         color: #fff;
         overflow: hidden;
         white-space: nowrap;
+
+        &:not(:only-child) {
+            margin-left: 10px;
+        }
+    }
+}
+
+.bx-focusable {
+    position: relative;
+    overflow: visible;
+
+    &::after {
+        border: 2px solid transparent;
+        border-radius: 10px;
     }
 
-    &.bx-focusable {
+    &:focus::after {
-        position: relative;
+        offset = -6px;
-
+        content: '';
-        &::after {
+        border-color: white;
-            border: 2px solid transparent;
+        position: absolute;
-            border-radius: 4px;
+        top: offset;
-        }
+        left: offset;
+        right: offset;
+        bottom: offset;
+    }
 
+    html[data-active-input=touch] &,
+    html[data-active-input=mouse] & {
         &:focus::after {
-            content: '';
+            border-color: transparent !important;
-            border-color: white;
+        }
-            position: absolute;
+    }
-            top: 0;
+
-            left: 0;
+    &.bx-circular {
-            right: 0;
+        &::after {
-            bottom: 0;
+            border-radius: var(--bx-button-height);
         }
     }
 }
@@ -111,3 +173,9 @@ a.bx-button {
         text-align: center;
     }
 }
+
+button.bx-inactive {
+    pointer-events: none;
+    opacity: 0.2;
+    background: transparent !important;
+}

src/assets/css/global-settings.styl

@@ -1,183 +0,0 @@
-.bx-settings-reload-button {
-    margin-top: 10px;
-}
-
-.bx-settings-container {
-    background-color: #151515;
-    user-select: none;
-    -webkit-user-select: none;
-    color: #fff;
-    font-family: var(--bx-normal-font);
-}
-
-@media (hover: hover) {
-    .bx-settings-wrapper a.bx-settings-title:hover {
-        color: #83f73a;
-    }
-}
-
-.bx-settings-wrapper {
-    width: 450px;
-    margin: auto;
-    padding: 12px 6px;
-
-    @media screen and (max-width: 450px) {
-        width: 100%;
-    }
-
-    *:focus {
-        outline: none !important;
-    }
-
-    .bx-settings-title-wrapper {
-        display: flex;
-        margin-bottom: 10px;
-        align-items: center;
-    }
-
-    a.bx-settings-title {
-        font-family: var(--bx-title-font);
-        font-size: 1.4rem;
-        text-decoration: none;
-        font-weight: bold;
-        display: block;
-        color: #5dc21e;
-        flex: 1;
-
-        &:focus {
-            color: #83f73a;
-        }
-    }
-
-    .bx-button.bx-primary {
-        margin-top: 8px;
-    }
-
-    a.bx-settings-update {
-        display: block;
-        color: #ff834b;
-        text-decoration: none;
-        margin-bottom: 8px;
-        text-align: center;
-        background: #222;
-        border-radius: 4px;
-        padding: 4px;
-
-        &:hover {
-            @media (hover: hover) {
-                color: #ff9869;
-                text-decoration: underline;
-            }
-        }
-
-        &:focus {
-            color: #ff9869;
-            text-decoration: underline;
-        }
-    }
-}
-
-.bx-settings-group-label {
-    font-weight: bold;
-    display: block;
-    font-size: 1.1rem;
-}
-
-
-.bx-settings-row {
-    display: flex;
-    padding: 6px 12px;
-    position: relative;
-
-    label {
-        flex: 1;
-        align-self: center;
-        margin-bottom: 0;
-    }
-
-
-    &:hover, &:focus-within {
-        background-color: #242424;
-    }
-
-    input {
-        align-self: center;
-        accent-color: var(--bx-primary-button-color);
-
-        &:focus {
-            accent-color: var(--bx-danger-button-color);
-        }
-    }
-
-    select {
-        &:disabled {
-            -webkit-appearance: none;
-            background: transparent;
-            text-align-last: right;
-            border: none;
-            color: #fff;
-        }
-    }
-
-    input[type=checkbox], select {
-        &:focus {
-            filter: drop-shadow(1px 0 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 1px 0 #fff) drop-shadow(0 -1px 0 #fff);
-        }
-    }
-
-
-    &:has(input:focus), &:has(select:focus) {
-        &::before {
-            content: ' ';
-            border-radius: 4px;
-            border: 2px solid #fff;
-            position: absolute;
-            top: 0;
-            left: 0;
-            bottom: 0;
-        }
-    }
-}
-
-.bx-settings-group-label b, .bx-settings-row label b {
-    display: block;
-    font-size: 12px;
-    font-style: italic;
-    font-weight: normal;
-    color: #828282;
-}
-
-.bx-settings-group-label b {
-    margin-bottom: 8px;
-}
-
-.bx-settings-app-version {
-    margin-top: 10px;
-    text-align: center;
-    color: #747474;
-    font-size: 12px;
-}
-
-.bx-donation-link {
-    display: block;
-    text-align: center;
-    text-decoration: none;
-    height: 20px;
-    line-height: 20px;
-    font-size: 14px;
-    margin-top: 10px;
-    color: #5dc21e;
-
-    &:hover {
-        color: #6dd72b;
-    }
-
-    &:focus {
-        text-decoration: underline;
-    }
-}
-
-.bx-settings-custom-user-agent {
-    display: block;
-    width: 100%;
-}

src/assets/css/guide-menu.styl

@@ -0,0 +1,65 @@
+.bx-guide-home-achievements-progress {
+    display: flex;
+    gap: 10px;
+    flex-direction: row;
+
+    .bx-button {
+        margin-bottom: 0 !important;
+    }
+
+    html[data-xds-platform=tv] & {
+        flex-direction: column;
+    }
+
+    html:not([data-xds-platform=tv]) & {
+        flex-direction: row;
+
+        > button:first-of-type {
+            flex: 1;
+        }
+
+        > button:last-of-type {
+            width: 40px;
+
+            span {
+                display: none;
+            }
+        }
+    }
+}
+
+.bx-guide-home-buttons {
+    > div {
+        display: flex;
+        flex-direction: row;
+        gap: 12px;
+
+        html[data-xds-platform=tv] & {
+            flex-direction: column;
+
+            button {
+                margin-bottom: 0 !important;
+            }
+        }
+
+        html:not([data-xds-platform=tv]) & {
+            button {
+                span {
+                    display: none;
+                }
+            }
+        }
+    }
+
+    &[data-is-playing="true"] {
+        button[data-state='normal'] {
+            display: none;
+        }
+    }
+
+    &[data-is-playing="false"] {
+        button[data-state='playing'] {
+            display: none;
+        }
+    }
+}

src/assets/css/header.styl

@@ -4,7 +4,7 @@
 
     svg {
         width: 24px;
-        height: 46px;
+        height: 24px;
     }
 }
 

src/assets/css/misc.styl

@@ -0,0 +1,21 @@
+.bx-product-details-buttons {
+    display: flex;
+    gap: 10px;
+    flex-direction: row;
+
+    button {
+        max-width: max-content;
+        margin: 10px 0 0 0;
+        display: flex;
+    }
+}
+
+@media (min-width: 568px) and (max-height: 480px) {
+    .bx-product-details-buttons {
+        flex-direction: column;
+
+        button {
+            margin: 8px 0 0 10px;
+        }
+    }
+}

src/assets/css/navigation-dialog.styl

@@ -0,0 +1,23 @@
+.bx-navigation-dialog {
+    position: absolute;
+    z-index: var(--bx-navigation-dialog-z-index);
+    font-family: var(--bx-title-font);
+
+    *:focus {
+        outline: none !important;
+    }
+}
+
+.bx-navigation-dialog-overlay {
+    position: fixed;
+    background: #0b0b0be3;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    z-index: var(--bx-navigation-dialog-overlay-z-index);
+
+    &[data-is-playing="true"] {
+        background: transparent;
+    }
+}

src/assets/css/number-stepper.styl

@@ -5,14 +5,15 @@
         display: inline-block;
         min-width: 40px;
         font-family: var(--bx-monospaced-font);
-        font-size: 14px;
+        font-size: 13px;
+        margin: 0 4px;
     }
 
     button {
         border: none;
         width: 24px;
         height: 24px;
-        margin: 0 4px;
+        margin: 0;
         line-height: 24px;
         background-color: var(--bx-default-button-color);
         color: #fff;
@@ -20,7 +21,6 @@
         font-weight: bold;
         font-size: 14px;
         font-family: var(--bx-monospaced-font);
-        color: #fff;
 
         &:hover {
             @media (hover: hover) {

src/assets/css/remote-play.styl

@@ -1,36 +1,16 @@
-.bx-remote-play-popup {
-    width: 100%;
-    max-width: 1920px;
-    margin: auto;
-    position: relative;
-    height: 0.1px;
-    overflow: visible;
-    z-index: var(--bx-remote-play-popup-z-index);
-}
-
 .bx-remote-play-container {
-    position: absolute;
+    position: fixed;
-    right: 10px;
+    top: 50%;
-    top: 0;
+    left: 50%;
+    transform: translate(-50%, -50%);
+
+    color: white;
     background: #1a1b1e;
     border-radius: 10px;
     width: 420px;
     max-width: calc(100vw - 20px);
     margin: 0 0 0 auto;
     padding: 20px;
-    box-shadow: #00000080 0px 0px 12px 0px;
-
-    @media (min-width:480px) and (min-height:calc(480px + 1px)) {
-        right: calc(env(safe-area-inset-right, 0px) + 32px);
-    }
-
-    @media (min-width:768px) and (min-height:calc(480px + 1px)) {
-        right: calc(env(safe-area-inset-right, 0px) + 48px);
-    }
-
-    @media (min-width:1920px) and (min-height:calc(480px + 1px)) {
-        right: calc(env(safe-area-inset-right, 0px) + 80px);
-    }
 
     > .bx-button {
         display: table;
@@ -57,14 +37,6 @@
             font-size: 12px;
         }
     }
-
-    span {
-        font-weight: bold;
-        font-size: 18px;
-        display: block;
-        margin-bottom: 8px;
-        text-align: center;
-    }
 }
 
 .bx-remote-play-resolution {
@@ -114,10 +86,15 @@
 
 .bx-remote-play-power-state {
     color: #888;
-    font-size: 14px;
+    font-size: 12px;
 }
 
 .bx-remote-play-connect-button {
     min-height: 100%;
     margin: 4px 0;
 }
+
+.bx-remote-play-buttons {
+    display: flex;
+    justify-content: space-between;
+}

src/assets/css/root.styl

@@ -1,3 +1,18 @@
+button_color(name, normal, hover, active, disabled)
+    prefix = unquote('--bx-' + name + '-button');
+    {prefix + '-color'}: normal;
+    {prefix + '-rgb'}: red(normal), green(normal), blue(normal);
+
+    {prefix + '-hover-color'}: hover;
+    {prefix + '-hover-rgb'}: red(hover), green(hover), blue(hover);
+
+    {prefix + '-active-color'}: active;
+    {prefix + '-active-rgb'}: red(active), green(active), blue(active);
+
+    {prefix + '-disabled-color'}: disabled;
+    {prefix + '-disabled-rgb'}: red(disabled), green(disabled), blue(disabled);
+
+
 :root {
     --bx-title-font: Bahnschrift, Arial, Helvetica, sans-serif;
     --bx-title-font-semibold: Bahnschrift Semibold, Arial, Helvetica, sans-serif;
@@ -5,30 +20,26 @@
     --bx-monospaced-font: Consolas, "Courier New", Courier, monospace;
     --bx-promptfont-font: promptfont;
 
-    --bx-button-height: 36px;
+    --bx-button-height: 40px;
 
-    --bx-default-button-color: #2d3036;
+    button_color('default', #2d3036, #515863, #222428, #8e8e8e);
-    --bx-default-button-hover-color: #515863;
+    button_color('primary', #008746, #04b358, #044e2a, #448262);
-    --bx-default-button-disabled-color: #8e8e8e;
+    button_color('danger', #c10404, #e61d1d, #a26c6c, #df5656);
 
-    --bx-primary-button-color: #008746;
+    --bx-fullscreen-text-z-index: 99999;
-    --bx-primary-button-hover-color: #04b358;
+    --bx-toast-z-index: 60000;
-    --bx-primary-button-disabled-color: #448262;
+    --bx-dialog-z-index: 50000;
 
-    --bx-danger-button-color: #c10404;
+    --bx-dialog-overlay-z-index: 40200;
-    --bx-danger-button-hover-color: #e61d1d;
+    --bx-stats-bar-z-index: 40100;
-    --bx-danger-button-disabled-color: #a26c6c;
+    --bx-mkb-pointer-lock-msg-z-index: 40000;
 
-    --bx-toast-z-index: 9999;
+    --bx-navigation-dialog-z-index: 30100;
-    --bx-dialog-z-index: 9101;
+    --bx-navigation-dialog-overlay-z-index: 30000;
-    --bx-dialog-overlay-z-index: 9100;
+
-    --bx-remote-play-popup-z-index: 9090;
+    --bx-game-bar-z-index: 10000;
-    --bx-stats-bar-z-index: 9001;
+    --bx-screenshot-animation-z-index: 9000;
-    --bx-stream-settings-z-index: 9000;
+    --bx-wait-time-box-z-index: 1000;
-    --bx-mkb-pointer-lock-msg-z-index: 8999;
-    --bx-game-bar-z-index: 8888;
-    --bx-wait-time-box-z-index: 100;
-    --bx-screenshot-animation-z-index: 1;
 }
 
 @font-face {
@@ -46,7 +57,7 @@ div[class^=HUDButton-module__hiddenContainer] ~ div:not([class^=HUDButton-module
 }
 
 /* Remove the "Cloud Gaming" text in header when the screen is too small */
-@media screen and (max-width: 600px) {
+@media screen and (max-width: 640px) {
     header a[href="/play"] {
         display: none;
     }
@@ -64,6 +75,14 @@ div[class^=HUDButton-module__hiddenContainer] ~ div:not([class^=HUDButton-module
     overflow: hidden !important;
 }
 
+.bx-hide-scroll-bar {
+    scrollbar-width: none;
+
+    &::-webkit-scrollbar {
+        display: none;
+    }
+}
+
 .bx-gone {
     display: none !important;
 }
@@ -79,6 +98,14 @@ div[class^=HUDButton-module__hiddenContainer] ~ div:not([class^=HUDButton-module
     visibility: hidden !important;
 }
 
+.bx-invisible {
+    opacity: 0;
+}
+
+.bx-unclickable {
+    pointer-events: none;
+}
+
 .bx-pixel {
     width: 1px !important;
     height: 1px !important;
@@ -96,6 +123,25 @@ div[class^=HUDButton-module__hiddenContainer] ~ div:not([class^=HUDButton-module
     font-family: var(--bx-promptfont-font);
 }
 
+.bx-line-through {
+    text-decoration: line-through !important;
+}
+
+.bx-normal-case {
+    text-transform: none !important;
+}
+
+.bx-normal-link {
+    text-transform: none !important;
+    text-align: left !important;
+    font-weight: 400 !important;
+    font-family: var(--bx-normal-font) !important;
+}
+
+select[multiple] {
+    overflow: auto;
+}
+
 /* Hide UI elements */
 #headerArea, #uhfSkipToMain, .uhf-footer {
     display: none;
@@ -112,3 +158,71 @@ div[class*=NotFocusedDialog] {
 #game-stream video:not([src]) {
     visibility: hidden;
 }
+
+/* Hide Controller icon in Game tiles */
+div[class*=SupportedInputsBadge] {
+    &:not(:has(:nth-child(2))), svg:first-of-type {
+        display: none;
+    }
+}
+
+
+.bx-game-tile-wait-time {
+    position: absolute;
+    top: 0;
+    left: 0;
+    z-index: 1;
+    background: #0000008c;
+    display: flex;
+    border-radius: 4px 0 4px 0;
+    align-items: center;
+    padding: 4px 8px;
+
+    svg {
+        width: 14px;
+        height: 16px;
+        margin-right: 2px;
+    }
+
+    span {
+        display: inline-block;
+        height: 16px;
+        line-height: 16px;
+        font-size: 12px;
+        font-weight: bold;
+        margin-left: 2px;
+    }
+}
+
+
+.bx-fullscreen-text {
+    position: fixed;
+    top: 0;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    background: #000000cc;
+    z-index: var(--bx-fullscreen-text-z-index);
+    line-height: 100vh;
+    color: #fff;
+    text-align: center;
+    font-weight: 400;
+    font-family: var(--bx-normal-font);
+    font-size: 1.3rem;
+    user-select: none;
+    -webkit-user-select: none;
+}
+
+/* Device Code page */
+#root {
+    section[class*=DeviceCodePage-module__page] {
+        margin-left: 20px !important;
+        margin-right: 20px !important;
+        margin-top: 20px !important;
+        max-width: 800px !important;
+    }
+
+    div[class*=DeviceCodePage-module__back] {
+        display: none;
+    }
+}

src/assets/css/settings-dialog.styl

@@ -0,0 +1,565 @@
+.bx-settings-dialog {
+    display: flex;
+    position: fixed;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    opacity: 0.98;
+    user-select: none;
+    -webkit-user-select: none;
+
+    .bx-focusable {
+        &::after {
+            border-radius: 4px;
+        }
+
+        &:focus::after {
+            offset = 0;
+
+            top: offset;
+            left: offset;
+            right: offset;
+            bottom: offset;
+        }
+    }
+
+    .bx-settings-reload-note {
+        font-size: 0.8rem;
+        display: block;
+        padding: 8px;
+        font-style: italic;
+        font-weight: normal;
+        height: var(--bx-button-height);
+    }
+
+    input {
+        accent-color: var(--bx-primary-button-color);
+
+        &:focus {
+            accent-color: var(--bx-danger-button-color);
+        }
+    }
+
+    select:disabled {
+        -webkit-appearance: none;
+        background: transparent;
+        text-align-last: right;
+        border: none;
+        color: #fff;
+    }
+
+    select option:disabled {
+        display: none;
+    }
+
+    input[type=checkbox],
+    select {
+        &:focus {
+            filter: drop-shadow(1px 0 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 1px 0 #fff) drop-shadow(0 -1px 0 #fff);
+        }
+    }
+
+    a {
+        color: #1c9d1c;
+        text-decoration: none;
+
+        &:hover, &:focus {
+            color: #5dc21e;
+        }
+    }
+}
+
+.bx-settings-tabs-container {
+    position: fixed;
+    width: 48px;
+    max-height: 100vh;
+    display: flex;
+    flex-direction: column;
+
+    > div:last-of-type {
+        display: flex;
+        flex-direction: column;
+        align-items: end;
+
+        button {
+            flex-shrink: 0;
+            border-top-right-radius: 0;
+            border-bottom-right-radius: 0;
+            margin-top: 8px;
+            height: unset;
+            padding: 8px 10px;
+
+            svg {
+                size = 16px;
+
+                width: size;
+                height: size;
+            }
+        }
+    }
+}
+
+.bx-settings-tabs {
+    display: flex;
+    flex-direction: column;
+    border-radius: 0 0 0 8px;
+    box-shadow: 0 0 6px #000;
+    overflow: overlay;
+    flex: 1;
+
+    svg {
+        size = 24px;
+        width: size;
+        height: size;
+        padding: 10px;
+        flex-shrink: 0;
+        box-sizing: content-box;
+        background: #131313;
+        cursor: pointer;
+        border-left: 4px solid #1e1e1e;
+
+        &.bx-active {
+            background: #222;
+            border-color: #008746;
+        }
+
+        &:not(.bx-active):hover {
+            background: #2f2f2f;
+            border-color: #484848;
+        }
+
+        &:focus {
+            border-color: #fff;
+        }
+
+        &[data-group=global] {
+            &[data-need-refresh=true] {
+                background: var(--bx-danger-button-color) !important;
+
+                &:hover {
+                    background: var(--bx-danger-button-hover-color) !important;
+                }
+            }
+        }
+    }
+}
+
+
+.bx-settings-tab-contents {
+    tabsWidth = 48px;
+
+    flex-direction: column;
+    padding: 10px;
+    margin-left: tabsWidth;
+    width: 450px;
+    max-width: calc(100vw - tabsWidth);
+    background: #1a1b1e;
+    color: #fff;
+    font-weight: 400;
+    font-size: 16px;
+    font-family: var(--bx-title-font);
+    text-align: center;
+    box-shadow: 0px 0px 6px #000;
+    overflow: overlay;
+    z-index: 1;
+
+    > div[data-tab-group=mkb] {
+        display: flex;
+        flex-direction: column;
+        height: 100%;
+        overflow: hidden;
+    }
+
+    > div[data-tab-group=shortcuts] {
+        > div {
+            &[data-has-gamepad=true] {
+                > div:first-of-type {
+                    display: none;
+                }
+
+                > div:last-of-type {
+                    display: block;
+                }
+            }
+
+            &[data-has-gamepad=false] {
+                > div:first-of-type {
+                    display: block;
+                }
+
+                > div:last-of-type {
+                    display: none;
+                }
+            }
+        }
+
+        .bx-shortcut-profile {
+            width: 100%;
+            height: 36px;
+            display: block;
+        }
+
+        .bx-shortcut-note {
+            margin-top: 10px;
+            font-size: 14px;
+        }
+
+        .bx-shortcut-row {
+            display: flex;
+            margin-bottom: 10px;
+
+            label.bx-prompt {
+                flex: 1;
+                font-size: 26px;
+                margin-bottom: 0;
+            }
+
+            .bx-shortcut-actions {
+                flex: 2;
+                position: relative;
+
+                select {
+                    position: absolute;
+                    width: 100%;
+                    height: 100%;
+                    display: block;
+
+                    &:last-of-type {
+                        opacity: 0;
+                        z-index: calc(var(--bx-settings-z-index) + 1);
+                    }
+                }
+            }
+        }
+    }
+
+    .bx-top-buttons {
+        display: flex;
+        flex-direction: column;
+        gap: 8px;
+        margin-bottom: 8px;
+
+        .bx-button {
+            display: block;
+        }
+    }
+
+    h2 {
+        margin: 16px 0 8px 0;
+        display: flex;
+        align-items: center;
+
+        &:first-of-type {
+            margin-top: 0;
+        }
+
+        span {
+            display: inline-block;
+            font-size: 20px;
+            font-weight: bold;
+            text-align: left;
+            flex: 1;
+            text-overflow: ellipsis;
+            overflow: hidden;
+            white-space: nowrap;
+        }
+    }
+}
+
+@media (max-width: 500px) {
+    .bx-settings-tab-contents {
+        width: calc(100vw - 48px);
+    }
+}
+
+.bx-settings-row {
+    display: flex;
+    gap: 10px;
+    padding: 16px 10px;
+    margin: 0;
+    background: #2a2a2a;
+    border-bottom: 1px solid #343434;
+
+    &:hover, &:focus-within {
+        background-color: #242424;
+    }
+
+    &:not(:has(> input[type=checkbox])) {
+        flex-wrap: wrap;
+    }
+
+    /*
+    &:has(input:focus), &:has(select:focus), &:has(button:focus) {
+        border-left-color: white;
+    }
+    */
+
+    > span.bx-settings-label {
+        font-size: 14px;
+        display: block;
+        text-align: left;
+        align-self: center;
+        margin-bottom: 0 !important;
+        flex: 1;
+
+        + * {
+            margin: 0 0 0 auto;
+        }
+    }
+}
+
+.bx-settings-dialog-note {
+    display: block;
+    color: #afafb0;
+    font-size: 12px;
+    font-weight: lighter;
+    font-style: italic;
+
+    &:not(:has(a)) {
+        margin-top: 4px;
+    }
+
+    a {
+        display: inline-block;
+        padding: 4px;
+    }
+}
+
+.bx-settings-custom-user-agent {
+    display: block;
+    width: 100%;
+    padding: 6px;
+}
+
+.bx-donation-link {
+    display: block;
+    text-align: center;
+    text-decoration: none;
+    height: 20px;
+    line-height: 20px;
+    font-size: 14px;
+    margin-top: 10px;
+}
+
+.bx-debug-info {
+    button {
+        margin-top: 10px;
+    }
+
+    pre {
+        margin-top: 10px;
+        cursor: copy;
+        color: white;
+        padding: 8px;
+        border: 1px solid #2d2d2d;
+        background: #212121;
+        white-space: break-spaces;
+        text-align: left;
+
+        &:hover {
+            background: #272727;
+        }
+    }
+}
+
+.bx-settings-app-version {
+    margin-top: 10px;
+    text-align: center;
+    color: #747474;
+    font-size: 12px;
+}
+
+.bx-note-unsupported {
+    display: block;
+    font-size: 12px;
+    font-style: italic;
+    font-weight: normal;
+    color: #828282;
+}
+
+.bx-settings-tab-contents {
+    > div {
+        // Label at the beginning
+        *:not(.bx-settings-row):has(+ .bx-settings-row) + .bx-settings-row:has(+ .bx-settings-row) {
+            border-top-left-radius: 10px;
+            border-top-right-radius: 10px;
+        }
+
+        // Label at the end
+        .bx-settings-row:not(:has(+ .bx-settings-row)) {
+            border: none;
+            border-bottom-left-radius: 10px;
+            border-bottom-right-radius: 10px;
+        }
+
+        // Single label
+        *:not(.bx-settings-row):has(+ .bx-settings-row) + .bx-settings-row:not(:has(+ .bx-settings-row)) {
+            border: none;
+            border-radius: 10px;
+        }
+    }
+}
+
+.bx-suggest-toggler {
+    text-align: left;
+    display: flex;
+    border-radius: 4px;
+    overflow: hidden;
+    background: #003861;
+
+    label {
+        flex: 1;
+        margin-bottom: 0;
+        padding: 10px;
+        background: #004f87;
+    }
+
+    span {
+        display: inline-block;
+        align-self: center;
+        padding: 10px;
+        width: 40px;
+        text-align: center;
+    }
+
+    &:hover, &:focus {
+        cursor: pointer;
+        background: #005da1;
+
+        label {
+            background: #006fbe;
+        }
+    }
+
+    &[bx-open] {
+        span {
+            transform: rotate(90deg);
+        }
+
+        &+ .bx-suggest-box {
+            display: block;
+        }
+    }
+}
+
+.bx-suggest-box {
+    display: none;
+    background: #161616;
+    padding: 10px;
+    box-shadow: 0px 0px 12px #0f0f0f inset;
+    border-radius: 10px;
+}
+
+.bx-suggest-wrapper {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+    margin: 10px;
+}
+
+.bx-suggest-note {
+    font-size: 11px;
+    color: #8c8c8c;
+    font-style: italic;
+    font-weight: 100;
+}
+
+.bx-suggest-link {
+    font-size: 14px;
+    display: inline-block;
+    margin-top: 4px;
+    padding: 4px;
+}
+
+.bx-suggest-row {
+    display: flex;
+    flex-direction: row;
+    gap: 10px;
+
+    label {
+        flex: 1;
+        overflow: overlay;
+        border-radius: 4px;
+
+        .bx-suggest-label {
+            background: #323232;
+            padding: 4px 10px;
+            font-size: 12px;
+            text-align: left;
+        }
+
+        .bx-suggest-value {
+            padding: 6px;
+            font-size: 14px;
+
+            &.bx-suggest-change {
+                background-color: var(--bx-warning-color);
+            }
+        }
+    }
+
+    &.bx-suggest-ok {
+        input {
+            visibility: hidden;
+        }
+
+        .bx-suggest-label {
+            background-color: #008114;
+        }
+
+        .bx-suggest-value {
+            background-color: #13a72a;
+        }
+    }
+
+    &.bx-suggest-change {
+        .bx-suggest-label {
+            background-color: #a65e08;
+        }
+
+        .bx-suggest-value {
+            background-color: #d57f18;
+        }
+
+        &:hover {
+            label {
+                cursor: pointer;
+            }
+
+            .bx-suggest-label {
+                background-color: #995707;
+            }
+
+            .bx-suggest-value {
+                background-color: #bd7115;
+            }
+        }
+
+        // Unchecked setting
+        input:not(:checked) + label {
+            opacity: 0.5;
+
+            .bx-suggest-label {
+                background-color: #2a2a2a;
+            }
+
+            .bx-suggest-value {
+                background-color: #393939;
+            }
+        }
+
+        &:hover {
+            input:not(:checked) + label {
+                opacity: 1;
+
+                .bx-suggest-label {
+                    background-color: #202020;
+                }
+
+                .bx-suggest-value {
+                    background-color: #303030;
+                }
+            }
+        }
+    }
+}

src/assets/css/stream-settings.styl

@@ -1,194 +0,0 @@
-.bx-stream-settings-dialog {
-    display: flex;
-    position: fixed;
-    z-index: var(--bx-stream-settings-z-index);
-    opacity: 0.98;
-    user-select: none;
-    -webkit-user-select: none;
-}
-
-.bx-stream-settings-tabs {
-    position: fixed;
-    top: 0;
-    right: 420px;
-    display: flex;
-    flex-direction: column;
-    border-radius: 0 0 0 8px;
-    box-shadow: 0px 0px 6px #000;
-    overflow: clip;
-
-    svg {
-        width: 32px;
-        height: 32px;
-        padding: 10px;
-        box-sizing: content-box;
-        background: #131313;
-        cursor: pointer;
-        border-left: 4px solid #1e1e1e;
-
-        &.bx-active {
-            background: #222;
-            border-color: #008746;
-        }
-
-        &:not(.bx-active):hover {
-            background: #2f2f2f;
-            border-color: #484848;
-        }
-    }
-}
-
-
-.bx-stream-settings-tab-contents {
-    flex-direction: column;
-    position: fixed;
-    right: 0;
-    top: 0;
-    bottom: 0;
-    padding: 14px 14px 0;
-    width: 420px;
-    background: #1a1b1e;
-    color: #fff;
-    font-weight: 400;
-    font-size: 16px;
-    font-family: var(--bx-title-font);
-    text-align: center;
-    box-shadow: 0px 0px 6px #000;
-    overflow: overlay;
-
-    > div[data-group=mkb] {
-        display: flex;
-        flex-direction: column;
-        height: 100%;
-        overflow: hidden;
-    }
-
-    *:focus {
-        outline: none !important;
-    }
-
-    h2 {
-        margin-bottom: 8px;
-        display: flex;
-        align-item: center;
-
-        span {
-            display: inline-block;
-            font-size: 24px;
-            font-weight: bold;
-            text-transform: uppercase;
-            text-align: left;
-            flex: 1;
-            height: var(--bx-button-height);
-            line-height: calc(var(--bx-button-height) + 4px);
-            text-overflow: ellipsis;
-            overflow: hidden;
-            white-space: nowrap;
-        }
-    }
-}
-
-
-.bx-stream-settings-row {
-    display: flex;
-    border-bottom: 1px solid #40404080;
-    margin-bottom: 16px;
-    padding-bottom: 16px;
-
-    label {
-        font-size: 16px;
-        display: block;
-        text-align: left;
-        flex: 1;
-        align-self: center;
-        margin-bottom: 0 !important;
-    }
-
-    input {
-        accent-color: var(--bx-primary-button-color);
-    }
-
-    select:disabled {
-        -webkit-appearance: none;
-        background: transparent;
-        text-align-last: right;
-        border: none;
-        color: #fff;
-    }
-
-    select option:disabled {
-        display: none;
-    }
-}
-
-.bx-stream-settings-dialog-note {
-    display: block;
-    font-size: 12px;
-    font-weight: lighter;
-    font-style: italic;
-}
-
-.bx-stream-settings-tab-contents {
-    div[data-group="shortcuts"] {
-        > div {
-            &[data-has-gamepad=true] {
-                > div:first-of-type {
-                    display: none;
-                }
-
-                > div:last-of-type {
-                    display: block;
-                }
-            }
-
-            &[data-has-gamepad=false] {
-                > div:first-of-type {
-                    display: block;
-                }
-
-                > div:last-of-type {
-                    display: none;
-                }
-            }
-        }
-
-        .bx-shortcut-profile {
-            width: 100%;
-            height: 36px;
-            display: block;
-            margin-bottom: 10px;
-        }
-
-        .bx-shortcut-note {
-            font-size: 14px;
-        }
-
-        .bx-shortcut-row {
-            display: flex;
-            margin-bottom: 10px;
-
-            label.bx-prompt {
-                flex: 1;
-                font-size: 26px;
-                margin-bottom: 0;
-            }
-
-            .bx-shortcut-actions {
-                flex: 2;
-                position: relative;
-
-                select {
-                    position: absolute;
-                    width: 100%;
-                    height: 100%;
-                    display: block;
-
-                    &:last-of-type {
-                        opacity: 0;
-                        z-index: calc(var(--bx-stream-settings-z-index) + 1);
-                    }
-                }
-            }
-        }
-    }
-}

src/assets/css/stream-stats.styl

@@ -71,7 +71,9 @@ div[class^=StreamMenu-module__container] .bx-badges {
 
 /* STATS BAR */
 .bx-stats-bar {
-    display: block;
+    display: flex;
+    flex-direction: row;
+    gap: 8px;
     user-select: none;
     -webkit-user-select: none;
     position: fixed;
@@ -84,22 +86,34 @@ div[class^=StreamMenu-module__container] .bx-badges {
     z-index: var(--bx-stats-bar-z-index);
     text-wrap: nowrap;
 
+    &[data-stats*="[time]"] > .bx-stat-time,
+    &[data-stats*="[play]"] > .bx-stat-play,
+    &[data-stats*="[batt]"] > .bx-stat-batt,
     &[data-stats*="[fps]"] > .bx-stat-fps,
     &[data-stats*="[ping]"] > .bx-stat-ping,
+    &[data-stats*="[jit]"] > .bx-stat-jit,
     &[data-stats*="[btr]"] > .bx-stat-btr,
     &[data-stats*="[dt]"] > .bx-stat-dt,
     &[data-stats*="[pl]"] > .bx-stat-pl,
-    &[data-stats*="[fl]"] > .bx-stat-fl {
+    &[data-stats*="[fl]"] > .bx-stat-fl,
-        display: inline-block;
+    &[data-stats*="[dl]"] > .bx-stat-dl,
+    &[data-stats*="[ul]"] > .bx-stat-ul {
+        display: inline-flex;
+        align-items: baseline;
     }
 
+    &[data-stats$="[time]"] > .bx-stat-time,
+    &[data-stats$="[play]"] > .bx-stat-play,
+    &[data-stats$="[batt]"] > .bx-stat-batt,
     &[data-stats$="[fps]"] > .bx-stat-fps,
     &[data-stats$="[ping]"] > .bx-stat-ping,
+    &[data-stats$="[jit]"] > .bx-stat-jit,
     &[data-stats$="[btr]"] > .bx-stat-btr,
     &[data-stats$="[dt]"] > .bx-stat-dt,
     &[data-stats$="[pl]"] > .bx-stat-pl,
-    &[data-stats$="[fl]"] > .bx-stat-fl {
+    &[data-stats$="[fl]"] > .bx-stat-fl,
-        margin-right: 0;
+    &[data-stats$="[dl]"] > .bx-stat-dl,
+    &[data-stats$="[ul]"] > .bx-stat-ul {
         border-right: none;
     }
 
@@ -137,7 +151,6 @@ div[class^=StreamMenu-module__container] .bx-badges {
 
     > div {
         display: none;
-        margin-right: 8px;
         border-right: 1px solid #fff;
         padding-right: 8px;
     }
@@ -145,7 +158,7 @@ div[class^=StreamMenu-module__container] .bx-badges {
     label {
         margin: 0 8px 0 0;
         font-family: var(--bx-title-font);
-        font-size: inherit;
+        font-size: 70%;
         font-weight: bold;
         vertical-align: middle;
         cursor: help;

src/assets/css/styles.styl

@@ -2,15 +2,18 @@
 
 @import 'button.styl';
 @import 'header.styl';
-@import 'global-settings.styl';
 @import 'dialog.styl';
+@import 'navigation-dialog.styl';
+@import 'settings-dialog.styl';
 @import 'toast.styl';
 @import 'loading-screen.styl';
 @import 'remote-play.styl';
+@import 'web-components.styl';
+@import 'guide-menu.styl';
 
 @import 'stream.styl';
 @import 'number-stepper.styl';
 @import 'game-bar.styl';
 @import 'stream-stats.styl';
-@import 'stream-settings.styl';
 @import 'mkb.styl';
+@import 'misc.styl';

src/assets/css/web-components.styl

@@ -0,0 +1,99 @@
+.bx-select {
+    display: flex;
+    align-items: center;
+    flex: 0 1 auto;
+
+    select {
+        // Render offscreen instead of "display: none" so we could get its size
+        position: absolute !important;
+        top: -9999px !important;
+        left: -9999px !important;
+        visibility: hidden !important;
+    }
+
+    > div, button.bx-select-value {
+        min-width: 120px;
+        text-align: left;
+        margin: 0 8px;
+        line-height: 24px;
+        vertical-align: middle;
+        background: #fff;
+        color: #000;
+        border-radius: 4px;
+        padding: 2px 8px;
+        flex: 1;
+    }
+
+    > div {
+        display: inline-block;
+
+        input {
+            display: inline-block;
+            margin-right: 8px;
+        }
+
+        label {
+            margin-bottom: 0;
+            font-size: 14px;
+            width: 100%;
+
+            span {
+                display: block;
+                font-size: 10px;
+                font-weight: bold;
+                text-align: left;
+                line-height: initial;
+            }
+        }
+    }
+
+    button.bx-select-value {
+        border: none;
+        display: inline-flex;
+        cursor: pointer;
+        min-height: 30px;
+        font-size: 0.9rem;
+        align-items: center;
+
+        span {
+            flex: 1;
+            text-align: left;
+            display: inline-block;
+        }
+
+        input {
+            margin: 0 4px;
+            accent-color: var(--bx-primary-button-color);
+            pointer-events: none;
+        }
+
+        &:hover,
+        &:focus {
+            input {
+                accent-color: var(--bx-danger-button-color);
+            }
+
+            &::after {
+                border-color: #4d4d4d !important;
+            }
+        }
+    }
+
+    button.bx-button {
+        border: none;
+        height: 24px;
+        width: 24px;
+        padding: 0;
+        line-height: 24px;
+        color: #fff;
+        border-radius: 4px;
+        font-weight: bold;
+        font-size: 12px;
+        font-family: var(--bx-monospaced-font);
+        flex-shrink: 0;
+
+        span {
+            line-height: unset;
+        }
+    }
+}

src/assets/header_script.lite.txt

@@ -0,0 +1,13 @@
+// ==UserScript==
+// @name         Better xCloud (Lite)
+// @namespace    https://github.com/redphx
+// @version      [[VERSION]]
+// @description  Improve Xbox Cloud Gaming (xCloud) experience
+// @author       redphx
+// @license      MIT
+// @match        https://www.xbox.com/*/play*
+// @match        https://www.xbox.com/*/auth/msa?*loggedIn*
+// @run-at       document-end
+// @grant        none
+// ==/UserScript==
+"use strict";

src/assets/header_script.txt

@@ -12,4 +12,4 @@
 // @updateURL    https://raw.githubusercontent.com/redphx/better-xcloud/typescript/dist/better-xcloud.meta.js
 // @downloadURL  https://github.com/redphx/better-xcloud/releases/latest/download/better-xcloud.user.js
 // ==/UserScript==
-'use strict';
+"use strict";

src/assets/svg/better-xcloud.svg

@@ -0,0 +1,4 @@
+<svg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='#fff' fill-rule='evenodd' stroke-linecap='round' stroke-linejoin='round' stroke-miterlimit='2' stroke-width='2' viewBox='0 0 32 32'>
+    <path d='M16.001 7.236h-2.328c-.443 0-1.941-.851-2.357-.905-.824-.106-1.684 0-2.489.176a13.04 13.04 0 0 0-3.137 1.14c-.392.275-.677.668-.866 1.104v.03l-3.302 8.963-.015.015c-.288.867-.553 3.75-.5 4.279a4.89 4.89 0 0 0 1.022 2.55c.654.823 3.71 1.364 4.057 1.016l4.462-4.475c.185-.186 1.547-.706 2.01-.706h6.884c.463 0 1.825.52 2.01.706l4.462 4.475c.347.348 3.403-.193 4.057-1.016a4.89 4.89 0 0 0 1.022-2.55c.053-.529-.212-3.412-.5-4.279l-.015-.015-3.302-8.963v-.03c-.189-.436-.474-.829-.866-1.104a13.04 13.04 0 0 0-3.137-1.14c-.805-.176-1.665-.282-2.489-.176-.416.054-1.914.905-2.357.905h-2.328' fill='none' stroke='#fff'/>
+    <path d='M8.172 12.914H6.519c-.235 0-.315.267-.335.452l-.052.578c0 .193.033.384.054.576.023.202.091.511.355.511h1.631l-.001 1.652c0 .234.266.315.452.335l.578.052c.193 0 .384-.033.576-.054.203-.023.511-.091.511-.355V15.03l1.652.001c.234 0 .315-.266.335-.452l.052-.578c-.001-.193-.033-.385-.055-.577-.022-.202-.09-.51-.354-.51h-1.632v-1.652c0-.234-.266-.315-.453-.335l-.577-.052c-.193 0-.385.033-.577.054-.202.023-.51.091-.51.355v1.631m16.546 2.994h-3.487c-.206 0-.413-.043-.604-.121-.177-.072-.339-.183-.476-.316-.149-.144-.259-.315-.341-.504-.156-.361-.172-.788-.032-1.157a1.57 1.57 0 0 1 .459-.641c.106-.089.223-.164.349-.222a1.52 1.52 0 0 1 .423-.123c.167-.024.338-.02.504.012a1.83 1.83 0 0 1 .455-.482 1.62 1.62 0 0 1 .522-.252c.307-.089.651-.09.959-.003a1.75 1.75 0 0 1 1.009.764 1.83 1.83 0 0 1 .251.721c.156 0 .312.031.456.09a1.24 1.24 0 0 1 .372.248c.091.087.165.19.221.302a1.19 1.19 0 0 1-.173 1.299c-.119.132-.276.239-.441.305a1.17 1.17 0 0 1-.426.08z' fill='#fff' stroke='none'/>
+</svg>

src/assets/svg/close.svg

@@ -0,0 +1,4 @@
+<svg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='#fff' fill-rule='evenodd' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 32 32'>
+    <path d='M29.928,2.072L2.072,29.928'/>
+    <path d='M29.928,29.928L2.072,2.072'/>
+</svg>

src/assets/svg/create-shortcut.svg

@@ -0,0 +1,4 @@
+<svg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='#fff' fill-rule='evenodd' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 32 32'>
+    <path d='M13.253 3.639c0-.758-.615-1.373-1.373-1.373H3.639c-.758 0-1.373.615-1.373 1.373v8.241c0 .758.615 1.373 1.373 1.373h8.241c.758 0 1.373-.615 1.373-1.373V3.639zm0 16.481c0-.758-.615-1.373-1.373-1.373H3.639c-.758 0-1.373.615-1.373 1.373v8.241c0 .758.615 1.373 1.373 1.373h8.241c.758 0 1.373-.615 1.373-1.373V20.12zm16.481 0c0-.758-.615-1.373-1.373-1.373H20.12c-.758 0-1.373.615-1.373 1.373v8.241c0 .758.615 1.373 1.373 1.373h8.241c.758 0 1.373-.615 1.373-1.373V20.12zM19.262 7.76h9.957'/>
+    <path d='M24.24 2.781v9.957'/>
+</svg>

src/assets/svg/native-mkb.svg

@@ -1,10 +1,10 @@
 <svg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='#fff' fill-rule='evenodd' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 32 32'>
-    <g stroke-width="2.1">
+    <g stroke-width='2.1'>
-        <path d="m15.817 6h-10.604c-2.215 0-4.013 1.798-4.013 4.013v12.213c0 2.215 1.798 4.013 4.013 4.013h11.21"/>
+        <path d='m15.817 6h-10.604c-2.215 0-4.013 1.798-4.013 4.013v12.213c0 2.215 1.798 4.013 4.013 4.013h11.21'/>
-        <path d="m5.698 20.617h1.124m-1.124-4.517h7.9m-7.881-4.5h7.9m-2.3 9h2.2"/>
+        <path d='m5.698 20.617h1.124m-1.124-4.517h7.9m-7.881-4.5h7.9m-2.3 9h2.2'/>
     </g>
-    <g stroke-width="2.13">
+    <g stroke-width='2.13'>
-        <path d="m30.805 13.1c0-3.919-3.181-7.1-7.1-7.1s-7.1 3.181-7.1 7.1v6.4c0 3.919 3.182 7.1 7.1 7.1s7.1-3.181 7.1-7.1z"/>
+        <path d='m30.805 13.1c0-3.919-3.181-7.1-7.1-7.1s-7.1 3.181-7.1 7.1v6.4c0 3.919 3.182 7.1 7.1 7.1s7.1-3.181 7.1-7.1z'/>
-        <path d="m23.705 14.715v-4.753"/>
+        <path d='m23.705 14.715v-4.753'/>
     </g>
 </svg>

src/assets/svg/power.svg

@@ -0,0 +1,3 @@
+<svg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='#fff' fill-rule='evenodd' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 32 32'>
+    <path d='M16 2.445v12.91m7.746-11.619C27.631 6.27 30.2 10.37 30.2 15.355c0 7.79-6.41 14.2-14.2 14.2s-14.2-6.41-14.2-14.2c0-4.985 2.569-9.085 6.454-11.619'/>
+</svg>

src/assets/svg/speaker-slash.svg

@@ -0,0 +1,3 @@
+<svg xmlns='http://www.w3.org/2000/svg' fill='#fff' stroke='none' fill-rule='evenodd' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 32 32'>
+    <path d='M5.462 3.4c-.205-.23-.499-.363-.808-.363-.592 0-1.079.488-1.079 1.08a1.08 1.08 0 0 0 .289.736l4.247 4.672H2.504a2.17 2.17 0 0 0-2.16 2.16v8.637a2.17 2.17 0 0 0 2.16 2.16h6.107l9.426 7.33a1.08 1.08 0 0 0 .662.227c.592 0 1.08-.487 1.08-1.079v-6.601l5.679 6.247a1.08 1.08 0 0 0 .808.363c.592 0 1.08-.487 1.08-1.079a1.08 1.08 0 0 0-.29-.736L5.462 3.4zm-2.958 8.285h5.398v8.637H2.504v-8.637zM17.62 26.752l-7.558-5.878V11.67l7.558 8.313v6.769zm5.668-8.607c1.072-1.218 1.072-3.063 0-4.281a1.08 1.08 0 0 1-.293-.74c0-.592.487-1.079 1.079-1.079a1.08 1.08 0 0 1 .834.393 5.42 5.42 0 0 1 0 7.137 1.08 1.08 0 0 1-.81.365c-.593 0-1.08-.488-1.08-1.08 0-.263.096-.517.27-.715zM12.469 7.888c-.147-.19-.228-.423-.228-.663a1.08 1.08 0 0 1 .417-.853l5.379-4.184a1.08 1.08 0 0 1 .662-.227c.593 0 1.08.488 1.08 1.08v10.105c0 .593-.487 1.08-1.08 1.08s-1.079-.487-1.079-1.08V5.255l-3.636 2.834c-.469.362-1.153.273-1.515-.196v-.005zm19.187 8.115a10.79 10.79 0 0 1-2.749 7.199 1.08 1.08 0 0 1-.793.347c-.593 0-1.08-.487-1.08-1.079 0-.26.094-.511.264-.708 2.918-3.262 2.918-8.253 0-11.516-.184-.2-.287-.461-.287-.733 0-.592.487-1.08 1.08-1.08a1.08 1.08 0 0 1 .816.373 10.78 10.78 0 0 1 2.749 7.197z' fill-rule='nonzero'/>
+</svg>

src/assets/svg/true-achievements.svg

@@ -0,0 +1,3 @@
+<svg xmlns='http://www.w3.org/2000/svg' fill='#fff' stroke='nons' fill-rule='evenodd' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 32 32'>
+    <path d='M2.497 14.127c.781-6.01 5.542-10.849 11.551-11.708V0C6.634.858.858 6.712 0 14.127h2.497zM17.952 2.419V0C25.366.858 31.142 6.712 32 14.127h-2.497c-.781-6.01-5.542-10.849-11.551-11.708zM2.497 17.873c.781 6.01 5.542 10.849 11.551 11.708V32C6.634 31.142.858 25.288 0 17.873h2.497zm27.006 0H32C31.142 25.288 25.366 31.142 17.952 32v-2.419c6.009-.859 10.77-5.698 11.551-11.708zm-19.2-4.527h2.028a.702.702 0 1 0 0-1.404h-2.107a1.37 1.37 0 0 1-1.326-1.327V9.21a.7.7 0 0 0-.703-.703c-.387 0-.703.316-.703.7v1.408c.079 1.483 1.25 2.731 2.811 2.731zm2.809 7.337h-2.888a1.37 1.37 0 0 1-1.326-1.327v-4.917c0-.387-.316-.703-.7-.703a.7.7 0 0 0-.706.703v4.917a2.77 2.77 0 0 0 2.732 2.732h2.81c.387 0 .702-.316.702-.7.078-.393-.234-.705-.624-.705zM25.6 19.2a.7.7 0 0 0-.702-.702c-.387 0-.703.316-.703.699v.081c0 .702-.546 1.326-1.248 1.326H19.98c-.702-.078-1.248-.624-1.248-1.326v-.312c0-.78.624-1.327 1.326-1.327h2.811a2.77 2.77 0 0 0 2.731-2.732v-.312a2.68 2.68 0 0 0-2.576-2.732h-4.76a.702.702 0 1 0 0 1.405h4.526a1.37 1.37 0 0 1 1.327 1.327v.234c0 .781-.624 1.327-1.327 1.327h-2.81a2.77 2.77 0 0 0-2.731 2.732v.312a2.77 2.77 0 0 0 2.731 2.732h2.967a2.74 2.74 0 0 0 2.575-2.732s.078.078.078 0z'/>
+</svg>

src/assets/svg/virtual-controller.svg

@@ -1,11 +1,11 @@
 <svg xmlns='http://www.w3.org/2000/svg' fill='none' stroke='#fff' fill-rule='evenodd' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' viewBox='0 0 32 32'>
-    <g stroke-width="2.06">
+    <g stroke-width='2.06'>
-        <path d="M8.417 13.218h4.124"/>
+        <path d='M8.417 13.218h4.124'/>
-        <path d="M10.479 11.155v4.125"/>
+        <path d='M10.479 11.155v4.125'/>
-        <path d="M12.787 19.404L7.36 25.565a3.61 3.61 0 0 1-2.551 1.056A3.63 3.63 0 0 1 1.2 23.013c0-.21.018-.42.055-.626l2.108-10.845C3.923 8.356 6.714 6.007 9.949 6h5.192"/>
+        <path d='M12.787 19.404L7.36 25.565a3.61 3.61 0 0 1-2.551 1.056A3.63 3.63 0 0 1 1.2 23.013c0-.21.018-.42.055-.626l2.108-10.845C3.923 8.356 6.714 6.007 9.949 6h5.192'/>
     </g>
-    <g stroke-width="2.11">
+    <g stroke-width='2.11'>
-        <path d="M30.8 13.1c0-3.919-3.181-7.1-7.1-7.1s-7.1 3.181-7.1 7.1v6.421c0 3.919 3.181 7.1 7.1 7.1s7.1-3.181 7.1-7.1V13.1z"/>
+        <path d='M30.8 13.1c0-3.919-3.181-7.1-7.1-7.1s-7.1 3.181-7.1 7.1v6.421c0 3.919 3.181 7.1 7.1 7.1s7.1-3.181 7.1-7.1V13.1z'/>
-        <path d="M23.7 14.724V9.966"/>
+        <path d='M23.7 14.724V9.966'/>
     </g>
 </svg>

src/enums/bypass-servers.ts

@@ -0,0 +1,17 @@
+import { t } from "@/utils/translation"
+
+export const BypassServers = {
+    'br': t('brazil'),
+    'jp': t('japan'),
+    'kr': t('korea'),
+    'pl': t('poland'),
+    'us': t('united-states'),
+}
+
+export const BypassServerIps: Record<keyof typeof BypassServers, string> = {
+    'br': '169.150.198.66',
+    'kr': '121.125.60.151',
+    'jp': '138.199.21.239',
+    'pl': '45.134.212.66',
+    'us': '143.244.47.65',
+}

src/enums/game-pass-gallery.ts

@@ -1,5 +1,6 @@
 export enum GamePassCloudGallery {
     ALL = '29a81209-df6f-41fd-a528-2ae6b91f719c',
+    MOST_POPULAR = 'e7590b22-e299-44db-ae22-25c61405454c',
     NATIVE_MKB = '8fa264dd-124f-4af3-97e8-596fcdf4b486',
     TOUCH = '9c86f07a-f3e8-45ad-82a0-a1f759597059',
 }

src/enums/pref-keys.ts

@@ -0,0 +1,103 @@
+export enum StorageKey {
+    GLOBAL = 'better_xcloud',
+}
+
+export enum PrefKey {
+    LAST_UPDATE_CHECK = 'version_last_check',
+    LATEST_VERSION = 'version_latest',
+    CURRENT_VERSION = 'version_current',
+
+    BETTER_XCLOUD_LOCALE = 'bx_locale',
+
+    SERVER_REGION = 'server_region',
+    SERVER_BYPASS_RESTRICTION = 'server_bypass_restriction',
+
+    PREFER_IPV6_SERVER = 'prefer_ipv6_server',
+    STREAM_TARGET_RESOLUTION = 'stream_target_resolution',
+    STREAM_PREFERRED_LOCALE = 'stream_preferred_locale',
+    STREAM_CODEC_PROFILE = 'stream_codec_profile',
+
+    USER_AGENT_PROFILE = 'user_agent_profile',
+    STREAM_SIMPLIFY_MENU = 'stream_simplify_menu',
+
+    STREAM_COMBINE_SOURCES = 'stream_combine_sources',
+
+    STREAM_TOUCH_CONTROLLER = 'stream_touch_controller',
+    STREAM_TOUCH_CONTROLLER_AUTO_OFF = 'stream_touch_controller_auto_off',
+    STREAM_TOUCH_CONTROLLER_DEFAULT_OPACITY = 'stream_touch_controller_default_opacity',
+    STREAM_TOUCH_CONTROLLER_STYLE_STANDARD = 'stream_touch_controller_style_standard',
+    STREAM_TOUCH_CONTROLLER_STYLE_CUSTOM = 'stream_touch_controller_style_custom',
+
+    STREAM_DISABLE_FEEDBACK_DIALOG = 'stream_disable_feedback_dialog',
+
+    BITRATE_VIDEO_MAX = 'bitrate_video_max',
+
+    GAME_BAR_POSITION = 'game_bar_position',
+
+    LOCAL_CO_OP_ENABLED = 'local_co_op_enabled',
+    // LOCAL_CO_OP_SEPARATE_TOUCH_CONTROLLER = 'local_co_op_separate_touch_controller',
+
+    CONTROLLER_ENABLE_SHORTCUTS = 'controller_enable_shortcuts',
+    CONTROLLER_ENABLE_VIBRATION = 'controller_enable_vibration',
+    CONTROLLER_DEVICE_VIBRATION = 'controller_device_vibration',
+    CONTROLLER_VIBRATION_INTENSITY = 'controller_vibration_intensity',
+    CONTROLLER_SHOW_CONNECTION_STATUS = 'controller_show_connection_status',
+
+    NATIVE_MKB_ENABLED = 'native_mkb_enabled',
+    NATIVE_MKB_SCROLL_HORIZONTAL_SENSITIVITY = 'native_mkb_scroll_x_sensitivity',
+    NATIVE_MKB_SCROLL_VERTICAL_SENSITIVITY = 'native_mkb_scroll_y_sensitivity',
+
+    MKB_ENABLED = 'mkb_enabled',
+    MKB_HIDE_IDLE_CURSOR = 'mkb_hide_idle_cursor',
+    MKB_ABSOLUTE_MOUSE = 'mkb_absolute_mouse',
+    MKB_DEFAULT_PRESET_ID = 'mkb_default_preset_id',
+
+    SCREENSHOT_APPLY_FILTERS = 'screenshot_apply_filters',
+
+    BLOCK_TRACKING = 'block_tracking',
+    BLOCK_SOCIAL_FEATURES = 'block_social_features',
+    SKIP_SPLASH_VIDEO = 'skip_splash_video',
+    HIDE_DOTS_ICON = 'hide_dots_icon',
+    REDUCE_ANIMATIONS = 'reduce_animations',
+
+    UI_LOADING_SCREEN_GAME_ART = 'ui_loading_screen_game_art',
+    UI_LOADING_SCREEN_WAIT_TIME = 'ui_loading_screen_wait_time',
+    UI_LOADING_SCREEN_ROCKET = 'ui_loading_screen_rocket',
+
+    UI_CONTROLLER_FRIENDLY = 'ui_controller_friendly',
+    UI_LAYOUT = 'ui_layout',
+    UI_SCROLLBAR_HIDE = 'ui_scrollbar_hide',
+    UI_HIDE_SECTIONS = 'ui_hide_sections',
+
+    UI_HOME_CONTEXT_MENU_DISABLED = 'ui_home_context_menu_disabled',
+    UI_GAME_CARD_SHOW_WAIT_TIME = 'ui_game_card_show_wait_time',
+
+    VIDEO_PLAYER_TYPE = 'video_player_type',
+    VIDEO_PROCESSING = 'video_processing',
+    VIDEO_POWER_PREFERENCE = 'video_power_preference',
+    VIDEO_MAX_FPS = 'video_max_fps',
+    VIDEO_SHARPNESS = 'video_sharpness',
+    VIDEO_RATIO = 'video_ratio',
+    VIDEO_BRIGHTNESS = 'video_brightness',
+    VIDEO_CONTRAST = 'video_contrast',
+    VIDEO_SATURATION = 'video_saturation',
+
+    AUDIO_MIC_ON_PLAYING = 'audio_mic_on_playing',
+    AUDIO_ENABLE_VOLUME_CONTROL = 'audio_enable_volume_control',
+    AUDIO_VOLUME = 'audio_volume',
+
+    STATS_ITEMS = 'stats_items',
+    STATS_SHOW_WHEN_PLAYING = 'stats_show_when_playing',
+    STATS_QUICK_GLANCE = 'stats_quick_glance',
+    STATS_POSITION = 'stats_position',
+    STATS_TEXT_SIZE = 'stats_text_size',
+    STATS_TRANSPARENT = 'stats_transparent',
+    STATS_OPACITY = 'stats_opacity',
+    STATS_CONDITIONAL_FORMATTING = 'stats_conditional_formatting',
+
+    REMOTE_PLAY_ENABLED = 'xhome_enabled',
+    REMOTE_PLAY_RESOLUTION = 'xhome_resolution',
+
+    GAME_FORTNITE_FORCE_CONSOLE = 'game_fortnite_force_console',
+    GAME_MSFS2020_FORCE_NATIVE_MKB = 'game_msfs2020_force_native_mkb',
+}

src/enums/ui-sections.ts

@@ -0,0 +1,8 @@
+export enum UiSection {
+    ALL_GAMES = 'all-games',
+    FRIENDS = 'friends',
+    MOST_POPULAR = 'most-popular',
+    NATIVE_MKB = 'native-mkb',
+    NEWS = 'news',
+    TOUCH = 'touch',
+}

src/enums/user-agent.ts

@@ -1,10 +1,9 @@
 export enum UserAgentProfile {
     WINDOWS_EDGE = 'windows-edge',
     MACOS_SAFARI = 'macos-safari',
-    SMARTTV_GENERIC = 'smarttv-generic',
+    SMART_TV_GENERIC = 'smarttv-generic',
-    SMARTTV_TIZEN = 'smarttv-tizen',
+    SMART_TV_TIZEN = 'smarttv-tizen',
     VR_OCULUS = 'vr-oculus',
-    ANDROID_KIWI_V123 = 'android-kiwi-v123',
     DEFAULT = 'default',
     CUSTOM = 'custom',
 }

src/index.ts

@@ -1,3 +1,5 @@
+import { compressCss, isFullVersion } from "@macros/build" with {type: "macro"};
+
 import "@utils/global";
 import { BxEvent } from "@utils/bx-event";
 import { BX_FLAGS } from "@utils/bx-flags";
@@ -9,81 +11,137 @@ import { showGamepadToast } from "@utils/gamepad";
 import { EmulatedMkbHandler } from "@modules/mkb/mkb-handler";
 import { StreamBadges } from "@modules/stream/stream-badges";
 import { StreamStats } from "@modules/stream/stream-stats";
-import { addCss } from "@utils/css";
+import { addCss, preloadFonts } from "@utils/css";
 import { Toast } from "@utils/toast";
-import { setupStreamUi, updateVideoPlayer } from "@modules/ui/ui";
-import { PrefKey, getPref } from "@utils/preferences";
 import { LoadingScreen } from "@modules/loading-screen";
 import { MouseCursorHider } from "@modules/mkb/mouse-cursor-hider";
 import { TouchController } from "@modules/touch-controller";
-import { watchHeader } from "@modules/ui/header";
+import { checkForUpdate, disablePwa, productTitleToSlug } from "@utils/utils";
-import { checkForUpdate, disablePwa } from "@utils/utils";
 import { Patcher } from "@modules/patcher";
-import { RemotePlay } from "@modules/remote-play";
+import { RemotePlayManager } from "@/modules/remote-play-manager";
 import { onHistoryChanged, patchHistoryMethod } from "@utils/history";
 import { VibrationManager } from "@modules/vibration-manager";
 import { overridePreloadState } from "@utils/preload-state";
-import { patchAudioContext, patchCanvasContext, patchMeControl, patchPointerLockApi, patchRtcCodecs, patchRtcPeerConnection, patchVideoApi } from "@utils/monkey-patches";
+import { disableAdobeAudienceManager, patchAudioContext, patchCanvasContext, patchMeControl, patchPointerLockApi, patchRtcCodecs, patchRtcPeerConnection, patchVideoApi } from "@utils/monkey-patches";
 import { AppInterface, STATES } from "@utils/global";
-import { injectStreamMenuButtons } from "@modules/stream/stream-ui";
 import { BxLogger } from "@utils/bx-logger";
 import { GameBar } from "./modules/game-bar/game-bar";
 import { Screenshot } from "./utils/screenshot";
 import { NativeMkbHandler } from "./modules/mkb/native-mkb-handler";
-import { GuideMenu, GuideMenuTab } from "./modules/ui/guide-menu";
+import { GuideMenu } from "./modules/ui/guide-menu";
-
+import { updateVideoPlayer } from "./modules/stream/stream-settings-utils";
+import { UiSection } from "./enums/ui-sections";
+import { HeaderSection } from "./modules/ui/header";
+import { GameTile } from "./modules/ui/game-tile";
+import { ProductDetailsPage } from "./modules/ui/product-details";
+import { NavigationDialogManager } from "./modules/ui/dialog/navigation-dialog";
+import { PrefKey } from "./enums/pref-keys";
+import { getPref, StreamTouchController } from "./utils/settings-storages/global-settings-storage";
+import { SettingsNavigationDialog } from "./modules/ui/dialog/settings-dialog";
+import { StreamUiHandler } from "./modules/stream/stream-ui";
+import { UserAgent } from "./utils/user-agent";
+import { XboxApi } from "./utils/xbox-api";
+import { StreamStatsCollector } from "./utils/stream-stats-collector";
 
 // Handle login page
 if (window.location.pathname.includes('/auth/msa')) {
-    window.addEventListener('load', e => {
+    const nativePushState = window.history['pushState'];
-            window.location.search.includes('loggedIn') && window.setTimeout(() => {
+    window.history['pushState'] = function(...args: any[]) {
-                const location = window.location;
+        const url = args[2];
-                // @ts-ignore
+        if (url && (url.startsWith('/play') || url.substring(6).startsWith('/play'))) {
-                location.pathname.includes('/play') && location.reload(true);
+            console.log('Redirecting to xbox.com/play');
-            }, 2000);
+            window.stop();
-        });
+            window.location.href = 'https://www.xbox.com' + url;
+            return;
+        }
+
+        // @ts-ignore
+        return nativePushState.apply(this, arguments);
+    }
     // Stop processing the script
     throw new Error('[Better xCloud] Refreshing the page after logging in');
 }
 
 BxLogger.info('readyState', document.readyState);
 
-if (BX_FLAGS.SafariWorkaround && document.readyState !== 'loading') {
+if (isFullVersion() && BX_FLAGS.SafariWorkaround && document.readyState !== 'loading') {
     // Stop loading
     window.stop();
 
-    // Show the reloading overlay
+    // We need to set it to an empty string first to work around Bun's bug
-    const css = `
+    // https://github.com/oven-sh/bun/issues/12067
+    let css = '';
+    css += compressCss(`
 .bx-reload-overlay {
     position: fixed;
     top: 0;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    display: flex;
+    align-items: center;
     background: #000000cc;
     z-index: 9999;
-    width: 100%;
-    line-height: 100vh;
     color: #fff;
     text-align: center;
     font-weight: 400;
     font-family: "Segoe UI", Arial, Helvetica, sans-serif;
     font-size: 1.3rem;
 }
-`;
+
+.bx-reload-overlay *:focus {
+    outline: none !important;
+}
+
+.bx-reload-overlay > div {
+    margin: 0 auto;
+}
+
+.bx-reload-overlay a {
+    text-decoration: none;
+    display: inline-block;
+    background: #107c10;
+    color: white;
+    border-radius: 4px;
+    padding: 6px;
+}
+`);
+
+    const isSafari = UserAgent.isSafari();
+    let $secondaryAction: HTMLElement;
+    if (isSafari) {
+        $secondaryAction = CE('p', {}, t('settings-reloading'));
+    } else {
+        $secondaryAction = CE('a', {
+            href: 'https://better-xcloud.github.io/troubleshooting',
+            target: '_blank',
+        }, '🤓 ' + t('how-to-fix'));
+    }
+
+    // Show the reloading overlay
     const $fragment = document.createDocumentFragment();
     $fragment.appendChild(CE('style', {}, css));
-    $fragment.appendChild(CE('div', {'class': 'bx-reload-overlay'}, t('safari-failed-message')));
+    $fragment.appendChild(CE('div',{
+        class: 'bx-reload-overlay',
+    },
+        CE('div', {},
+            CE('p', {}, t('load-failed-message')),
+            $secondaryAction,
+        ),
+    ));
 
     document.documentElement.appendChild($fragment);
 
-    // Reload the page
+    // Reload the page if using Safari
     // @ts-ignore
-    window.location.reload(true);
+    isSafari && window.location.reload(true);
 
     // Stop processing the script
     throw new Error('[Better xCloud] Executing workaround for Safari');
 }
 
-// Automatically reload the page when running into the "We are sorry..." error message
 window.addEventListener('load', e => {
+    // Automatically reload the page when running into the "We are sorry..." error message
     window.setTimeout(() => {
         if (document.body.classList.contains('legacyBackground')) {
             // Has error message -> reload page
@@ -94,6 +152,31 @@ window.addEventListener('load', e => {
     }, 3000);
 });
 
+document.addEventListener('readystatechange', e => {
+    if (document.readyState !== 'interactive') {
+        return;
+    }
+
+    STATES.isSignedIn = !!((window as any).xbcUser?.isSignedIn);
+
+    if (STATES.isSignedIn) {
+        // Preload Remote Play
+        getPref(PrefKey.REMOTE_PLAY_ENABLED) && RemotePlayManager.getInstance().initialize();
+    } else {
+        // Show Settings button in the header when not signed in
+        window.setTimeout(HeaderSection.watchHeader, 2000);
+    }
+
+    // Hide "Play with Friends" skeleton section
+    if (getPref(PrefKey.UI_HIDE_SECTIONS).includes(UiSection.FRIENDS)) {
+        const $parent = document.querySelector('div[class*=PlayWithFriendsSkeleton]')?.closest('div[class*=HomePage-module]') as HTMLElement;
+        $parent && ($parent.style.display = 'none');
+    }
+
+    // Preload fonts
+    preloadFonts();
+})
+
 window.BX_EXPOSED = BxExposed;
 
 // Hide Settings UI when navigate to another page
@@ -105,30 +188,29 @@ window.addEventListener('popstate', onHistoryChanged);
 window.history.pushState = patchHistoryMethod('pushState');
 window.history.replaceState = patchHistoryMethod('replaceState');
 
-window.addEventListener(BxEvent.XCLOUD_SERVERS_READY, e => {
+window.addEventListener(BxEvent.XCLOUD_SERVERS_UNAVAILABLE, e => {
-    // Start rendering UI
+    STATES.supportedRegion = false;
-    if (document.querySelector('div[class^=UnsupportedMarketPage]')) {
+    window.setTimeout(HeaderSection.watchHeader, 2000);
-        window.setTimeout(watchHeader, 2000);
+
-    } else {
+    // Open Settings dialog on Unsupported page
-        watchHeader();
+    const $unsupportedPage = document.querySelector('div[class^=UnsupportedMarketPage-module__container]') as HTMLElement;
+    if ($unsupportedPage) {
+        SettingsNavigationDialog.getInstance().show();
     }
+}, {once: true});
+
+window.addEventListener(BxEvent.XCLOUD_SERVERS_READY, e => {
+    STATES.isSignedIn = true;
+    window.setTimeout(HeaderSection.watchHeader, 2000);
 });
 
 window.addEventListener(BxEvent.STREAM_LOADING, e => {
     // Get title ID for screenshot's name
-    if (window.location.pathname.includes('/launch/')) {
+    if (window.location.pathname.includes('/launch/') && STATES.currentStream.titleInfo) {
-        const matches = /\/launch\/(?<title_id>[^\/]+)\/(?<product_id>\w+)/.exec(window.location.pathname);
+        STATES.currentStream.titleSlug = productTitleToSlug(STATES.currentStream.titleInfo.product.title);
-        if (matches?.groups) {
-            STATES.currentStream.titleId = matches.groups.title_id;
-            STATES.currentStream.productId = matches.groups.product_id;
-        }
     } else {
-        STATES.currentStream.titleId = 'remote-play';
+        STATES.currentStream.titleSlug = 'remote-play';
-        STATES.currentStream.productId = '';
     }
-
-    // Setup UI
-    setupStreamUi();
 });
 
 // Setup loading screen
@@ -147,17 +229,19 @@ window.addEventListener(BxEvent.STREAM_STARTING, e => {
 
 window.addEventListener(BxEvent.STREAM_PLAYING, e => {
     STATES.isPlaying = true;
-    injectStreamMenuButtons();
+    StreamUiHandler.observe();
 
-    if (getPref(PrefKey.GAME_BAR_POSITION) !== 'off') {
+    if (isFullVersion() && getPref(PrefKey.GAME_BAR_POSITION) !== 'off') {
         const gameBar = GameBar.getInstance();
         gameBar.reset();
         gameBar.enable();
         gameBar.showBar();
     }
 
-    const $video = (e as any).$video as HTMLVideoElement;
+    if (isFullVersion()) {
-    Screenshot.updateCanvasSize($video.videoWidth, $video.videoHeight);
+        const $video = (e as any).$video as HTMLVideoElement;
+        Screenshot.updateCanvasSize($video.videoWidth, $video.videoHeight);
+    }
 
     updateVideoPlayer();
 });
@@ -166,14 +250,55 @@ window.addEventListener(BxEvent.STREAM_ERROR_PAGE, e => {
     BxEvent.dispatch(window, BxEvent.STREAM_STOPPED);
 });
 
+window.addEventListener(BxEvent.XCLOUD_RENDERING_COMPONENT, e => {
+    const component = (e as any).component;
+    if (component === 'product-details') {
+        ProductDetailsPage.injectButtons();
+    }
+});
+
+// Detect game change
+window.addEventListener(BxEvent.DATA_CHANNEL_CREATED, e => {
+    const dataChannel = (e as any).dataChannel;
+    if (!dataChannel || dataChannel.label !== 'message') {
+        return;
+    }
+
+    dataChannel.addEventListener('message', async (msg: MessageEvent) => {
+        if (msg.origin === 'better-xcloud' || typeof msg.data !== 'string') {
+            return;
+        }
+
+        // Get xboxTitleId from message
+        if (msg.data.includes('/titleinfo')) {
+            const json = JSON.parse(JSON.parse(msg.data).content);
+            const xboxTitleId = parseInt(json.titleid, 16);
+            STATES.currentStream.xboxTitleId = xboxTitleId;
+
+            // Get titleSlug for Remote Play
+            if (STATES.remotePlay.isPlaying) {
+                STATES.currentStream.titleSlug = 'remote-play';
+                if (json.focused) {
+                    const productTitle = await XboxApi.getProductTitle(xboxTitleId);
+                    if (productTitle) {
+                        STATES.currentStream.titleSlug = productTitleToSlug(productTitle);
+                    }
+                }
+            }
+        }
+    });
+});
+
 function unload() {
     if (!STATES.isPlaying) {
         return;
     }
 
-    // Stop MKB listeners
+    if (isFullVersion()) {
-    EmulatedMkbHandler.getInstance().destroy();
+        // Stop MKB listeners
-    NativeMkbHandler.getInstance().destroy();
+        EmulatedMkbHandler.getInstance().destroy();
+        NativeMkbHandler.getInstance().destroy();
+    }
 
     // Destroy StreamPlayer
     STATES.currentStream.streamPlayer?.destroy();
@@ -183,16 +308,14 @@ function unload() {
     window.BX_EXPOSED.shouldShowSensorControls = false;
     window.BX_EXPOSED.stopTakRendering = false;
 
-    const $streamSettingsDialog = document.querySelector('.bx-stream-settings-dialog');
+    NavigationDialogManager.getInstance().hide();
-    if ($streamSettingsDialog) {
-        $streamSettingsDialog.classList.add('bx-gone');
-    }
-
     StreamStats.getInstance().onStoppedPlaying();
 
-    MouseCursorHider.stop();
+    if (isFullVersion()) {
-    TouchController.reset();
+        MouseCursorHider.stop();
-    GameBar.getInstance().disable();
+        TouchController.reset();
+        GameBar.getInstance().disable();
+    }
 }
 
 window.addEventListener(BxEvent.STREAM_STOPPED, unload);
@@ -200,13 +323,13 @@ window.addEventListener('pagehide', e => {
     BxEvent.dispatch(window, BxEvent.STREAM_STOPPED);
 });
 
-window.addEventListener(BxEvent.CAPTURE_SCREENSHOT, e => {
+isFullVersion() && window.addEventListener(BxEvent.CAPTURE_SCREENSHOT, e => {
     Screenshot.takeScreenshot();
 });
 
 
 function observeRootDialog($root: HTMLElement) {
-    let currentShown = false;
+    let beingShown = false;
 
     const observer = new MutationObserver(mutationList => {
         for (const mutation of mutationList) {
@@ -214,31 +337,20 @@ function observeRootDialog($root: HTMLElement) {
                 continue;
             }
 
+            BX_FLAGS.Debug && BxLogger.warning('RootDialog', 'added', mutation.addedNodes);
             if (mutation.addedNodes.length === 1) {
                 const $addedElm = mutation.addedNodes[0];
                 if ($addedElm instanceof HTMLElement && $addedElm.className) {
-                    if ($addedElm.className.startsWith('NavigationAnimation') || $addedElm.className.startsWith('DialogRoutes') || $addedElm.className.startsWith('Dialog-module__container')) {
+                    // Make sure it's Guide dialog
-                        // Make sure it's Guide dialog
+                    if ($root.querySelector('div[class*=GuideDialog]')) {
-                        if (document.querySelector('#gamepass-dialog-root div[class*=GuideDialog]')) {
+                        GuideMenu.observe($addedElm);
-                            // Find navigation bar
-                            const $selectedTab = $addedElm.querySelector('div[class^=NavigationMenu] button[aria-selected=true');
-                            if ($selectedTab) {
-                                let $elm: Element | null = $selectedTab;
-                                let index;
-                                for (index = 0; ($elm = $elm?.previousElementSibling); index++);
-
-                                if (index === 0) {
-                                    BxEvent.dispatch(window, BxEvent.XCLOUD_GUIDE_MENU_SHOWN, {where: GuideMenuTab.HOME});
-                                }
-                            }
-                        }
                     }
                 }
             }
 
-            const shown = ($root.firstElementChild && $root.firstElementChild.childElementCount > 0) || false;
+            const shown = !!($root.firstElementChild && $root.firstElementChild.childElementCount > 0);
-            if (shown !== currentShown) {
+            if (shown !== beingShown) {
-                currentShown = shown;
+                beingShown = shown;
                 BxEvent.dispatch(window, shown ? BxEvent.XCLOUD_DIALOG_SHOWN : BxEvent.XCLOUD_DIALOG_DISMISSED);
             }
         }
@@ -266,7 +378,9 @@ function waitForRootDialog() {
 
 
 function main() {
-    waitForRootDialog();
+    if (getPref(PrefKey.GAME_MSFS2020_FORCE_NATIVE_MKB)) {
+        BX_FLAGS.ForceNativeMkbTitles.push('9PMQDM08SNK9');
+    }
 
     // Monkey patches
     patchRtcPeerConnection();
@@ -274,51 +388,66 @@ function main() {
     interceptHttpRequests();
     patchVideoApi();
     patchCanvasContext();
-    AppInterface && patchPointerLockApi();
+    isFullVersion() && AppInterface && patchPointerLockApi();
 
     getPref(PrefKey.AUDIO_ENABLE_VOLUME_CONTROL) && patchAudioContext();
-    getPref(PrefKey.BLOCK_TRACKING) && patchMeControl();
 
-    STATES.userAgentHasTouchSupport && TouchController.updateCustomList();
+    if (getPref(PrefKey.BLOCK_TRACKING)) {
-    overridePreloadState();
+        patchMeControl();
+        disableAdobeAudienceManager();
+    }
 
-    VibrationManager.initialSetup();
+    waitForRootDialog();
-
-    // Check for Update
-    BX_FLAGS.CheckForUpdate && checkForUpdate();
 
     // Setup UI
     addCss();
     Toast.setup();
-    (getPref(PrefKey.GAME_BAR_POSITION) !== 'off') && GameBar.getInstance();
-    BX_FLAGS.PreloadUi && setupStreamUi();
 
-    GuideMenu.observe();
+    GuideMenu.addEventListeners();
+    StreamStatsCollector.setupEvents();
     StreamBadges.setupEvents();
     StreamStats.setupEvents();
-    EmulatedMkbHandler.setupEvents();
 
-    Patcher.init();
+    if (isFullVersion()) {
+        (getPref(PrefKey.GAME_BAR_POSITION) !== 'off') && GameBar.getInstance();
+        Screenshot.setup();
 
-    disablePwa();
+        STATES.userAgent.capabilities.touch && TouchController.updateCustomList();
+        overridePreloadState();
+
+        VibrationManager.initialSetup();
+
+        // Check for Update
+        BX_FLAGS.CheckForUpdate && checkForUpdate();
+
+        Patcher.init();
+        disablePwa();
+
+        // Preload Remote Play
+        if (getPref(PrefKey.REMOTE_PLAY_ENABLED)) {
+            RemotePlayManager.detect();
+        }
+
+        if (getPref(PrefKey.STREAM_TOUCH_CONTROLLER) === StreamTouchController.ALL) {
+            TouchController.setup();
+        }
+
+        // Start PointerProviderServer
+        if (getPref(PrefKey.MKB_ENABLED) && AppInterface) {
+            STATES.pointerServerPort = AppInterface.startPointerServer() || 9269;
+            BxLogger.info('startPointerServer', 'Port', STATES.pointerServerPort.toString());
+        }
+
+        // Show wait time in game card
+        getPref(PrefKey.UI_GAME_CARD_SHOW_WAIT_TIME) && GameTile.setup();
+
+        EmulatedMkbHandler.setupEvents();
+    }
 
     // Show a toast when connecting/disconecting controller
-    window.addEventListener('gamepadconnected', e => showGamepadToast(e.gamepad));
+    if (getPref(PrefKey.CONTROLLER_SHOW_CONNECTION_STATUS)) {
-    window.addEventListener('gamepaddisconnected', e => showGamepadToast(e.gamepad));
+        window.addEventListener('gamepadconnected', e => showGamepadToast(e.gamepad));
-
+        window.addEventListener('gamepaddisconnected', e => showGamepadToast(e.gamepad));
-    // Preload Remote Play
-    if (getPref(PrefKey.REMOTE_PLAY_ENABLED)) {
-        RemotePlay.detect();
-    }
-
-    if (getPref(PrefKey.STREAM_TOUCH_CONTROLLER) === 'all') {
-        TouchController.setup();
-    }
-
-    // Start PointerProviderServer
-    if (getPref(PrefKey.MKB_ENABLED) && AppInterface) {
-        STATES.pointerServerPort = AppInterface.startPointerServer() || 9269;
-        BxLogger.info('startPointerServer', 'Port', STATES.pointerServerPort.toString());
     }
 }
 

src/macros/build.ts

@@ -1,12 +1,27 @@
 import stylus from 'stylus';
 
-import cssStr from "@assets/css/styles.styl" with { type: "text" };
+export const isFullVersion = () => {
+    return Bun.env.BUILD_VARIANT === 'full';
+};
 
-const generatedCss = await (stylus(cssStr, {})
+export const isLiteVersion = () => {
-	.set('filename', 'styles.css')
+    return Bun.env.BUILD_VARIANT === 'lite';
-	.include('src/assets/css/'))
+};
-	.render();
+
+export const renderStylus = async () => {
+    const file = Bun.file('./src/assets/css/styles.styl');
+    const cssStr = await file.text();
+
+    const generatedCss = await (stylus(cssStr, {})
+        .set('filename', 'styles.css')
+        .set('compress', true)
+        .include('src/assets/css/'))
+        .render();
 
-export const renderStylus = () => {
     return generatedCss;
 };
+
+
+export const compressCss = (css: string) => {
+    return (stylus(css, {}).set('compress', true)).render();
+};

src/modules/controller-shortcut.ts

@@ -1,18 +1,24 @@
 import { Screenshot } from "@utils/screenshot";
 import { GamepadKey } from "@enums/mkb";
 import { PrompFont } from "@enums/prompt-font";
-import { CE } from "@utils/html";
+import { CE, removeChildElements } from "@utils/html";
 import { t } from "@utils/translation";
-import { EmulatedMkbHandler } from "./mkb/mkb-handler";
 import { StreamStats } from "./stream/stream-stats";
 import { MicrophoneShortcut } from "./shortcuts/shortcut-microphone";
 import { StreamUiShortcut } from "./shortcuts/shortcut-stream-ui";
-import { PrefKey, getPref } from "@utils/preferences";
 import { SoundShortcut } from "./shortcuts/shortcut-sound";
 import { BxEvent } from "@/utils/bx-event";
 import { AppInterface } from "@/utils/global";
+import { BxSelectElement } from "@/web-components/bx-select";
+import { setNearby } from "@/utils/navigation-utils";
+import { PrefKey } from "@/enums/pref-keys";
+import { getPref } from "@/utils/settings-storages/global-settings-storage";
+import { SettingsNavigationDialog } from "./ui/dialog/settings-dialog";
+import { VIRTUAL_GAMEPAD_ID } from "./mkb/mkb-handler";
+
+const enum ShortcutAction {
+    BETTER_XCLOUD_SETTINGS_SHOW = 'bx-settings-show',
 
-enum ShortcutAction {
     STREAM_SCREENSHOT_CAPTURE = 'stream-screenshot-capture',
 
     STREAM_MENU_SHOW = 'stream-menu-show',
@@ -41,7 +47,7 @@ export class ControllerShortcut {
     static #$selectActions: Partial<{[key in GamepadKey]: HTMLSelectElement}> = {};
     static #$container: HTMLElement;
 
-    static #ACTIONS: {[key: string]: (ShortcutAction | null)[]} = {};
+    static #ACTIONS: {[key: string]: (ShortcutAction | null)[]} | null = null;
 
     static reset(index: number) {
         ControllerShortcut.#buttonsCache[index] = [];
@@ -49,8 +55,12 @@ export class ControllerShortcut {
     }
 
     static handle(gamepad: Gamepad): boolean {
+        if (!ControllerShortcut.#ACTIONS) {
+            ControllerShortcut.#ACTIONS = ControllerShortcut.#getActionsFromStorage();
+        }
+
         const gamepadIndex = gamepad.index;
-        const actions = ControllerShortcut.#ACTIONS[gamepad.id];
+        const actions = ControllerShortcut.#ACTIONS![gamepad.id];
         if (!actions) {
             return false;
         }
@@ -82,6 +92,10 @@ export class ControllerShortcut {
 
     static #runAction(action: ShortcutAction) {
         switch (action) {
+            case ShortcutAction.BETTER_XCLOUD_SETTINGS_SHOW:
+                SettingsNavigationDialog.getInstance().show();
+                break;
+
             case ShortcutAction.STREAM_SCREENSHOT_CAPTURE:
                 Screenshot.takeScreenshot();
                 break;
@@ -121,15 +135,16 @@ export class ControllerShortcut {
     }
 
     static #updateAction(profile: string, button: GamepadKey, action: ShortcutAction | null) {
-        if (!(profile in ControllerShortcut.#ACTIONS)) {
+        const actions = ControllerShortcut.#ACTIONS!;
-            ControllerShortcut.#ACTIONS[profile] = [];
+        if (!(profile in actions)) {
+            actions[profile] = [];
         }
 
         if (!action) {
             action = null;
         }
 
-        ControllerShortcut.#ACTIONS[profile][button] = action;
+        actions[profile][button] = action;
 
         // Remove empty profiles
         for (const key in ControllerShortcut.#ACTIONS) {
@@ -159,9 +174,7 @@ export class ControllerShortcut {
         const $fragment = document.createDocumentFragment();
 
         // Remove old profiles
-        while ($select.firstElementChild) {
+        removeChildElements($select);
-            $select.firstElementChild.remove();
-        }
 
         const gamepads = navigator.getGamepads();
         let hasGamepad = false;
@@ -172,7 +185,7 @@ export class ControllerShortcut {
             }
 
             // Ignore emulated gamepad
-            if (gamepad.id === EmulatedMkbHandler.VIRTUAL_GAMEPAD_ID) {
+            if (gamepad.id === VIRTUAL_GAMEPAD_ID) {
                 continue;
             }
 
@@ -182,18 +195,18 @@ export class ControllerShortcut {
             $fragment.appendChild($option);
         }
 
+        $container.dataset.hasGamepad = hasGamepad.toString();
         if (hasGamepad) {
             $select.appendChild($fragment);
 
             $select.selectedIndex = 0;
-            $select.dispatchEvent(new Event('change'));
+            $select.dispatchEvent(new Event('input'));
         }
 
-        $container.dataset.hasGamepad = hasGamepad.toString();
     }
 
     static #switchProfile(profile: string) {
-        let actions = ControllerShortcut.#ACTIONS[profile];
+        let actions = ControllerShortcut.#ACTIONS![profile];
         if (!actions) {
             actions = [];
         }
@@ -204,15 +217,22 @@ export class ControllerShortcut {
             const $select = ControllerShortcut.#$selectActions[button as GamepadKey]!;
             $select.value = actions[button] || '';
 
-            BxEvent.dispatch($select, 'change', {
+            BxEvent.dispatch($select, 'input', {
-                    ignoreOnChange: true,
+                ignoreOnChange: true,
-                });
+                manualTrigger: true,
+            });
         }
     }
 
+    static #getActionsFromStorage() {
+        return JSON.parse(window.localStorage.getItem(ControllerShortcut.#STORAGE_KEY) || '{}');
+    }
+
     static renderSettings() {
+        const PREF_CONTROLLER_FRIENDLY_UI = getPref(PrefKey.UI_CONTROLLER_FRIENDLY);
+
         // Read actions from localStorage
-        ControllerShortcut.#ACTIONS = JSON.parse(window.localStorage.getItem(ControllerShortcut.#STORAGE_KEY) || '{}');
+        ControllerShortcut.#ACTIONS = ControllerShortcut.#getActionsFromStorage();
 
         const buttons: Map<GamepadKey, PrompFont> = new Map();
         buttons.set(GamepadKey.Y, PrompFont.Y);
@@ -238,6 +258,10 @@ export class ControllerShortcut {
         buttons.set(GamepadKey.R3, PrompFont.R3);
 
         const actions: {[key: string]: Partial<{[key in ShortcutAction]: string | string[]}>} = {
+            [t('better-xcloud')]: {
+                [ShortcutAction.BETTER_XCLOUD_SETTINGS_SHOW]: [t('settings'), t('show')],
+            },
+
             [t('device')]: AppInterface && {
                 [ShortcutAction.DEVICE_SOUND_TOGGLE]: [t('sound'), t('toggle')],
                 [ShortcutAction.DEVICE_VOLUME_INC]: [t('volume'), t('increase')],
@@ -257,7 +281,7 @@ export class ControllerShortcut {
                 [ShortcutAction.STREAM_MENU_SHOW]: [t('menu'), t('show')],
                 [ShortcutAction.STREAM_STATS_TOGGLE]: [t('stats'), t('show-hide')],
                 [ShortcutAction.STREAM_MICROPHONE_TOGGLE]: [t('microphone'), t('toggle')],
-            }
+            },
         };
 
         const $baseSelect = CE<HTMLSelectElement>('select', {autocomplete: 'off'}, CE('option', {value: ''}, '---'));
@@ -287,23 +311,35 @@ export class ControllerShortcut {
         }
 
         let $remap: HTMLElement;
-        let $selectProfile: HTMLSelectElement;
+        const $selectProfile = CE<HTMLSelectElement>('select', {class: 'bx-shortcut-profile', autocomplete: 'off'});
 
-        const $container = CE('div', {'data-has-gamepad': 'false'},
+        const $profile = PREF_CONTROLLER_FRIENDLY_UI ? BxSelectElement.wrap($selectProfile) : $selectProfile;
+        $profile.classList.add('bx-full-width');
+
+        const $container = CE('div', {
+            'data-has-gamepad': 'false',
+            _nearby: {
+                focus: $profile,
+            },
+        },
             CE('div', {},
-                CE('p', {'class': 'bx-shortcut-note'}, t('controller-shortcuts-connect-note')),
+                CE('p', {class: 'bx-shortcut-note'}, t('controller-shortcuts-connect-note')),
             ),
 
             $remap = CE('div', {},
-                $selectProfile = CE('select', {'class': 'bx-shortcut-profile', autocomplete: 'off'}),
+                CE('div', {
-                CE('p', {'class': 'bx-shortcut-note'},
+                    _nearby: {
-                    CE('span', {'class': 'bx-prompt'}, PrompFont.HOME),
+                        focus: $profile,
+                    },
+                }, $profile),
+                CE('p', {class: 'bx-shortcut-note'},
+                    CE('span', {class: 'bx-prompt'}, PrompFont.HOME),
                     ': ' + t('controller-shortcuts-xbox-note'),
                 ),
             ),
         );
 
-        $selectProfile.addEventListener('change', e => {
+        $selectProfile.addEventListener('input', e => {
             ControllerShortcut.#switchProfile($selectProfile.value);
         });
 
@@ -314,38 +350,59 @@ export class ControllerShortcut {
             const button: unknown = $target.dataset.button;
             const action = $target.value as ShortcutAction;
 
-            const $fakeSelect = $target.previousElementSibling! as HTMLSelectElement;
+            if (!PREF_CONTROLLER_FRIENDLY_UI) {
-            let fakeText = '---';
+                const $fakeSelect = $target.previousElementSibling! as HTMLSelectElement;
-            if (action) {
+                let fakeText = '---';
-                const $selectedOption =  $target.options[$target.selectedIndex];
+                if (action) {
-                const $optGroup = $selectedOption.parentElement as HTMLOptGroupElement;
+                    const $selectedOption =  $target.options[$target.selectedIndex];
-                fakeText = $optGroup.label + ' ❯ ' + $selectedOption.text;
+                    const $optGroup = $selectedOption.parentElement as HTMLOptGroupElement;
+                    fakeText = $optGroup.label + ' ❯ ' + $selectedOption.text;
+                }
+                ($fakeSelect.firstElementChild as HTMLOptionElement).text = fakeText;
             }
-            ($fakeSelect.firstElementChild as HTMLOptionElement).text = fakeText;
 
             !(e as any).ignoreOnChange && ControllerShortcut.#updateAction(profile, button as GamepadKey, action);
         };
 
+
         // @ts-ignore
         for (const [button, prompt] of buttons) {
-            const $row = CE('div', {'class': 'bx-shortcut-row'});
+            const $row = CE('div', {
+                class: 'bx-shortcut-row',
+            });
 
-            const $label = CE('label', {'class': 'bx-prompt'}, `${PrompFont.HOME} + ${prompt}`);
+            const $label = CE('label', {class: 'bx-prompt'}, `${PrompFont.HOME} + ${prompt}`);
 
-            const $div = CE('div', {'class': 'bx-shortcut-actions'});
+            const $div = CE('div', {class: 'bx-shortcut-actions'});
 
-            const $fakeSelect = CE<HTMLSelectElement>('select', {autocomplete: 'off'},
+            if (!PREF_CONTROLLER_FRIENDLY_UI) {
-                CE('option', {}, '---'),
+                const $fakeSelect = CE<HTMLSelectElement>('select', {autocomplete: 'off'},
-            );
+                    CE('option', {}, '---'),
-            $div.appendChild($fakeSelect);
+                );
+
+                $div.appendChild($fakeSelect);
+            }
 
             const $select = $baseSelect.cloneNode(true) as HTMLSelectElement;
             $select.dataset.button = button.toString();
-            $select.addEventListener('change', onActionChanged);
+            $select.addEventListener('input', onActionChanged);
 
             ControllerShortcut.#$selectActions[button] = $select;
 
-            $div.appendChild($select);
+            if (PREF_CONTROLLER_FRIENDLY_UI) {
+                const $bxSelect = BxSelectElement.wrap($select);
+                $bxSelect.classList.add('bx-full-width');
+
+                $div.appendChild($bxSelect);
+                setNearby($row, {
+                    focus: $bxSelect,
+                });
+            } else {
+                $div.appendChild($select);
+                setNearby($row, {
+                    focus: $select,
+                });
+            }
 
             $row.appendChild($label);
             $row.appendChild($div);

src/modules/game-bar/action-microphone.ts

@@ -1,7 +1,6 @@
 import { BxEvent } from "@utils/bx-event";
 import { BxIcon } from "@utils/bx-icon";
 import { createButton, ButtonStyle, CE } from "@utils/html";
-import { t } from "@utils/translation";
 import { BaseGameBarAction } from "./action-base";
 import { MicrophoneShortcut, MicrophoneState } from "../shortcuts/shortcut-microphone";
 
@@ -15,16 +14,15 @@ export class MicrophoneAction extends BaseGameBarAction {
         super();
 
         const onClick = (e: Event) => {
-                BxEvent.dispatch(window, BxEvent.GAME_BAR_ACTION_ACTIVATED);
+            BxEvent.dispatch(window, BxEvent.GAME_BAR_ACTION_ACTIVATED);
 
-                const enabled = MicrophoneShortcut.toggle(false);
+            const enabled = MicrophoneShortcut.toggle(false);
-                this.$content.setAttribute('data-enabled', enabled.toString());
+            this.$content.setAttribute('data-enabled', enabled.toString());
-            };
+        };
 
         const $btnDefault = createButton({
             style: ButtonStyle.GHOST,
             icon: BxIcon.MICROPHONE,
-            title: t('show-touch-controller'),
             onClick: onClick,
             classes: ['bx-activated'],
         });
@@ -32,7 +30,6 @@ export class MicrophoneAction extends BaseGameBarAction {
         const $btnMuted = createButton({
             style: ButtonStyle.GHOST,
             icon: BxIcon.MICROPHONE_MUTED,
-            title: t('hide-touch-controller'),
             onClick: onClick,
         });
 

src/modules/game-bar/action-screenshot.ts

@@ -12,16 +12,16 @@ export class ScreenshotAction extends BaseGameBarAction {
         super();
 
         const onClick = (e: Event) => {
-                BxEvent.dispatch(window, BxEvent.GAME_BAR_ACTION_ACTIVATED);
+            BxEvent.dispatch(window, BxEvent.GAME_BAR_ACTION_ACTIVATED);
-                Screenshot.takeScreenshot();
+            Screenshot.takeScreenshot();
-            };
+        };
 
         this.$content = createButton({
-                style: ButtonStyle.GHOST,
+            style: ButtonStyle.GHOST,
-                icon: BxIcon.SCREENSHOT,
+            icon: BxIcon.SCREENSHOT,
-                title: t('take-screenshot'),
+            title: t('take-screenshot'),
-                onClick: onClick,
+            onClick: onClick,
-            });
+        });
     }
 
     render(): HTMLElement {

src/modules/game-bar/action-speaker.ts

@@ -0,0 +1,54 @@
+import { BxEvent } from "@utils/bx-event";
+import { BxIcon } from "@utils/bx-icon";
+import { createButton, ButtonStyle, CE } from "@utils/html";
+import { BaseGameBarAction } from "./action-base";
+import { SoundShortcut, SpeakerState } from "../shortcuts/shortcut-sound";
+
+
+export class SpeakerAction extends BaseGameBarAction {
+    $content: HTMLElement;
+
+    constructor() {
+        super();
+
+        const onClick = (e: Event) => {
+            BxEvent.dispatch(window, BxEvent.GAME_BAR_ACTION_ACTIVATED);
+            SoundShortcut.muteUnmute();
+        };
+
+        const $btnEnable = createButton({
+            style: ButtonStyle.GHOST,
+            icon: BxIcon.AUDIO,
+            onClick: onClick,
+        });
+
+        const $btnMuted = createButton({
+            style: ButtonStyle.GHOST,
+            icon: BxIcon.SPEAKER_MUTED,
+            onClick: onClick,
+            classes: ['bx-activated'],
+        });
+
+        this.$content = CE('div', {},
+            $btnEnable,
+            $btnMuted,
+        );
+
+        this.reset();
+
+        window.addEventListener(BxEvent.SPEAKER_STATE_CHANGED, e => {
+            const speakerState = (e as any).speakerState;
+            const enabled = speakerState === SpeakerState.ENABLED;
+
+            this.$content.dataset.enabled = enabled.toString();
+        });
+    }
+
+    render(): HTMLElement {
+        return this.$content;
+    }
+
+    reset(): void {
+        this.$content.dataset.enabled = 'true';
+    }
+}

src/modules/game-bar/action-touch-control.ts

@@ -26,7 +26,6 @@ export class TouchControlAction extends BaseGameBarAction {
             icon: BxIcon.TOUCH_CONTROL_ENABLE,
             title: t('show-touch-controller'),
             onClick: onClick,
-            classes: ['bx-activated'],
         });
 
         const $btnDisable = createButton({
@@ -34,6 +33,7 @@ export class TouchControlAction extends BaseGameBarAction {
             icon: BxIcon.TOUCH_CONTROL_DISABLE,
             title: t('hide-touch-controller'),
             onClick: onClick,
+            classes: ['bx-activated'],
         });
 
         this.$content = CE('div', {},

src/modules/game-bar/action-true-achievements.ts

@@ -0,0 +1,30 @@
+import { BxEvent } from "@/utils/bx-event";
+import { BxIcon } from "@/utils/bx-icon";
+import { createButton, ButtonStyle } from "@/utils/html";
+import { t } from "@/utils/translation";
+import { BaseGameBarAction } from "./action-base";
+import { TrueAchievements } from "@/utils/true-achievements";
+
+export class TrueAchievementsAction extends BaseGameBarAction {
+    $content: HTMLElement;
+
+    constructor() {
+        super();
+
+        const onClick = (e: Event) => {
+            BxEvent.dispatch(window, BxEvent.GAME_BAR_ACTION_ACTIVATED);
+            TrueAchievements.open(false);
+        };
+
+        this.$content = createButton({
+            style: ButtonStyle.GHOST,
+            icon: BxIcon.TRUE_ACHIEVEMENTS,
+            title: t('true-achievements'),
+            onClick: onClick,
+        });
+    }
+
+    render(): HTMLElement {
+        return this.$content;
+    }
+}

src/modules/game-bar/game-bar.ts

@@ -1,17 +1,19 @@
-import { CE, createSvgIcon } from "@utils/html";
+import { CE, clearFocus, createSvgIcon } from "@utils/html";
 import { ScreenshotAction } from "./action-screenshot";
 import { TouchControlAction } from "./action-touch-control";
 import { BxEvent } from "@utils/bx-event";
 import { BxIcon } from "@utils/bx-icon";
 import type { BaseGameBarAction } from "./action-base";
 import { STATES } from "@utils/global";
-import { PrefKey, getPref } from "@utils/preferences";
 import { MicrophoneAction } from "./action-microphone";
+import { PrefKey } from "@/enums/pref-keys";
+import { getPref, StreamTouchController } from "@/utils/settings-storages/global-settings-storage";
+import { TrueAchievementsAction } from "./action-true-achievements";
+import { SpeakerAction } from "./action-speaker";
 
 
 export class GameBar {
     private static instance: GameBar;
-
     public static getInstance(): GameBar {
         if (!GameBar.instance) {
             GameBar.instance = new GameBar();
@@ -41,8 +43,10 @@ export class GameBar {
 
         this.actions = [
             new ScreenshotAction(),
-            ...(STATES.userAgentHasTouchSupport && (getPref(PrefKey.STREAM_TOUCH_CONTROLLER) !== 'off') ? [new TouchControlAction()] : []),
+            ...(STATES.userAgent.capabilities.touch && (getPref(PrefKey.STREAM_TOUCH_CONTROLLER) !== StreamTouchController.OFF) ? [new TouchControlAction()] : []),
+            new SpeakerAction(),
             new MicrophoneAction(),
+            new TrueAchievementsAction(),
         ];
 
         // Reverse the action list if Game Bar's position is on the right side
@@ -74,7 +78,7 @@ export class GameBar {
         $container.addEventListener('transitionend', e => {
             const classList = $container.classList;
             if (classList.contains('bx-hide')) {
-                classList.remove('bx-offscreen', 'bx-hide');
+                classList.remove('bx-hide');
                 classList.add('bx-offscreen');
             }
         });
@@ -92,7 +96,7 @@ export class GameBar {
 
             // Toggle Game bar
             const mode = (e as any).mode;
-            mode !== 'None' ? this.disable() : this.enable();
+            mode !== 'none' ? this.disable() : this.enable();
         }).bind(this));
     }
 
@@ -124,13 +128,18 @@ export class GameBar {
             return;
         }
 
-        this.$container.classList.remove('bx-offscreen', 'bx-hide');
+        this.$container.classList.remove('bx-offscreen', 'bx-hide' , 'bx-gone');
         this.$container.classList.add('bx-show');
 
         this.beginHideTimeout();
     }
 
     hideBar() {
+        this.clearHideTimeout();
+
+        // Stop focusing Game Bar
+        clearFocus();
+
         if (!this.$container) {
             return;
         }

src/modules/loading-screen.ts

@@ -1,8 +1,10 @@
 import { CE } from "@utils/html";
 import { getPreferredServerRegion } from "@utils/region";
-import { PrefKey, getPref } from "@utils/preferences";
 import { t } from "@utils/translation";
 import { STATES } from "@utils/global";
+import { PrefKey } from "@/enums/pref-keys";
+import { getPref } from "@/utils/settings-storages/global-settings-storage";
+import { compressCss } from "@macros/build" with {type: "macro"};
 
 export class LoadingScreen {
     static #$bgStyle: HTMLElement;
@@ -42,7 +44,7 @@ export class LoadingScreen {
     static #hideRocket() {
         let $bgStyle = LoadingScreen.#$bgStyle;
 
-        const css = `
+        $bgStyle.textContent! += compressCss(`
 #game-stream div[class*=RocketAnimation-module__container] > svg {
     display: none;
 }
@@ -50,8 +52,7 @@ export class LoadingScreen {
 #game-stream video[class*=RocketAnimationVideo-module__video] {
     display: none;
 }
-`;
+`);
-        $bgStyle.textContent += css;
     }
 
     static #setBackground(imageUrl: string) {
@@ -61,9 +62,8 @@ export class LoadingScreen {
         // Limit max width to reduce image size
         imageUrl = imageUrl + '?w=1920';
 
-        const css = `
+        $bgStyle.textContent! += compressCss(`
 #game-stream {
-    background-image: linear-gradient(#00000033, #000000e6), url(${imageUrl}) !important;
     background-color: transparent !important;
     background-position: center center !important;
     background-repeat: no-repeat !important;
@@ -73,16 +73,15 @@ export class LoadingScreen {
 #game-stream rect[width="800"] {
     transition: opacity 0.3s ease-in-out !important;
 }
-`;
+`) + `#game-stream {background-image: linear-gradient(#00000033, #000000e6), url(${imageUrl}) !important;}`;
-        $bgStyle.textContent += css;
 
         const bg = new Image();
         bg.onload = e => {
-            $bgStyle.textContent += `
+            $bgStyle.textContent += compressCss(`
 #game-stream rect[width="800"] {
     opacity: 0 !important;
 }
-`;
+`);
         };
         bg.src = imageUrl;
     }
@@ -109,7 +108,7 @@ export class LoadingScreen {
 
         let $waitTimeBox = LoadingScreen.#$waitTimeBox;
         if (!$waitTimeBox) {
-            $waitTimeBox = CE<HTMLElement>('div', {'class': 'bx-wait-time-box'},
+            $waitTimeBox = CE('div', {'class': 'bx-wait-time-box'},
                                     CE('label', {}, t('server')),
                                     CE('span', {}, getPreferredServerRegion()),
                                     CE('label', {}, t('wait-time-estimated')),
@@ -149,18 +148,18 @@ export class LoadingScreen {
         if (getPref(PrefKey.UI_LOADING_SCREEN_GAME_ART) && LoadingScreen.#$bgStyle) {
             const $rocketBg = document.querySelector('#game-stream rect[width="800"]');
             $rocketBg && $rocketBg.addEventListener('transitionend', e => {
-                LoadingScreen.#$bgStyle.textContent += `
+                LoadingScreen.#$bgStyle.textContent += compressCss(`
 #game-stream {
     background: #000 !important;
 }
-`;
+`);
             });
 
-            LoadingScreen.#$bgStyle.textContent += `
+            LoadingScreen.#$bgStyle.textContent += compressCss(`
 #game-stream rect[width="800"] {
     opacity: 1 !important;
 }
-`;
+`);
         }
 
         setTimeout(LoadingScreen.reset, 2000);

src/modules/mkb/mkb-handler.ts

@@ -1,20 +1,24 @@
+import { isFullVersion } from "@macros/build" with {type: "macro"};
+
 import { MkbPreset } from "./mkb-preset";
 import { GamepadKey, MkbPresetKey, GamepadStick, MouseMapTo, WheelCode } from "@enums/mkb";
 import { createButton, ButtonStyle, CE } from "@utils/html";
 import { BxEvent } from "@utils/bx-event";
-import { PrefKey, getPref } from "@utils/preferences";
 import { Toast } from "@utils/toast";
 import { t } from "@utils/translation";
 import { LocalDb } from "@utils/local-db";
 import { KeyHelper } from "./key-helper";
 import type { MkbStoredPreset } from "@/types/mkb";
-import { showStreamSettings } from "@modules/stream/stream-ui";
 import { AppInterface, STATES } from "@utils/global";
 import { UserAgent } from "@utils/user-agent";
 import { BxLogger } from "@utils/bx-logger";
 import { PointerClient } from "./pointer-client";
 import { NativeMkbHandler } from "./native-mkb-handler";
 import { MkbHandler, MouseDataProvider } from "./base-mkb-handler";
+import { SettingsNavigationDialog } from "../ui/dialog/settings-dialog";
+import { NavigationDialogManager } from "../ui/dialog/navigation-dialog";
+import { PrefKey } from "@/enums/pref-keys";
+import { getPref } from "@/utils/settings-storages/global-settings-storage";
 
 const LOG_TAG = 'MkbHandler';
 
@@ -24,6 +28,7 @@ const PointerToMouseButton = {
     4: 1,
 }
 
+export const VIRTUAL_GAMEPAD_ID = 'Xbox 360 Controller';
 
 class WebSocketMouseDataProvider extends MouseDataProvider {
     #pointerClient: PointerClient | undefined
@@ -134,10 +139,8 @@ export class EmulatedMkbHandler extends MkbHandler {
     static readonly DEFAULT_DEADZONE_COUNTERWEIGHT = 0.01;
     static readonly MAXIMUM_STICK_RANGE = 1.1;
 
-    static VIRTUAL_GAMEPAD_ID = 'Xbox 360 Controller';
-
     #VIRTUAL_GAMEPAD = {
-            id: EmulatedMkbHandler.VIRTUAL_GAMEPAD_ID,
+            id: VIRTUAL_GAMEPAD_ID,
             index: 3,
             connected: false,
             hapticActuators: null,
@@ -457,7 +460,7 @@ export class EmulatedMkbHandler extends MkbHandler {
         }
 
         const mode = (e as any).mode;
-        if (mode === 'None') {
+        if (mode === 'none') {
             this.#$message.classList.remove('bx-offscreen');
         } else {
             this.#$message.classList.add('bx-offscreen');
@@ -507,7 +510,10 @@ export class EmulatedMkbHandler extends MkbHandler {
                                 e.preventDefault();
                                 e.stopPropagation();
 
-                                showStreamSettings('mkb');
+                                // Show Settings dialog & focus the MKB tab
+                                const dialog = SettingsNavigationDialog.getInstance();
+                                dialog.focusTab('mkb');
+                                NavigationDialogManager.getInstance().show(dialog);
                             },
                         }),
                     ),
@@ -673,7 +679,7 @@ export class EmulatedMkbHandler extends MkbHandler {
     }
 
     static setupEvents() {
-        window.addEventListener(BxEvent.STREAM_PLAYING, () => {
+        isFullVersion() && window.addEventListener(BxEvent.STREAM_PLAYING, () => {
             if (STATES.currentStream.titleInfo?.details.hasMkbSupport) {
                 // Enable native MKB in Android app
                 if (AppInterface && getPref(PrefKey.NATIVE_MKB_ENABLED) === 'on') {

src/modules/mkb/mkb-preset.ts

@@ -1,9 +1,9 @@
 import { t } from "@utils/translation";
-import { SettingElementType } from "@utils/settings";
 import { GamepadKey, MouseButtonCode, MouseMapTo, MkbPresetKey } from "@enums/mkb";
 import { EmulatedMkbHandler } from "./mkb-handler";
 import type { MkbPresetData, MkbConvertedPresetData } from "@/types/mkb";
 import type { PreferenceSettings } from "@/types/preferences";
+import { SettingElementType } from "@/utils/setting-element";
 
 
 export class MkbPreset {

src/modules/mkb/mkb-remapper.ts

@@ -1,15 +1,17 @@
 import { CE, createButton, ButtonStyle } from "@utils/html";
 import { t } from "@utils/translation";
 import { Dialog } from "@modules/dialog";
-import { getPref, setPref, PrefKey } from "@utils/preferences";
 import { KeyHelper } from "./key-helper";
 import { MkbPreset } from "./mkb-preset";
 import { EmulatedMkbHandler } from "./mkb-handler";
 import { LocalDb } from "@utils/local-db";
 import { BxIcon } from "@utils/bx-icon";
-import { SettingElement } from "@utils/settings";
 import type { MkbPresetData, MkbStoredPresets } from "@/types/mkb";
 import { MkbPresetKey, GamepadKey, GamepadKeyName } from "@enums/mkb";
+import { deepClone } from "@utils/global";
+import { SettingElement } from "@/utils/setting-element";
+import { PrefKey } from "@/enums/pref-keys";
+import { getPref, setPref } from "@/utils/settings-storages/global-settings-storage";
 
 
 type MkbRemapperElements = {
@@ -291,7 +293,7 @@ export class MkbRemapper {
         this.#$.wrapper!.classList.toggle('bx-editing', this.#STATE.isEditing);
 
         if (this.#STATE.isEditing) {
-            this.#STATE.editingPresetData = structuredClone(this.#getCurrentPreset().data);
+            this.#STATE.editingPresetData = deepClone(this.#getCurrentPreset().data);
         } else {
             this.#STATE.editingPresetData = null;
         }
@@ -316,7 +318,7 @@ export class MkbRemapper {
     render() {
         this.#$.wrapper = CE('div', {'class': 'bx-mkb-settings'});
 
-        this.#$.presetsSelect = CE<HTMLSelectElement>('select', {});
+        this.#$.presetsSelect = CE<HTMLSelectElement>('select', {tabindex: -1});
         this.#$.presetsSelect!.addEventListener('change', e => {
             this.#switchPreset(parseInt((e.target as HTMLSelectElement).value));
         });
@@ -335,80 +337,84 @@ export class MkbRemapper {
         };
 
         const $header = CE('div', {'class': 'bx-mkb-preset-tools'},
-                this.#$.presetsSelect,
+            this.#$.presetsSelect,
-                // Rename button
+            // Rename button
-                createButton({
+            createButton({
-                    title: t('rename'),
+                title: t('rename'),
-                    icon: BxIcon.CURSOR_TEXT,
+                icon: BxIcon.CURSOR_TEXT,
-                    onClick: e => {
+                tabIndex: -1,
-                        const preset = this.#getCurrentPreset();
+                onClick: e => {
+                    const preset = this.#getCurrentPreset();
 
-                        let newName = promptNewName(preset.name);
+                    let newName = promptNewName(preset.name);
-                        if (!newName || newName === preset.name) {
+                    if (!newName || newName === preset.name) {
+                        return;
+                    }
+
+                    // Update preset with new name
+                    preset.name = newName;
+                    LocalDb.INSTANCE.updatePreset(preset).then(id => this.#refresh());
+                },
+            }),
+
+            // New button
+            createButton({
+                    icon: BxIcon.NEW,
+                    title: t('new'),
+                    tabIndex: -1,
+                    onClick: e => {
+                        let newName = promptNewName('');
+                        if (!newName) {
                             return;
                         }
 
-                        // Update preset with new name
+                        // Create new preset selected name
-                        preset.name = newName;
+                        LocalDb.INSTANCE.newPreset(newName, MkbPreset.DEFAULT_PRESET).then(id => {
-                        LocalDb.INSTANCE.updatePreset(preset).then(id => this.#refresh());
+                            this.#STATE.currentPresetId = id;
+                            this.#refresh();
+                        });
                     },
                 }),
 
-                // New button
+            // Copy button
-                createButton({
+            createButton({
-                      icon: BxIcon.NEW,
+                icon: BxIcon.COPY,
-                      title: t('new'),
+                title: t('copy'),
-                      onClick: e => {
+                tabIndex: -1,
-                          let newName = promptNewName('');
+                onClick: e => {
-                          if (!newName) {
+                    const preset = this.#getCurrentPreset();
-                              return;
-                          }
 
-                          // Create new preset selected name
+                    let newName = promptNewName(`${preset.name} (2)`);
-                          LocalDb.INSTANCE.newPreset(newName, MkbPreset.DEFAULT_PRESET).then(id => {
+                    if (!newName) {
-                              this.#STATE.currentPresetId = id;
+                        return;
-                              this.#refresh();
+                    }
-                          });
-                      },
-                    }),
 
-                // Copy button
+                    // Create new preset selected name
-                createButton({
+                    LocalDb.INSTANCE.newPreset(newName, preset.data).then(id => {
-                        icon: BxIcon.COPY,
+                        this.#STATE.currentPresetId = id;
-                        title: t('copy'),
+                        this.#refresh();
-                        onClick: e => {
+                    });
-                            const preset = this.#getCurrentPreset();
+                },
+            }),
 
-                            let newName = promptNewName(`${preset.name} (2)`);
+            // Delete button
-                            if (!newName) {
+            createButton({
-                                return;
+                icon: BxIcon.TRASH,
-                            }
+                style: ButtonStyle.DANGER,
+                title: t('delete'),
+                tabIndex: -1,
+                onClick: e => {
+                    if (!confirm(t('confirm-delete-preset'))) {
+                        return;
+                    }
 
-                            // Create new preset selected name
+                    LocalDb.INSTANCE.deletePreset(this.#STATE.currentPresetId).then(id => {
-                            LocalDb.INSTANCE.newPreset(newName, preset.data).then(id => {
+                        this.#STATE.currentPresetId = 0;
-                                this.#STATE.currentPresetId = id;
+                        this.#refresh();
-                                this.#refresh();
+                    });
-                            });
+                },
-                        },
+            }),
-                    }),
+        );
-
-                // Delete button
-                createButton({
-                        icon: BxIcon.TRASH,
-                        style: ButtonStyle.DANGER,
-                        title: t('delete'),
-                        onClick: e => {
-                            if (!confirm(t('confirm-delete-preset'))) {
-                                return;
-                            }
-
-                            LocalDb.INSTANCE.deletePreset(this.#STATE.currentPresetId).then(id => {
-                                this.#STATE.currentPresetId = 0;
-                                this.#refresh();
-                            });
-                        },
-                    }),
-            );
 
         this.#$.wrapper!.appendChild($header);
 
@@ -425,11 +431,11 @@ export class MkbRemapper {
             const $fragment = document.createDocumentFragment();
             for (let i = 0; i < keysPerButton; i++) {
                 $elm = CE('button', {
-                        type: 'button',
+                    type: 'button',
-                        'data-prompt': buttonPrompt,
+                    'data-prompt': buttonPrompt,
-                        'data-button-index': buttonIndex,
+                    'data-button-index': buttonIndex,
-                        'data-key-slot': i,
+                    'data-key-slot': i,
-                    }, ' ');
+                }, ' ');
 
                 $elm.addEventListener('mouseup', this.#onBindingKey);
                 $elm.addEventListener('contextmenu', this.#onContextMenu);
@@ -439,9 +445,9 @@ export class MkbRemapper {
             }
 
             const $keyRow = CE('div', {'class': 'bx-mkb-key-row'},
-                    CE('label', {'title': buttonName}, buttonPrompt),
+                CE('label', {'title': buttonName}, buttonPrompt),
-                    $fragment,
+                $fragment,
-                );
+            );
 
             $rows.appendChild($keyRow);
         }
@@ -459,10 +465,13 @@ export class MkbRemapper {
             const onChange = (e: Event, value: any) => {
                 (this.#STATE.editingPresetData!.mouse as any)[key] = value;
             };
-            const $row = CE('div', {'class': 'bx-stream-settings-row'},
+            const $row = CE('label', {
-                    CE('label', {'for': `bx_setting_${key}`}, setting.label),
+                class: 'bx-settings-row',
-                    $elm = SettingElement.render(setting.type, key, setting, value, onChange, setting.params),
+                for: `bx_setting_${key}`
-                );
+            },
+                CE('span', {class: 'bx-settings-label'}, setting.label),
+                $elm = SettingElement.render(setting.type, key, setting, value, onChange, setting.params),
+            );
 
             $mouseSettings.appendChild($row);
             this.#$.allMouseElements[key as MkbPresetKey] = $elm;
@@ -473,59 +482,63 @@ export class MkbRemapper {
 
         // Render action buttons
         const $actionButtons = CE('div', {'class': 'bx-mkb-action-buttons'},
-                CE('div', {},
+            CE('div', {},
-                   // Edit button
+                // Edit button
-                   createButton({
+                createButton({
-                           label: t('edit'),
+                    label: t('edit'),
-                           onClick: e => this.#toggleEditing(true),
+                    tabIndex: -1,
-                   }),
+                    onClick: e => this.#toggleEditing(true),
+                }),
 
-                   // Activate button
+                // Activate button
-                   this.#$.activateButton = createButton({
+                this.#$.activateButton = createButton({
-                           label: t('activate'),
+                    label: t('activate'),
-                           style: ButtonStyle.PRIMARY,
+                    style: ButtonStyle.PRIMARY,
-                           onClick: e => {
+                    tabIndex: -1,
-                               setPref(PrefKey.MKB_DEFAULT_PRESET_ID, this.#STATE.currentPresetId);
+                    onClick: e => {
-                               EmulatedMkbHandler.getInstance().refreshPresetData();
+                        setPref(PrefKey.MKB_DEFAULT_PRESET_ID, this.#STATE.currentPresetId);
+                        EmulatedMkbHandler.getInstance().refreshPresetData();
 
-                               this.#refresh();
+                        this.#refresh();
-                           },
+                    },
-                       }),
+                }),
-                ),
+            ),
 
-                CE('div', {},
+            CE('div', {},
-                   // Cancel button
+                // Cancel button
-                   createButton({
+                createButton({
-                           label: t('cancel'),
+                    label: t('cancel'),
-                           style: ButtonStyle.GHOST,
+                    style: ButtonStyle.GHOST,
-                           onClick: e => {
+                    tabIndex: -1,
-                               // Restore preset
+                    onClick: e => {
-                               this.#switchPreset(this.#STATE.currentPresetId);
+                        // Restore preset
-                               this.#toggleEditing(false);
+                        this.#switchPreset(this.#STATE.currentPresetId);
-                           },
+                        this.#toggleEditing(false);
-                       }),
+                    },
+                }),
 
-                   // Save button
+                // Save button
-                   createButton({
+                createButton({
-                           label: t('save'),
+                    label: t('save'),
-                           style: ButtonStyle.PRIMARY,
+                    style: ButtonStyle.PRIMARY,
-                           onClick: e => {
+                    tabIndex: -1,
-                               const updatedPreset = structuredClone(this.#getCurrentPreset());
+                    onClick: e => {
-                               updatedPreset.data = this.#STATE.editingPresetData as MkbPresetData;
+                        const updatedPreset = deepClone(this.#getCurrentPreset());
+                        updatedPreset.data = this.#STATE.editingPresetData as MkbPresetData;
 
-                               LocalDb.INSTANCE.updatePreset(updatedPreset).then(id => {
+                        LocalDb.INSTANCE.updatePreset(updatedPreset).then(id => {
-                                   // If this is the default preset => refresh preset data
+                            // If this is the default preset => refresh preset data
-                                   if (id === getPref(PrefKey.MKB_DEFAULT_PRESET_ID)) {
+                            if (id === getPref(PrefKey.MKB_DEFAULT_PRESET_ID)) {
-                                       EmulatedMkbHandler.getInstance().refreshPresetData();
+                                EmulatedMkbHandler.getInstance().refreshPresetData();
-                                   }
+                            }
 
-                                   this.#toggleEditing(false);
+                            this.#toggleEditing(false);
-                                   this.#refresh();
+                            this.#refresh();
-                               });
+                        });
-                           },
+                    },
-                       }),
+                }),
-                ),
+            ),
-            );
+        );
 
         this.#$.wrapper!.appendChild($actionButtons);
 

src/modules/mkb/native-mkb-handler.ts

@@ -5,7 +5,8 @@ import { MkbHandler } from "./base-mkb-handler";
 import { t } from "@/utils/translation";
 import { BxEvent } from "@/utils/bx-event";
 import { ButtonStyle, CE, createButton } from "@/utils/html";
-import { PrefKey, getPref } from "@/utils/preferences";
+import { PrefKey } from "@/enums/pref-keys";
+import { getPref } from "@/utils/settings-storages/global-settings-storage";
 
 type NativeMouseData = {
     X: number,
@@ -68,7 +69,7 @@ export class NativeMkbHandler extends MkbHandler {
         }
 
         const mode = (e as any).mode;
-        if (mode === 'None') {
+        if (mode === 'none') {
             this.#$message.classList.remove('bx-offscreen');
         } else {
             this.#$message.classList.add('bx-offscreen');

src/modules/patcher.ts

@@ -1,6 +1,5 @@
-import { SCRIPT_VERSION, STATES } from "@utils/global";
+import { AppInterface, SCRIPT_VERSION, STATES } from "@utils/global";
 import { BX_FLAGS } from "@utils/bx-flags";
-import { getPref, PrefKey } from "@utils/preferences";
 import { VibrationManager } from "@modules/vibration-manager";
 import { BxLogger } from "@utils/bx-logger";
 import { hashCode, renderString } from "@utils/utils";
@@ -9,36 +8,68 @@ import { BxEvent } from "@/utils/bx-event";
 import codeControllerShortcuts from "./patches/controller-shortcuts.js" with { type: "text" };
 import codeExposeStreamSession from "./patches/expose-stream-session.js" with { type: "text" };
 import codeLocalCoOpEnable from "./patches/local-co-op-enable.js" with { type: "text" };
+import codeSetCurrentlyFocusedInteractable from "./patches/set-currently-focused-interactable.js" with { type: "text" };
 import codeRemotePlayEnable from "./patches/remote-play-enable.js" with { type: "text" };
 import codeRemotePlayKeepAlive from "./patches/remote-play-keep-alive.js" with { type: "text" };
 import codeVibrationAdjust from "./patches/vibration-adjust.js" with { type: "text" };
 import { FeatureGates } from "@/utils/feature-gates.js";
+import { UiSection } from "@/enums/ui-sections.js";
+import { PrefKey } from "@/enums/pref-keys.js";
+import { getPref, StreamTouchController } from "@/utils/settings-storages/global-settings-storage";
+import { GamePassCloudGallery } from "@/enums/game-pass-gallery.js";
 
 type PatchArray = (keyof typeof PATCHES)[];
 
-const ENDING_CHUNKS_PATCH_NAME = 'loadingEndingChunks';
+class PatcherUtils {
+    static indexOf(txt: string, searchString: string, startIndex: number, maxRange: number): number {
+        const index = txt.indexOf(searchString, startIndex);
+        if (index < 0 || (maxRange && index - startIndex > maxRange)) {
+            return -1;
+        }
 
+        return index;
+    }
+
+    static lastIndexOf(txt: string, searchString: string, startIndex: number, maxRange: number): number {
+        const index = txt.lastIndexOf(searchString, startIndex);
+        if (index < 0 || (maxRange && startIndex - index > maxRange)) {
+            return -1;
+        }
+
+        return index;
+    }
+
+    static insertAt(txt: string, index: number, insertString: string): string {
+        return txt.substring(0, index) + insertString + txt.substring(index);
+    }
+
+    static replaceWith(txt: string, index: number, fromString: string, toString: string): string {
+        return txt.substring(0, index) + toString + txt.substring(index + fromString.length);
+    }
+}
+
+const ENDING_CHUNKS_PATCH_NAME = 'loadingEndingChunks';
 const LOG_TAG = 'Patcher';
 
 const PATCHES = {
     // Disable ApplicationInsights.track() function
     disableAiTrack(str: string) {
-        const text = '.track=function(';
+        let text = '.track=function(';
         const index = str.indexOf(text);
-        if (index === -1) {
+        if (index < 0) {
             return false;
         }
 
-        if (str.substring(0, index + 200).includes('"AppInsightsCore')) {
+        if (PatcherUtils.indexOf(str, '"AppInsightsCore', index, 200) < 0) {
             return false;
         }
 
-        return str.substring(0, index) + '.track=function(e){},!!function(' + str.substring(index + text.length);
+        return PatcherUtils.replaceWith(str, index, text, '.track=function(e){},!!function(');
     },
 
     // Set disableTelemetry() to true
     disableTelemetry(str: string) {
-        const text = '.disableTelemetry=function(){return!1}';
+        let text = '.disableTelemetry=function(){return!1}';
         if (!str.includes(text)) {
             return false;
         }
@@ -47,7 +78,7 @@ const PATCHES = {
     },
 
     disableTelemetryProvider(str: string) {
-        const text = 'this.enableLightweightTelemetry=!';
+        let text = 'this.enableLightweightTelemetry=!';
         if (!str.includes(text)) {
             return false;
         }
@@ -68,7 +99,7 @@ const PATCHES = {
 
     // Disable IndexDB logging
     disableIndexDbLogging(str: string) {
-        const text = ',this.logsDb=new';
+        let text = ',this.logsDb=new';
         if (!str.includes(text)) {
             return false;
         }
@@ -80,7 +111,7 @@ const PATCHES = {
 
     // Set custom website layout
     websiteLayout(str: string) {
-        const text = '?"tv":"default"';
+        let text = '?"tv":"default"';
         if (!str.includes(text)) {
             return false;
         }
@@ -92,7 +123,7 @@ const PATCHES = {
     // Replace "/direct-connect" with "/play"
     remotePlayDirectConnectUrl(str: string) {
         const index = str.indexOf('/direct-connect');
-        if (index === -1) {
+        if (index < 0) {
             return false;
         }
 
@@ -100,7 +131,7 @@ const PATCHES = {
     },
 
     remotePlayKeepAlive(str: string) {
-        const text = 'onServerDisconnectMessage(e){';
+        let text = 'onServerDisconnectMessage(e){';
         if (!str.includes(text)) {
             return false;
         }
@@ -112,7 +143,7 @@ const PATCHES = {
 
     // Enable Remote Play feature
     remotePlayConnectMode(str: string) {
-        const text = 'connectMode:"cloud-connect",';
+        let text = 'connectMode:"cloud-connect",';
         if (!str.includes(text)) {
             return false;
         }
@@ -120,35 +151,44 @@ const PATCHES = {
         return str.replace(text, codeRemotePlayEnable);
     },
 
-    // Disable achievement toast in Remote Play
+    // Remote Play: Disable achievement toast
     remotePlayDisableAchievementToast(str: string) {
-        const text = '.AchievementUnlock:{';
+        let text = '.AchievementUnlock:{';
         if (!str.includes(text)) {
             return false;
         }
 
-        const newCode = `
+        const newCode = `if (!!window.BX_REMOTE_PLAY_CONFIG) return;`;
-if (!!window.BX_REMOTE_PLAY_CONFIG) {
-    return;
-}
-`;
-
         return str.replace(text, text + newCode);
     },
 
-    // Disable trackEvent() function
+    // Remote Play: Prevent adding "Fortnite" to the "Jump back in" list
-    disableTrackEvent(str: string) {
+    remotePlayRecentlyUsedTitleIds(str: string) {
-        const text = 'this.trackEvent=';
+        let text = '(e.data.recentlyUsedTitleIds)){';
         if (!str.includes(text)) {
             return false;
         }
 
-        return str.replace(text, 'this.trackEvent=e=>{},this.uwuwu=');
+        const newCode = `if (window.BX_REMOTE_PLAY_CONFIG) return;`;
+        return str.replace(text, text + newCode);
     },
 
+    // Remote Play: change web page's title
+    /*
+    remotePlayWebTitle(str: string) {
+        let text = '"undefined"!==typeof e&&document.title!==e';
+        if (!str.includes(text)) {
+            return false;
+        }
+
+        const newCode = `if (window.BX_REMOTE_PLAY_CONFIG) { e = "${t('remote-play')} - ${t('better-xcloud')}"; }`;
+        return str.replace(text, newCode + text);
+    },
+    */
+
     // Block WebRTC stats collector
     blockWebRtcStatsCollector(str: string) {
-        const text = 'this.shouldCollectStats=!0';
+        let text = 'this.shouldCollectStats=!0';
         if (!str.includes(text)) {
             return false;
         }
@@ -158,7 +198,7 @@ if (!!window.BX_REMOTE_PLAY_CONFIG) {
 
     patchPollGamepads(str: string) {
         const index = str.indexOf('},this.pollGamepads=()=>{');
-        if (index === -1) {
+        if (index < 0) {
             return false;
         }
 
@@ -171,7 +211,8 @@ if (!!window.BX_REMOTE_PLAY_CONFIG) {
 
         // Block gamepad stats collecting
         if (getPref(PrefKey.BLOCK_TRACKING)) {
-            codeBlock = codeBlock.replaceAll('this.inputPollingIntervalStats.addValue', '');
+            codeBlock = codeBlock.replace('this.inputPollingIntervalStats.addValue', '');
+            codeBlock = codeBlock.replace('this.inputPollingDurationStats.addValue', '');
         }
 
         // Map the Share button on Xbox Series controller with the capturing screenshot feature
@@ -179,8 +220,8 @@ if (!!window.BX_REMOTE_PLAY_CONFIG) {
         if (match) {
             const gamepadVar = match[1];
             const newCode = renderString(codeControllerShortcuts, {
-                    gamepadVar,
+                gamepadVar,
-                });
+            });
 
             codeBlock = codeBlock.replace('this.gamepadTimestamps.set', newCode + 'this.gamepadTimestamps.set');
         }
@@ -189,17 +230,23 @@ if (!!window.BX_REMOTE_PLAY_CONFIG) {
     },
 
     enableXcloudLogger(str: string) {
-        const text = 'this.telemetryProvider=e}log(e,t,i){';
+        let text = 'this.telemetryProvider=e}log(e,t,r){';
         if (!str.includes(text)) {
             return false;
         }
 
-        str = str.replaceAll(text, text + 'console.log(Array.from(arguments));');
+        const newCode = `
+const [logTag, logLevel, logMessage] = Array.from(arguments);
+const logFunc = [console.debug, console.log, console.warn, console.error][logLevel];
+logFunc(logTag, '//', logMessage);
+`;
+
+        str = str.replaceAll(text, text + newCode);
         return str;
     },
 
     enableConsoleLogging(str: string) {
-        const text = 'static isConsoleLoggingAllowed(){';
+        let text = 'static isConsoleLoggingAllowed(){';
         if (!str.includes(text)) {
             return false;
         }
@@ -210,7 +257,7 @@ if (!!window.BX_REMOTE_PLAY_CONFIG) {
 
     // Control controller vibration
     playVibration(str: string) {
-        const text = '}playVibration(e){';
+        let text = '}playVibration(e){';
         if (!str.includes(text)) {
             return false;
         }
@@ -223,7 +270,7 @@ if (!!window.BX_REMOTE_PLAY_CONFIG) {
     // Override website's settings
     overrideSettings(str: string) {
         const index = str.indexOf(',EnableStreamGate:');
-        if (index === -1) {
+        if (index < 0) {
             return false;
         }
 
@@ -241,7 +288,7 @@ if (!!window.BX_REMOTE_PLAY_CONFIG) {
 
     disableGamepadDisconnectedScreen(str: string) {
         const index = str.indexOf('"GamepadDisconnected_Title",');
-        if (index === -1) {
+        if (index < 0) {
             return false;
         }
 
@@ -251,7 +298,7 @@ if (!!window.BX_REMOTE_PLAY_CONFIG) {
     },
 
     patchUpdateInputConfigurationAsync(str: string) {
-        const text = 'async updateInputConfigurationAsync(e){';
+        let text = 'async updateInputConfigurationAsync(e){';
         if (!str.includes(text)) {
             return false;
         }
@@ -264,7 +311,7 @@ if (!!window.BX_REMOTE_PLAY_CONFIG) {
 
     // Add patches that are only needed when start playing
     loadingEndingChunks(str: string) {
-        const text = '"FamilySagaManager"';
+        let text = '"FamilySagaManager"';
         if (!str.includes(text)) {
             return false;
         }
@@ -278,7 +325,7 @@ if (!!window.BX_REMOTE_PLAY_CONFIG) {
     // Disable StreamGate
     disableStreamGate(str: string) {
         const index = str.indexOf('case"partially-ready":');
-        if (index === -1) {
+        if (index < 0) {
             return false;
         }
 
@@ -289,7 +336,7 @@ if (!!window.BX_REMOTE_PLAY_CONFIG) {
     },
 
     exposeTouchLayoutManager(str: string) {
-        const text = 'this._perScopeLayoutsStream=new';
+        let text = 'this._perScopeLayoutsStream=new';
         if (!str.includes(text)) {
             return false;
         }
@@ -308,7 +355,7 @@ window.dispatchEvent(new Event("${BxEvent.TOUCH_LAYOUT_MANAGER_READY}"));
     patchBabylonRendererClass(str: string) {
         // ()=>{a.current.render(),h.current=window.requestAnimationFrame(l)
         let index = str.indexOf('.current.render(),');
-        if (index === -1) {
+        if (index < 0) {
             return false;
         }
 
@@ -336,7 +383,7 @@ if (window.BX_EXPOSED.stopTakRendering) {
     },
 
     supportLocalCoOp(str: string) {
-        const text = 'this.gamepadMappingsToSend=[],';
+        let text = 'this.gamepadMappingsToSend=[],';
         if (!str.includes(text)) {
             return false;
         }
@@ -348,7 +395,7 @@ if (window.BX_EXPOSED.stopTakRendering) {
     },
 
     forceFortniteConsole(str: string) {
-        const text = 'sendTouchInputEnabledMessage(e){';
+        let text = 'sendTouchInputEnabledMessage(e){';
         if (!str.includes(text)) {
             return false;
         }
@@ -360,14 +407,16 @@ if (window.BX_EXPOSED.stopTakRendering) {
     },
 
     disableTakRenderer(str: string) {
-        const text = 'const{TakRenderer:';
+        let text = 'const{TakRenderer:';
         if (!str.includes(text)) {
             return false;
         }
 
-        let remotePlayCode = '';
+        let autoOffCode = '';
-        if (getPref(PrefKey.STREAM_TOUCH_CONTROLLER) !== 'off' && getPref(PrefKey.STREAM_TOUCH_CONTROLLER_AUTO_OFF)) {
+        if (getPref(PrefKey.STREAM_TOUCH_CONTROLLER) === StreamTouchController.OFF) {
-            remotePlayCode = `
+            autoOffCode = 'return;';
+        } else if (getPref(PrefKey.STREAM_TOUCH_CONTROLLER_AUTO_OFF)) {
+            autoOffCode = `
 const gamepads = window.navigator.getGamepads();
 let gamepadFound = false;
 
@@ -385,13 +434,11 @@ if (gamepadFound) {
         }
 
         const newCode = `
-if (!!window.BX_REMOTE_PLAY_CONFIG) {
+${autoOffCode}
-    ${remotePlayCode}
+
-} else {
+const titleInfo = window.BX_EXPOSED.getTitleInfo();
-    const titleInfo = window.BX_EXPOSED.getTitleInfo();
+if (titleInfo && !titleInfo.details.hasTouchSupport && !titleInfo.details.hasFakeTouchSupport) {
-    if (titleInfo && !titleInfo.details.hasTouchSupport && !titleInfo.details.hasFakeTouchSupport) {
+    return;
-        return;
-    }
 }
 `;
 
@@ -400,7 +447,7 @@ if (!!window.BX_REMOTE_PLAY_CONFIG) {
     },
 
     streamCombineSources(str: string) {
-        const text = 'this.useCombinedAudioVideoStream=!!this.deviceInformation.isTizen';
+        let text = 'this.useCombinedAudioVideoStream=!!this.deviceInformation.isTizen';
         if (!str.includes(text)) {
             return false;
         }
@@ -410,7 +457,7 @@ if (!!window.BX_REMOTE_PLAY_CONFIG) {
     },
 
     patchStreamHud(str: string) {
-        const text = 'let{onCollapse';
+        let text = 'let{onCollapse';
         if (!str.includes(text)) {
             return false;
         }
@@ -423,7 +470,7 @@ e.guideUI = null;
 `;
 
         // Remove the TAK Edit button when the touch controller is disabled
-        if (getPref(PrefKey.STREAM_TOUCH_CONTROLLER) === 'off') {
+        if (getPref(PrefKey.STREAM_TOUCH_CONTROLLER) === StreamTouchController.OFF) {
             newCode += 'e.canShowTakHUD = false;';
         }
 
@@ -432,22 +479,33 @@ e.guideUI = null;
     },
 
     broadcastPollingMode(str: string) {
-        const text = '.setPollingMode=e=>{';
+        let text = '.setPollingMode=e=>{';
         if (!str.includes(text)) {
             return false;
         }
 
         const newCode = `
-BxEvent.dispatch(window, BxEvent.XCLOUD_POLLING_MODE_CHANGED, {mode: e});
+BxEvent.dispatch(window, BxEvent.XCLOUD_POLLING_MODE_CHANGED, {mode: e.toLowerCase()});
 `;
         str = str.replace(text, text + newCode);
         return str;
     },
 
+    patchGamepadPolling(str: string) {
+        let index = str.indexOf('.shouldHandleGamepadInput)())return void');
+        if (index < 0) {
+            return false;
+        }
+
+        index = str.indexOf('{', index - 20) + 1;
+        str = str.substring(0, index) + 'if (window.BX_EXPOSED.disableGamepadPolling) return;' + str.substring(index);
+        return str;
+    },
+
     patchXcloudTitleInfo(str: string) {
-        const text = 'async cloudConnect';
+        let text = 'async cloudConnect';
         let index = str.indexOf(text);
-        if (index === -1) {
+        if (index < 0) {
             return false;
         }
 
@@ -467,9 +525,9 @@ BxLogger.info('patchXcloudTitleInfo', ${titleInfoVar});
     },
 
     patchRemotePlayMkb(str: string) {
-        const text = 'async homeConsoleConnect';
+        let text = 'async homeConsoleConnect';
         let index = str.indexOf(text);
-        if (index === -1) {
+        if (index < 0) {
             return false;
         }
 
@@ -495,7 +553,7 @@ BxLogger.info('patchRemotePlayMkb', ${configsVar});
     },
 
     patchAudioMediaStream(str: string) {
-        const text = '.srcObject=this.audioMediaStream,';
+        let text = '.srcObject=this.audioMediaStream,';
         if (!str.includes(text)) {
             return false;
         }
@@ -507,7 +565,7 @@ BxLogger.info('patchRemotePlayMkb', ${configsVar});
     },
 
     patchCombinedAudioVideoMediaStream(str: string) {
-        const text = '.srcObject=this.combinedAudioVideoStream';
+        let text = '.srcObject=this.combinedAudioVideoStream';
         if (!str.includes(text)) {
             return false;
         }
@@ -518,7 +576,7 @@ BxLogger.info('patchRemotePlayMkb', ${configsVar});
     },
 
     patchTouchControlDefaultOpacity(str: string) {
-        const text = 'opacityMultiplier:1';
+        let text = 'opacityMultiplier:1';
         if (!str.includes(text)) {
             return false;
         }
@@ -530,7 +588,7 @@ BxLogger.info('patchRemotePlayMkb', ${configsVar});
     },
 
     patchShowSensorControls(str: string) {
-        const text = '{shouldShowSensorControls:';
+        let text = '{shouldShowSensorControls:';
         if (!str.includes(text)) {
             return false;
         }
@@ -543,7 +601,7 @@ BxLogger.info('patchRemotePlayMkb', ${configsVar});
 
     /*
     exposeEventTarget(str: string) {
-        const text ='this._eventTarget=new EventTarget';
+        let text ='this._eventTarget=new EventTarget';
         if (!str.includes(text)) {
             return false;
         }
@@ -560,7 +618,7 @@ window.dispatchEvent(new Event('${BxEvent.STREAM_EVENT_TARGET_READY}'))
 
     // Class with: connectAsync(), doConnectAsync(), setPlayClient()
     exposeStreamSession(str: string) {
-        const text =',this._connectionType=';
+        let text =',this._connectionType=';
         if (!str.includes(text)) {
             return false;
         }
@@ -574,7 +632,7 @@ true` + text;
     },
 
     skipFeedbackDialog(str: string) {
-        const text = '&&this.shouldTransitionToFeedback(';
+        let text = '&&this.shouldTransitionToFeedback(';
         if (!str.includes(text)) {
             return false;
         }
@@ -584,7 +642,7 @@ true` + text;
     },
 
     enableNativeMkb(str: string) {
-        const text = 'e.mouseSupported&&e.keyboardSupported&&e.fullscreenSupported;';
+        let text = 'e.mouseSupported&&e.keyboardSupported&&e.fullscreenSupported;';
         if ((!str.includes(text))) {
             return false;
         }
@@ -594,7 +652,7 @@ true` + text;
     },
 
     patchMouseAndKeyboardEnabled(str: string) {
-        const text = 'get mouseAndKeyboardEnabled(){';
+        let text = 'get mouseAndKeyboardEnabled(){';
         if (!str.includes(text)) {
             return false;
         }
@@ -604,7 +662,7 @@ true` + text;
     },
 
     exposeInputSink(str: string) {
-        const text = 'this.controlChannel=null,this.inputChannel=null';
+        let text = 'this.controlChannel=null,this.inputChannel=null';
         if (!str.includes(text)) {
             return false;
         }
@@ -616,13 +674,283 @@ true` + text;
     },
 
     disableNativeRequestPointerLock(str: string) {
-        const text = 'async requestPointerLock(){';
+        let text = 'async requestPointerLock(){';
         if (!str.includes(text)) {
             return false;
         }
 
         str = str.replace(text, text + 'return;');
         return str;
+    },
+
+    // Fix crashing when RequestInfo.origin is empty
+    patchRequestInfoCrash(str: string) {
+        let text = 'if(!e)throw new Error("RequestInfo.origin is falsy");';
+        if (!str.includes(text)) {
+            return false;
+        }
+
+        str = str.replace(text, 'if (!e) e = "https://www.xbox.com";');
+        return str;
+    },
+
+    exposeDialogRoutes(str: string) {
+        let text = 'return{goBack:function(){';
+        if (!str.includes(text)) {
+            return false;
+        }
+
+        str = str.replace(text, 'return window.BX_EXPOSED.dialogRoutes = {goBack:function(){');
+        return str;
+    },
+
+    /*
+    (x.AW, {
+        path: V.LoginDeviceCode.path,
+        exact: !0,
+        render: () => (0, n.jsx)(qe, {
+            children: (0, n.jsx)(Et.R, {})
+        })
+    }, V.LoginDeviceCode.name),
+
+    const qe = e => {
+        let {
+            children: t
+        } = e;
+        const {
+            isTV: a,
+            isSupportedTVBrowser: r
+        } = (0, T.d)();
+        return a && r ? (0, n.jsx)(n.Fragment, {
+            children: t
+        }) : (0, n.jsx)(x.l_, {
+            to: V.Home.getLink()
+        })
+    };
+    */
+    enableTvRoutes(str: string) {
+        let index = str.indexOf('.LoginDeviceCode.path,');
+        if (index < 0) {
+            return false;
+        }
+
+        // Find *qe* name
+        const match = /render:.*?jsx\)\(([^,]+),/.exec(str.substring(index, index + 100));
+        if (!match) {
+            return false;
+        }
+
+        const funcName = match[1];
+
+        // Replace *qe*'s return value
+        // `return a && r ?` => `return a && r || true ?`
+        index = str.indexOf(`const ${funcName}=e=>{`);
+        index > -1 && (index = str.indexOf('return ', index));
+        index > -1 && (index = str.indexOf('?', index));
+
+        if (index < 0) {
+            return false;
+        }
+
+        str = str.substring(0, index) + '|| true' + str.substring(index);
+        return str;
+    },
+
+    // Don't render "Play With Friends" sections
+    ignorePlayWithFriendsSection(str: string) {
+        let index = str.indexOf('location:"PlayWithFriendsRow",');
+        if (index < 0) {
+            return false;
+        }
+
+        index = PatcherUtils.lastIndexOf(str, 'return', index, 50);
+        if (index < 0) {
+            return false;
+        }
+
+        str = PatcherUtils.replaceWith(str, index, 'return', 'return null;');
+        return str;
+    },
+
+    // Don't render "All Games" sections
+    ignoreAllGamesSection(str: string) {
+        let index = str.indexOf('className:"AllGamesRow-module__allGamesRowContainer');
+        if (index < 0) {
+            return false;
+        }
+
+        index = PatcherUtils.indexOf(str, 'grid:!0,', index, 1500);
+        if (index < 0) {
+            return false;
+        }
+
+        index = PatcherUtils.lastIndexOf(str, '(0,', index, 70);
+        if (index < 0) {
+            return false;
+        }
+
+        str = PatcherUtils.insertAt(str, index, 'true ? null :');
+        return str;
+    },
+
+    // home-page.js
+    ignorePlayWithTouchSection(str: string) {
+        let index = str.indexOf('("Play_With_Touch"),');
+        if (index < 0) {
+            return false;
+        }
+
+        index = PatcherUtils.lastIndexOf(str, 'const ', index, 30);
+        if (index < 0) {
+            return false;
+        }
+
+        str = PatcherUtils.insertAt(str, index, 'return null;');
+        return str;
+    },
+
+    // home-page.js
+    ignoreSiglSections(str: string) {
+        let index = str.indexOf('SiglRow-module__heroCard___');
+        if (index < 0) {
+            return false;
+        }
+
+        index = PatcherUtils.lastIndexOf(str, 'const[', index, 300);
+        if (index < 0) {
+            return false;
+        }
+
+        const PREF_HIDE_SECTIONS = getPref(PrefKey.UI_HIDE_SECTIONS) as UiSection[];
+        const siglIds: GamePassCloudGallery[] = [];
+
+        const sections: PartialRecord<UiSection, GamePassCloudGallery> = {
+            [UiSection.NATIVE_MKB]: GamePassCloudGallery.NATIVE_MKB,
+            [UiSection.MOST_POPULAR]: GamePassCloudGallery.MOST_POPULAR,
+        };
+
+        PREF_HIDE_SECTIONS.forEach(section => {
+            const galleryId = sections[section];
+            galleryId && siglIds.push(galleryId);
+        });
+
+        const checkSyntax = siglIds.map(item => `siglId === "${item}"`).join(' || ');
+
+        const newCode = `
+if (e && e.id) {
+    const siglId = e.id;
+    if (${checkSyntax}) {
+        return null;
+    }
+}
+`;
+        str = PatcherUtils.insertAt(str, index, newCode);
+        return str;
+    },
+
+    // Override Storage.getSettings()
+    overrideStorageGetSettings(str: string) {
+        let text = '}getSetting(e){';
+        if (!str.includes(text)) {
+            return false;
+        }
+
+        const newCode = `
+// console.log('setting', this.baseStorageKey, e);
+if (this.baseStorageKey in window.BX_EXPOSED.overrideSettings) {
+    const settings = window.BX_EXPOSED.overrideSettings[this.baseStorageKey];
+    if (e in settings) {
+        return settings[e];
+    }
+}
+`;
+        str = str.replace(text, text + newCode);
+        return str;
+    },
+
+    // game-stream.js   24.16.4
+    alwaysShowStreamHud(str: string) {
+        let index = str.indexOf(',{onShowStreamMenu:');
+        if (index < 0) {
+            return false;
+        }
+
+        index = str.indexOf('&&(0,', index - 100);
+        if (index < 0) {
+            return false;
+        }
+
+        const commaIndex = str.indexOf(',', index - 10);
+        str = str.substring(0, commaIndex) + ',true' + str.substring(index);
+        return str;
+    },
+
+    // 24225.js#4127, 24.17.11
+    patchSetCurrentlyFocusedInteractable(str: string) {
+        let index = str.indexOf('.setCurrentlyFocusedInteractable=(');
+        if (index < 0) {
+            return false;
+        }
+
+        index = str.indexOf('{', index) + 1;
+        str = str.substring(0, index) + codeSetCurrentlyFocusedInteractable + str.substring(index);
+        return str;
+    },
+
+    // product-details-page.js#2388, 24.17.20
+    detectProductDetailsPage(str: string) {
+        let index = str.indexOf('{location:"ProductDetailPage",');
+        if (index < 0) {
+            return false;
+        }
+
+        index = str.indexOf('return', index - 40);
+        if (index < 0) {
+            return false;
+        }
+
+        str = str.substring(0, index) + 'BxEvent.dispatch(window, BxEvent.XCLOUD_RENDERING_COMPONENT, {component: "product-details"});' + str.substring(index);
+        return str;
+    },
+
+    detectBrowserRouterReady(str: string) {
+        let text = 'BrowserRouter:()=>';
+        if (!str.includes(text)) {
+            return false;
+        }
+
+        let index = str.indexOf('{history:this.history,');
+        if (index < 0) {
+            return false;
+        }
+
+        index = PatcherUtils.lastIndexOf(str, 'return', index, 100);
+        if (index < 0) {
+            return false;
+        }
+
+        str = PatcherUtils.insertAt(str, index, 'window.BxEvent.dispatch(window, window.BxEvent.XCLOUD_ROUTER_HISTORY_READY, {history: this.history});');
+        return str;
+    },
+
+    // Set Achievements list's filter default to "Locked"
+    guideAchievementsDefaultLocked(str: string) {
+        let index = str.indexOf('FilterButton-module__container');
+        index >= 0 && (index = PatcherUtils.lastIndexOf(str, '.All', index, 150));
+        if (index < 0) {
+            return false;
+        }
+
+        str = PatcherUtils.replaceWith(str, index, '.All', '.Locked');
+
+        index = str.indexOf('"Guide_Achievements_Unlocked_Empty","Guide_Achievements_Locked_Empty"');
+        index >= 0 && (index = PatcherUtils.indexOf(str, '.All', index, 250));
+        if (index < 0) {
+            return false;
+        }
+
+        str = PatcherUtils.replaceWith(str, index, '.All', '.Locked');
+        return str;
     }
 };
 
@@ -634,16 +962,34 @@ let PATCH_ORDERS: PatchArray = [
         'exposeInputSink',
     ] : []),
 
+    'detectBrowserRouterReady',
+    'patchRequestInfoCrash',
+
     'disableStreamGate',
     'overrideSettings',
     'broadcastPollingMode',
+    'patchGamepadPolling',
 
     'exposeStreamSession',
+    'exposeDialogRoutes',
+
+    'guideAchievementsDefaultLocked',
+
+    'enableTvRoutes',
+    AppInterface && 'detectProductDetailsPage',
+
+    'overrideStorageGetSettings',
+    getPref(PrefKey.UI_GAME_CARD_SHOW_WAIT_TIME) && 'patchSetCurrentlyFocusedInteractable',
 
     getPref(PrefKey.UI_LAYOUT) !== 'default' && 'websiteLayout',
     getPref(PrefKey.LOCAL_CO_OP_ENABLED) && 'supportLocalCoOp',
     getPref(PrefKey.GAME_FORTNITE_FORCE_CONSOLE) && 'forceFortniteConsole',
 
+    getPref(PrefKey.UI_HIDE_SECTIONS).includes(UiSection.FRIENDS) && 'ignorePlayWithFriendsSection',
+    getPref(PrefKey.UI_HIDE_SECTIONS).includes(UiSection.ALL_GAMES) && 'ignoreAllGamesSection',
+    getPref(PrefKey.UI_HIDE_SECTIONS).includes(UiSection.TOUCH) && 'ignorePlayWithTouchSection',
+    (getPref(PrefKey.UI_HIDE_SECTIONS).includes(UiSection.NATIVE_MKB) || getPref(PrefKey.UI_HIDE_SECTIONS).includes(UiSection.MOST_POPULAR)) && 'ignoreSiglSections',
+
     ...(getPref(PrefKey.BLOCK_TRACKING) ? [
         'disableAiTrack',
         'disableTelemetry',
@@ -652,14 +998,14 @@ let PATCH_ORDERS: PatchArray = [
         'disableIndexDbLogging',
 
         'disableTelemetryProvider',
-        'disableTrackEvent',
     ] : []),
 
     ...(getPref(PrefKey.REMOTE_PLAY_ENABLED) ? [
         'remotePlayKeepAlive',
         'remotePlayDirectConnectUrl',
         'remotePlayDisableAchievementToast',
-        STATES.userAgentHasTouchSupport && 'patchUpdateInputConfigurationAsync',
+        'remotePlayRecentlyUsedTitleIds',
+        STATES.userAgent.capabilities.touch && 'patchUpdateInputConfigurationAsync',
     ] : []),
 
     ...(BX_FLAGS.EnableXcloudLogging ? [
@@ -675,6 +1021,8 @@ let PLAYING_PATCH_ORDERS: PatchArray = [
     'patchStreamHud',
     'playVibration',
 
+    'alwaysShowStreamHud',
+
     // 'exposeEventTarget',
 
     // Patch volume control for normal stream
@@ -685,10 +1033,10 @@ let PLAYING_PATCH_ORDERS: PatchArray = [
     // Skip feedback dialog
     getPref(PrefKey.STREAM_DISABLE_FEEDBACK_DIALOG) && 'skipFeedbackDialog',
 
-    ...(STATES.userAgentHasTouchSupport ? [
+    ...(STATES.userAgent.capabilities.touch ? [
-        getPref(PrefKey.STREAM_TOUCH_CONTROLLER) === 'all' && 'patchShowSensorControls',
+        getPref(PrefKey.STREAM_TOUCH_CONTROLLER) === StreamTouchController.ALL && 'patchShowSensorControls',
-        getPref(PrefKey.STREAM_TOUCH_CONTROLLER) === 'all' && 'exposeTouchLayoutManager',
+        getPref(PrefKey.STREAM_TOUCH_CONTROLLER) === StreamTouchController.ALL && 'exposeTouchLayoutManager',
-        (getPref(PrefKey.STREAM_TOUCH_CONTROLLER) === 'off' || getPref(PrefKey.STREAM_TOUCH_CONTROLLER_AUTO_OFF)) && 'disableTakRenderer',
+        (getPref(PrefKey.STREAM_TOUCH_CONTROLLER) === StreamTouchController.OFF || getPref(PrefKey.STREAM_TOUCH_CONTROLLER_AUTO_OFF) || !STATES.userAgent.capabilities.touch) && 'disableTakRenderer',
         getPref(PrefKey.STREAM_TOUCH_CONTROLLER_DEFAULT_OPACITY) !== 100 && 'patchTouchControlDefaultOpacity',
         'patchBabylonRendererClass',
     ] : []),
@@ -772,7 +1120,8 @@ export class Patcher {
             }
 
             const func = item[1][id];
-            let str = func.toString();
+            const funcStr = func.toString();
+            let patchedFuncStr = funcStr;
 
             let modified = false;
 
@@ -787,15 +1136,15 @@ export class Patcher {
                 }
 
                 // Check function against patch
-                const patchedStr = PATCHES[patchName].call(null, str);
+                const tmpStr = PATCHES[patchName].call(null, patchedFuncStr);
 
                 // Not patched
-                if (!patchedStr) {
+                if (!tmpStr) {
                     continue;
                 }
 
                 modified = true;
-                str = patchedStr;
+                patchedFuncStr = tmpStr;
 
                 BxLogger.info(LOG_TAG, `✅ ${patchName}`);
                 appliedPatches.push(patchName);
@@ -808,7 +1157,13 @@ export class Patcher {
 
             // Apply patched functions
             if (modified) {
-                item[1][id] = eval(str);
+                try {
+                    item[1][id] = eval(patchedFuncStr);
+                } catch (e: unknown) {
+                    if (e instanceof Error) {
+                        BxLogger.error(LOG_TAG, 'Error', appliedPatches, e.message, patchedFuncStr);
+                    }
+                }
             }
 
             // Save to cache

src/modules/patches/controller-shortcuts.js

@@ -1,3 +1,8 @@
+if (window.BX_EXPOSED.disableGamepadPolling) {
+    this.inputConfiguration.useIntervalWorkerThreadForInput && this.intervalWorker ? this.intervalWorker.scheduleTimer(50) : this.pollGamepadssetTimeoutTimerID = setTimeout(this.pollGamepads, 50);
+    return;
+}
+
 const currentGamepad = ${gamepadVar};
 
 // Share button on XS controller

src/modules/patches/expose-stream-session.js

@@ -15,6 +15,10 @@ window.dispatchEvent(new Event(BxEvent.STREAM_SESSION_READY));
 // Patch updateDimensions() to make native touch work correctly with WebGL2
 let updateDimensionsStr = this.updateDimensions.toString();
 
+if (updateDimensionsStr.startsWith('function ')) {
+    updateDimensionsStr = updateDimensionsStr.substring(9);
+}
+
 // if(r){
 const renderTargetVar = updateDimensionsStr.match(/if\((\w+)\){/)[1];
 

src/modules/patches/local-co-op-enable.js

@@ -1,6 +1,10 @@
 let match;
 let onGamepadChangedStr = this.onGamepadChanged.toString();
 
+if (onGamepadChangedStr.startsWith('function ')) {
+    onGamepadChangedStr = onGamepadChangedStr.substring(9);
+}
+
 onGamepadChangedStr = onGamepadChangedStr.replaceAll('0', 'arguments[1]');
 eval(`this.onGamepadChanged = function ${onGamepadChangedStr}`);
 

src/modules/patches/set-currently-focused-interactable.js

@@ -0,0 +1 @@
+e && BxEvent.dispatch(window, BxEvent.NAVIGATION_FOCUS_CHANGED, {element: e});

src/modules/player/shaders/clarity_boost.fs

@@ -1,121 +1,100 @@
-const int FILTER_UNSHARP_MASKING = 1;
+#version 300 es
-const int FILTER_CAS = 2;
 
-precision highp float;
+precision mediump float;
 uniform sampler2D data;
 uniform vec2 iResolution;
 
+const int FILTER_UNSHARP_MASKING = 1;
+// const int FILTER_CAS = 2;
+
+// constrast = 0.8
+const float CAS_CONTRAST_PEAK = 0.8 * -3.0 + 8.0;
+
+// Luminosity factor
+const vec3 LUMINOSITY_FACTOR = vec3(0.2126, 0.7152, 0.0722);
+
 uniform int filterId;
 uniform float sharpenFactor;
 uniform float brightness;
 uniform float contrast;
 uniform float saturation;
 
-vec3 textureAt(sampler2D tex, vec2 coord) {
+out vec4 fragColor;
-    return texture2D(tex, coord / iResolution.xy).rgb;
+
-}
+vec3 clarityBoost(sampler2D tex, vec2 coord, vec3 e) {
+    vec2 texelSize = 1.0 / iResolution.xy;
 
-vec3 clarityBoost(sampler2D tex, vec2 coord)
-{
     // Load a collection of samples in a 3x3 neighorhood, where e is the current pixel.
     // a b c
     // d e f
     // g h i
-    vec3 a = textureAt(tex, coord + vec2(-1, 1));
+    vec3 a = texture(tex, coord + texelSize * vec2(-1, 1)).rgb;
-    vec3 b = textureAt(tex, coord + vec2(0, 1));
+    vec3 b = texture(tex, coord + texelSize * vec2(0, 1)).rgb;
-    vec3 c = textureAt(tex, coord + vec2(1, 1));
+    vec3 c = texture(tex, coord + texelSize * vec2(1, 1)).rgb;
 
-    vec3 d = textureAt(tex, coord + vec2(-1, 0));
+    vec3 d = texture(tex, coord + texelSize * vec2(-1, 0)).rgb;
-    vec3 e = textureAt(tex, coord);
+    vec3 f = texture(tex, coord + texelSize * vec2(1, 0)).rgb;
-    vec3 f = textureAt(tex, coord + vec2(1, 0));
 
-    vec3 g = textureAt(tex, coord + vec2(-1, -1));
+    vec3 g = texture(tex, coord + texelSize * vec2(-1, -1)).rgb;
-    vec3 h = textureAt(tex, coord + vec2(0, -1));
+    vec3 h = texture(tex, coord + texelSize * vec2(0, -1)).rgb;
-    vec3 i = textureAt(tex, coord + vec2(1, -1));
+    vec3 i = texture(tex, coord + texelSize * vec2(1, -1)).rgb;
 
-    if (filterId == FILTER_CAS) {
+    // USM
-        // Soft min and max.
+    if (filterId == FILTER_UNSHARP_MASKING) {
-        //  a b c             b
+        vec3 gaussianBlur = (a + c + g + i) * 1.0 + (b + d + f + h) * 2.0 + e * 4.0;
-        //  d e f * 0.5  +  d e f * 0.5
+        gaussianBlur /= 16.0;
-        //  g h i             h
-        // These are 2.0x bigger (factored out the extra multiply).
-        vec3 minRgb = min(min(min(d, e), min(f, b)), h);
-        vec3 minRgb2 = min(min(a, c), min(g, i));
-        minRgb += min(minRgb, minRgb2);
-
-        vec3 maxRgb = max(max(max(d, e), max(f, b)), h);
-        vec3 maxRgb2 = max(max(a, c), max(g, i));
-        maxRgb += max(maxRgb, maxRgb2);
-
-        // Smooth minimum distance to signal limit divided by smooth max.
-        vec3 reciprocalMaxRgb = 1.0 / maxRgb;
-        vec3 amplifyRgb = clamp(min(minRgb, 2.0 - maxRgb) * reciprocalMaxRgb, 0.0, 1.0);
-
-        // Shaping amount of sharpening.
-        amplifyRgb = inversesqrt(amplifyRgb);
-
-        float contrast = 0.8;
-        float peak = -3.0 * contrast + 8.0;
-        vec3 weightRgb = -(1.0 / (amplifyRgb * peak));
-
-        vec3 reciprocalWeightRgb = 1.0 / (4.0 * weightRgb + 1.0);
-
-        //                0 w 0
-        // Filter shape:  w 1 w
-        //                0 w 0
-        vec3 window = (b + d) + (f + h);
-        vec3 outColor = clamp((window * weightRgb + e) * reciprocalWeightRgb, 0.0, 1.0);
-
-        outColor = mix(e, outColor, sharpenFactor / 2.0);
-
-        return outColor;
-    } else if (filterId == FILTER_UNSHARP_MASKING) {
-        vec3 gaussianBlur = (a * 1.0 + b * 2.0 + c * 1.0 +
-            d * 2.0 + e * 4.0 + f * 2.0 +
-            g * 1.0 + h * 2.0 + i * 1.0) / 16.0;
 
         // Return edge detection
         return e + (e - gaussianBlur) * sharpenFactor / 3.0;
     }
 
-    return e;
+    // CAS
-}
+    // Soft min and max.
+    //  a b c             b
+    //  d e f * 0.5  +  d e f * 0.5
+    //  g h i             h
+    // These are 2.0x bigger (factored out the extra multiply).
+    vec3 minRgb = min(min(min(d, e), min(f, b)), h);
+    minRgb += min(min(a, c), min(g, i));
 
-vec3 adjustBrightness(vec3 color) {
+    vec3 maxRgb = max(max(max(d, e), max(f, b)), h);
-    return (1.0 + brightness) * color;
+    maxRgb += max(max(a, c), max(g, i));
-}
 
-vec3 adjustContrast(vec3 color) {
+    // Smooth minimum distance to signal limit divided by smooth max.
-    return 0.5 + (1.0 + contrast) * (color - 0.5);
+    vec3 reciprocalMaxRgb = 1.0 / maxRgb;
-}
+    vec3 amplifyRgb = clamp(min(minRgb, 2.0 - maxRgb) * reciprocalMaxRgb, 0.0, 1.0);
 
-vec3 adjustSaturation(vec3 color) {
+    // Shaping amount of sharpening.
-    const vec3 luminosityFactor = vec3(0.2126, 0.7152, 0.0722);
+    amplifyRgb = inversesqrt(amplifyRgb);
-    vec3 grayscale = vec3(dot(color, luminosityFactor));
 
-    return mix(grayscale, color, 1.0 + saturation);
+    vec3 weightRgb = -(1.0 / (amplifyRgb * CAS_CONTRAST_PEAK));
+    vec3 reciprocalWeightRgb = 1.0 / (4.0 * weightRgb + 1.0);
+
+    //                0 w 0
+    // Filter shape:  w 1 w
+    //                0 w 0
+    vec3 window = b + d + f + h;
+    vec3 outColor = clamp((window * weightRgb + e) * reciprocalWeightRgb, 0.0, 1.0);
+
+    return mix(e, outColor, sharpenFactor / 2.0);
 }
 
 void main() {
-    vec3 color;
+    vec2 uv = gl_FragCoord.xy / iResolution.xy;
+    // Get current pixel
+    vec3 color = texture(data, uv).rgb;
 
-    if (sharpenFactor > 0.0) {
+    // Clarity boost
-        color = clarityBoost(data, gl_FragCoord.xy);
+    color = sharpenFactor > 0.0 ? clarityBoost(data, uv, color) : color;
-    } else {
-        color = textureAt(data, gl_FragCoord.xy);
-    }
 
-    if (saturation != 0.0) {
+    // Saturation
-        color = adjustSaturation(color);
+    color = saturation != 1.0 ? mix(vec3(dot(color, LUMINOSITY_FACTOR)), color, saturation) : color;
-    }
 
-    if (contrast != 0.0) {
+    // Contrast
-        color = adjustContrast(color);
+    color = contrast * (color - 0.5) + 0.5;
-    }
 
-    if (brightness != 0.0) {
+    // Brightness
-        color = adjustBrightness(color);
+    color = brightness * color;
-    }
 
-    gl_FragColor = vec4(color, 1.0);
+    fragColor = vec4(color, 1.0);
 }

src/modules/player/shaders/clarity_boost.vert

@@ -1,5 +1,7 @@
-attribute vec2 position;
+#version 300 es
+
+in vec4 position;
 
 void main() {
-    gl_Position = vec4(position, 0, 1);
+    gl_Position = position;
 }

src/modules/player/webgl2-player.ts

@@ -1,21 +1,23 @@
 import vertClarityBoost from "./shaders/clarity_boost.vert" with { type: "text" };
 import fsClarityBoost from "./shaders/clarity_boost.fs" with { type: "text" };
 import { BxLogger } from "@/utils/bx-logger";
+import { PrefKey } from "@/enums/pref-keys";
+import { getPref } from "@/utils/settings-storages/global-settings-storage";
 
 
 const LOG_TAG = 'WebGL2Player';
 
 export class WebGL2Player {
-    #$video: HTMLVideoElement;
+    private $video: HTMLVideoElement;
-    #$canvas: HTMLCanvasElement;
+    private $canvas: HTMLCanvasElement;
 
-    #gl: WebGL2RenderingContext | null = null;
+    private gl: WebGL2RenderingContext | null = null;
-    #resources: Array<any> = [];
+    private resources: Array<any> = [];
-    #program: WebGLProgram | null = null;
+    private program: WebGLProgram | null = null;
 
-    #stopped: boolean = false;
+    private stopped: boolean = false;
 
-    #options = {
+    private options = {
         filterId: 1,
         sharpenFactor: 0,
         brightness: 0.0,
@@ -23,110 +25,131 @@ export class WebGL2Player {
         saturation: 0.0,
     };
 
-    #animFrameId: number | null = null;
+    private targetFps = 60;
+    private frameInterval = Math.ceil(1000 / this.targetFps);
+    private lastFrameTime = 0;
+
+    private animFrameId: number | null = null;
 
     constructor($video: HTMLVideoElement) {
         BxLogger.info(LOG_TAG, 'Initialize');
-        this.#$video = $video;
+        this.$video = $video;
 
         const $canvas = document.createElement('canvas');
         $canvas.width = $video.videoWidth;
         $canvas.height = $video.videoHeight;
-        this.#$canvas = $canvas;
+        this.$canvas = $canvas;
 
-        this.#setupShaders();
+        this.setupShaders();
-        this.#setupRendering();
+        this.setupRendering();
 
         $video.insertAdjacentElement('afterend', $canvas);
     }
 
     setFilter(filterId: number, update = true) {
-        this.#options.filterId = filterId;
+        this.options.filterId = filterId;
         update && this.updateCanvas();
     }
 
     setSharpness(sharpness: number, update = true) {
-        this.#options.sharpenFactor = sharpness;
+        this.options.sharpenFactor = sharpness;
         update && this.updateCanvas();
     }
 
     setBrightness(brightness: number, update = true) {
-        this.#options.brightness = (brightness - 100) / 100;
+        this.options.brightness = 1 + (brightness - 100) / 100;
         update && this.updateCanvas();
     }
 
     setContrast(contrast: number, update = true) {
-        this.#options.contrast = (contrast - 100) / 100;
+        this.options.contrast = 1 + (contrast - 100) / 100;
         update && this.updateCanvas();
     }
 
     setSaturation(saturation: number, update = true) {
-        this.#options.saturation = (saturation - 100) / 100;
+        this.options.saturation = 1 + (saturation - 100) / 100;
         update && this.updateCanvas();
     }
 
+    setTargetFps(target: number) {
+        this.targetFps = target;
+        this.frameInterval = Math.ceil(1000 / target);
+    }
+
     getCanvas() {
-        return this.#$canvas;
+        return this.$canvas;
     }
 
     updateCanvas() {
-        const gl = this.#gl!;
+        const gl = this.gl!;
-        const program = this.#program!;
+        const program = this.program!;
 
-        gl.uniform2f(gl.getUniformLocation(program, 'iResolution'), this.#$canvas.width, this.#$canvas.height);
+        gl.uniform2f(gl.getUniformLocation(program, 'iResolution'), this.$canvas.width, this.$canvas.height);
 
-        gl.uniform1i(gl.getUniformLocation(program, 'filterId'), this.#options.filterId);
+        gl.uniform1i(gl.getUniformLocation(program, 'filterId'), this.options.filterId);
-        gl.uniform1f(gl.getUniformLocation(program, 'sharpenFactor'), this.#options.sharpenFactor);
+        gl.uniform1f(gl.getUniformLocation(program, 'sharpenFactor'), this.options.sharpenFactor);
-        gl.uniform1f(gl.getUniformLocation(program, 'brightness'), this.#options.brightness);
+        gl.uniform1f(gl.getUniformLocation(program, 'brightness'), this.options.brightness);
-        gl.uniform1f(gl.getUniformLocation(program, 'contrast'), this.#options.contrast);
+        gl.uniform1f(gl.getUniformLocation(program, 'contrast'), this.options.contrast);
-        gl.uniform1f(gl.getUniformLocation(program, 'saturation'), this.#options.saturation);
+        gl.uniform1f(gl.getUniformLocation(program, 'saturation'), this.options.saturation);
     }
 
     drawFrame() {
-        const gl = this.#gl!;
+        // Limit FPS
-        const $video = this.#$video;
+        if (this.targetFps < 60) {
+            const currentTime = performance.now();
+            const timeSinceLastFrame = currentTime - this.lastFrameTime;
+            if (timeSinceLastFrame < this.frameInterval) {
+                return;
+            }
+            this.lastFrameTime = currentTime;
+        }
+
+        const gl = this.gl!;
+        const $video = this.$video;
 
         gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, gl.RGB, gl.UNSIGNED_BYTE, $video);
         gl.drawArrays(gl.TRIANGLES, 0, 6);
     }
 
-    #setupRendering() {
+    private setupRendering() {
         let animate: any;
 
         if ('requestVideoFrameCallback' in HTMLVideoElement.prototype) {
-            const $video = this.#$video;
+            const $video = this.$video;
             animate = () => {
-                if (this.#stopped) {
+                if (this.stopped) {
                     return;
                 }
 
                 this.drawFrame();
-                this.#animFrameId = $video.requestVideoFrameCallback(animate);
+                this.animFrameId = $video.requestVideoFrameCallback(animate);
             }
 
-            this.#animFrameId = $video.requestVideoFrameCallback(animate);
+            this.animFrameId = $video.requestVideoFrameCallback(animate);
         } else {
             animate = () => {
-                if (this.#stopped) {
+                if (this.stopped) {
                     return;
                 }
 
                 this.drawFrame();
-                this.#animFrameId = requestAnimationFrame(animate);
+                this.animFrameId = requestAnimationFrame(animate);
             }
 
-            this.#animFrameId = requestAnimationFrame(animate);
+            this.animFrameId = requestAnimationFrame(animate);
         }
     }
 
-    #setupShaders() {
+    private setupShaders() {
-        const gl = this.#$canvas.getContext('webgl2', {
+        BxLogger.info(LOG_TAG, 'Setting up', getPref(PrefKey.VIDEO_POWER_PREFERENCE));
+
+        const gl = this.$canvas.getContext('webgl2', {
             isBx: true,
             antialias: true,
             alpha: false,
-            powerPreference: 'high-performance',
+            powerPreference: getPref(PrefKey.VIDEO_POWER_PREFERENCE),
         }) as WebGL2RenderingContext;
-        this.#gl = gl;
+        this.gl = gl;
 
         gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferWidth);
 
@@ -141,7 +164,7 @@ export class WebGL2Player {
 
         // Create and link program
         const program = gl.createProgram()!;
-        this.#program = program;
+        this.program = program;
 
         gl.attachShader(program, vShader);
         gl.attachShader(program, fShader);
@@ -158,7 +181,7 @@ export class WebGL2Player {
 
         // Vertices: A screen-filling quad made from two triangles
         const buffer = gl.createBuffer();
-        this.#resources.push(buffer);
+        this.resources.push(buffer);
 
         gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
         gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
@@ -175,7 +198,7 @@ export class WebGL2Player {
 
         // Texture to contain the video data
         const texture = gl.createTexture();
-        this.#resources.push(texture);
+        this.resources.push(texture);
 
         gl.bindTexture(gl.TEXTURE_2D, texture);
         gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
@@ -193,26 +216,26 @@ export class WebGL2Player {
 
     resume() {
         this.stop();
-        this.#stopped = false;
+        this.stopped = false;
         BxLogger.info(LOG_TAG, 'Resume');
 
-        this.#$canvas.classList.remove('bx-gone');
+        this.$canvas.classList.remove('bx-gone');
-        this.#setupRendering();
+        this.setupRendering();
     }
 
     stop() {
         BxLogger.info(LOG_TAG, 'Stop');
-        this.#$canvas.classList.add('bx-gone');
+        this.$canvas.classList.add('bx-gone');
 
-        this.#stopped = true;
+        this.stopped = true;
-        if (this.#animFrameId) {
+        if (this.animFrameId) {
             if ('requestVideoFrameCallback' in HTMLVideoElement.prototype) {
-                this.#$video.cancelVideoFrameCallback(this.#animFrameId);
+                this.$video.cancelVideoFrameCallback(this.animFrameId);
             } else {
-                cancelAnimationFrame(this.#animFrameId);
+                cancelAnimationFrame(this.animFrameId);
             }
 
-            this.#animFrameId = null;
+            this.animFrameId = null;
         }
     }
 
@@ -220,11 +243,11 @@ export class WebGL2Player {
         BxLogger.info(LOG_TAG, 'Destroy');
         this.stop();
 
-        const gl = this.#gl;
+        const gl = this.gl;
         if (gl) {
             gl.getExtension('WEBGL_lose_context')?.loseContext();
 
-            for (const resource of this.#resources) {
+            for (const resource of this.resources) {
                 if (resource instanceof WebGLProgram) {
                     gl.useProgram(null);
                     gl.deleteProgram(resource);
@@ -237,14 +260,14 @@ export class WebGL2Player {
                 }
             }
 
-            this.#gl = null;
+            this.gl = null;
         }
 
-        if (this.#$canvas.isConnected) {
+        if (this.$canvas.isConnected) {
-            this.#$canvas.parentElement?.removeChild(this.#$canvas);
+            this.$canvas.parentElement?.removeChild(this.$canvas);
         }
 
-        this.#$canvas.width = 1;
+        this.$canvas.width = 1;
-        this.#$canvas.height = 1;
+        this.$canvas.height = 1;
     }
 }

src/modules/remote-play-manager.ts

@@ -0,0 +1,232 @@
+import { STATES, AppInterface } from "@utils/global";
+import { Toast } from "@utils/toast";
+import { BxEvent } from "@utils/bx-event";
+import { t } from "@utils/translation";
+import { localRedirect } from "@modules/ui/ui";
+import { BxLogger } from "@utils/bx-logger";
+import { HeaderSection } from "./ui/header";
+import { PrefKey } from "@/enums/pref-keys";
+import { getPref, setPref } from "@/utils/settings-storages/global-settings-storage";
+import { RemotePlayNavigationDialog } from "./ui/dialog/remote-play-dialog";
+
+const LOG_TAG = 'RemotePlay';
+
+export const enum RemotePlayConsoleState {
+    ON = 'On',
+    OFF = 'Off',
+    STANDBY = 'ConnectedStandby',
+    UNKNOWN = 'Unknown',
+}
+
+type RemotePlayRegion = {
+    name: string;
+    baseUri: string;
+    isDefault: boolean;
+};
+
+type RemotePlayConsole = {
+    deviceName: string;
+    serverId: string;
+    powerState: RemotePlayConsoleState;
+    consoleType: string;
+    // playPath: string;
+    // outOfHomeWarning: string;
+    // wirelessWarning: string;
+    // isDevKit: string;
+};
+
+export class RemotePlayManager {
+    private static instance: RemotePlayManager;
+    public static getInstance(): RemotePlayManager {
+        if (!this.instance) {
+            this.instance = new RemotePlayManager();
+        }
+
+        return this.instance;
+    }
+
+    private isInitialized = false;
+
+    private XCLOUD_TOKEN!: string;
+    private XHOME_TOKEN!: string;
+
+    private consoles!: Array<RemotePlayConsole>;
+    private regions: Array<RemotePlayRegion> = [];
+
+    initialize() {
+        if (this.isInitialized) {
+            return;
+        }
+
+        this.isInitialized = true;
+
+        this.getXhomeToken(() => {
+            this.getConsolesList(() => {
+                BxLogger.info(LOG_TAG, 'Consoles', this.consoles);
+
+                STATES.supportedRegion && HeaderSection.showRemotePlayButton();
+                BxEvent.dispatch(window, BxEvent.REMOTE_PLAY_READY);
+            });
+        });
+    }
+
+    get xcloudToken() {
+        return this.XCLOUD_TOKEN;
+    }
+
+    set xcloudToken(token: string) {
+        this.XCLOUD_TOKEN = token;
+    }
+
+    get xhomeToken() {
+        return this.XHOME_TOKEN;
+    }
+
+    getConsoles() {
+        return this.consoles;
+    }
+
+
+    private getXhomeToken(callback: any) {
+        if (this.XHOME_TOKEN) {
+            callback();
+            return;
+        }
+
+        let GSSV_TOKEN;
+        try {
+            GSSV_TOKEN = JSON.parse(localStorage.getItem('xboxcom_xbl_user_info')!).tokens['http://gssv.xboxlive.com/'].token;
+        } catch (e) {
+            for (let i = 0; i < localStorage.length; i++){
+                const key = localStorage.key(i)!;
+                if (!key.startsWith('Auth.User.')) {
+                    continue;
+                }
+
+                const json = JSON.parse(localStorage.getItem(key)!);
+                for (const token of json.tokens) {
+                    if (!token.relyingParty.includes('gssv.xboxlive.com')) {
+                        continue;
+                    }
+
+                    GSSV_TOKEN = token.tokenData.token;
+                    break;
+                }
+
+                break;
+            }
+        }
+
+        const request = new Request('https://xhome.gssv-play-prod.xboxlive.com/v2/login/user', {
+            method: 'POST',
+            body: JSON.stringify({
+                offeringId: 'xhome',
+                token: GSSV_TOKEN,
+            }),
+            headers: {
+                'Content-Type': 'application/json; charset=utf-8',
+            },
+        });
+
+        fetch(request).then(resp => resp.json())
+            .then(json => {
+                this.regions = json.offeringSettings.regions;
+                this.XHOME_TOKEN = json.gsToken;
+                callback();
+            });
+    }
+
+    private async getConsolesList(callback: any) {
+        if (this.consoles) {
+            callback();
+            return;
+        }
+
+        const options = {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${this.XHOME_TOKEN}`,
+                },
+            };
+
+        // Test servers one by one
+        for (const region of this.regions) {
+            try {
+                const request = new Request(`${region.baseUri}/v6/servers/home?mr=50`, options);
+                const resp = await fetch(request);
+
+                const json = await resp.json();
+                if (json.results.length === 0) {
+                    continue;
+                }
+
+                this.consoles = json.results;
+
+                // Store working server
+                STATES.remotePlay.server = region.baseUri;
+
+                break;
+            } catch (e) {}
+        }
+
+        // None of the servers worked
+        if (!STATES.remotePlay.server) {
+            this.consoles = [];
+        }
+
+        callback();
+    }
+
+    play(serverId: string, resolution?: string) {
+        if (resolution) {
+            setPref(PrefKey.REMOTE_PLAY_RESOLUTION, resolution);
+        }
+
+        STATES.remotePlay.config = {
+            serverId: serverId,
+        };
+        window.BX_REMOTE_PLAY_CONFIG = STATES.remotePlay.config;
+
+        localRedirect('/launch/fortnite/BT5P2X999VH2#remote-play');
+    }
+
+    togglePopup(force = null) {
+        if (!this.isReady()) {
+            Toast.show(t('getting-consoles-list'));
+            return;
+        }
+
+        if (this.consoles.length === 0) {
+            Toast.show(t('no-consoles-found'), '', {instant: true});
+            return;
+        }
+
+        // Show native dialog in Android app
+        if (AppInterface && AppInterface.showRemotePlayDialog) {
+            AppInterface.showRemotePlayDialog(JSON.stringify(this.consoles));
+            (document.activeElement as HTMLElement).blur();
+            return;
+        }
+
+        RemotePlayNavigationDialog.getInstance().show();
+    }
+
+    static detect() {
+        if (!getPref(PrefKey.REMOTE_PLAY_ENABLED)) {
+            return;
+        }
+
+        STATES.remotePlay.isPlaying = window.location.pathname.includes('/launch/') && window.location.hash.startsWith('#remote-play');
+        if (STATES.remotePlay?.isPlaying) {
+            window.BX_REMOTE_PLAY_CONFIG = STATES.remotePlay.config;
+            // Remove /launch/... from URL
+            window.history.replaceState({origin: 'better-xcloud'}, '', 'https://www.xbox.com/' + location.pathname.substring(1, 6) + '/play');
+        } else {
+            window.BX_REMOTE_PLAY_CONFIG = null;
+        }
+    }
+
+    isReady() {
+        return this.consoles !== null;
+    }
+}

src/modules/remote-play.ts

@@ -1,358 +0,0 @@
-import { STATES, AppInterface } from "@utils/global";
-import { CE, createButton, ButtonStyle } from "@utils/html";
-import { BxIcon } from "@utils/bx-icon";
-import { Toast } from "@utils/toast";
-import { BxEvent } from "@utils/bx-event";
-import { getPref, PrefKey, setPref } from "@utils/preferences";
-import { t } from "@utils/translation";
-import { localRedirect } from "@modules/ui/ui";
-import { BxLogger } from "@utils/bx-logger";
-
-const LOG_TAG = 'RemotePlay';
-
-enum RemotePlayConsoleState {
-    ON = 'On',
-    OFF = 'Off',
-    STANDBY = 'ConnectedStandby',
-    UNKNOWN = 'Unknown',
-}
-
-type RemotePlayRegion = {
-    name: string;
-    baseUri: string;
-    isDefault: boolean;
-};
-
-type RemotePlayConsole = {
-    deviceName: string;
-    serverId: string;
-    powerState: RemotePlayConsoleState;
-    consoleType: string;
-    // playPath: string;
-    // outOfHomeWarning: string;
-    // wirelessWarning: string;
-    // isDevKit: string;
-};
-
-export class RemotePlay {
-    static XCLOUD_TOKEN: string;
-    static XHOME_TOKEN: string;
-    static #CONSOLES: Array<RemotePlayConsole>;
-    static #REGIONS: Array<RemotePlayRegion>;
-
-    static readonly #STATE_LABELS: {[key in RemotePlayConsoleState]: string} = {
-        [RemotePlayConsoleState.ON]: t('powered-on'),
-        [RemotePlayConsoleState.OFF]: t('powered-off'),
-        [RemotePlayConsoleState.STANDBY]: t('standby'),
-        [RemotePlayConsoleState.UNKNOWN]: t('unknown'),
-    };
-
-    static readonly BASE_DEVICE_INFO = {
-        appInfo: {
-            env: {
-                clientAppId: window.location.host,
-                clientAppType: 'browser',
-                clientAppVersion: '21.1.98',
-                clientSdkVersion: '8.5.3',
-                httpEnvironment: 'prod',
-                sdkInstallId: '',
-            },
-        },
-        dev: {
-            displayInfo: {
-                dimensions: {
-                    widthInPixels: 1920,
-                    heightInPixels: 1080,
-                },
-                pixelDensity: {
-                    dpiX: 1,
-                    dpiY: 1,
-                },
-            },
-            hw: {
-                make: 'Microsoft',
-                model: 'unknown',
-                sdktype: 'web',
-            },
-            os: {
-                name: 'windows',
-                ver: '22631.2715',
-                platform: 'desktop',
-            },
-            browser: {
-                browserName: 'chrome',
-                browserVersion: '119.0',
-            },
-        },
-    };
-
-    static #$content: HTMLElement;
-
-    static #initialize() {
-        if (RemotePlay.#$content) {
-            return;
-        }
-
-        RemotePlay.#$content = CE('div', {}, t('getting-consoles-list'));
-        RemotePlay.#getXhomeToken(() => {
-            RemotePlay.#getConsolesList(() => {
-                BxLogger.info(LOG_TAG, 'Consoles', RemotePlay.#CONSOLES);
-                RemotePlay.#renderConsoles();
-                BxEvent.dispatch(window, BxEvent.REMOTE_PLAY_READY);
-            });
-        });
-    }
-
-    static #renderConsoles() {
-        const $fragment = CE('div', {'class': 'bx-remote-play-container'});
-
-        if (!RemotePlay.#CONSOLES || RemotePlay.#CONSOLES.length === 0) {
-            $fragment.appendChild(CE('span', {}, t('no-consoles-found')));
-            RemotePlay.#$content = CE('div', {}, $fragment);
-            return;
-        }
-
-        const $settingNote = CE('p', {});
-
-        const resolutions = [1080, 720];
-        const currentResolution = getPref(PrefKey.REMOTE_PLAY_RESOLUTION);
-        const $resolutionGroup = CE('div', {});
-        for (const resolution of resolutions) {
-            const value = `${resolution}p`;
-            const id = `bx_radio_xhome_resolution_${resolution}`;
-
-            const $radio = CE<HTMLInputElement>('input', {
-                'type': 'radio',
-                'value': value,
-                'id': id,
-                'name': 'bx_radio_xhome_resolution',
-            }, value);
-
-            $radio.addEventListener('change', e => {
-                const value = (e.target as HTMLInputElement).value;
-
-                $settingNote.textContent = value === '1080p' ? '✅ ' + t('can-stream-xbox-360-games') : '❌ ' + t('cant-stream-xbox-360-games');
-                setPref(PrefKey.REMOTE_PLAY_RESOLUTION, value);
-            });
-
-            const $label = CE('label', {
-                'for': id,
-                'class': 'bx-remote-play-resolution',
-            }, $radio, `${resolution}p`);
-
-            $resolutionGroup.appendChild($label);
-
-            if (currentResolution === value) {
-                $radio.checked = true;
-                $radio.dispatchEvent(new Event('change'));
-            }
-        }
-
-        const $qualitySettings = CE('div', {'class': 'bx-remote-play-settings'},
-                                    CE('div', {},
-                                       CE('label', {}, t('target-resolution'), $settingNote),
-                                       $resolutionGroup,
-                                      )
-                                   );
-
-        $fragment.appendChild($qualitySettings);
-
-        // Render concoles list
-        for (let con of RemotePlay.#CONSOLES) {
-            const $child = CE('div', {'class': 'bx-remote-play-device-wrapper'},
-                CE('div', {'class': 'bx-remote-play-device-info'},
-                    CE('div', {},
-                        CE('span', {'class': 'bx-remote-play-device-name'}, con.deviceName),
-                        CE('span', {'class': 'bx-remote-play-console-type'}, con.consoleType.replace('Xbox', ''))
-                    ),
-                    CE('div', {'class': 'bx-remote-play-power-state'}, RemotePlay.#STATE_LABELS[con.powerState]),
-                ),
-
-                // Connect button
-                createButton({
-                    classes: ['bx-remote-play-connect-button'],
-                    label: t('console-connect'),
-                    style: ButtonStyle.PRIMARY | ButtonStyle.FOCUSABLE,
-                    onClick: e => {
-                            RemotePlay.play(con.serverId);
-                        },
-                }),
-            );
-
-            $fragment.appendChild($child);
-        }
-
-        // Add Help button
-        $fragment.appendChild(createButton({
-            icon: BxIcon.QUESTION,
-            style: ButtonStyle.GHOST | ButtonStyle.FOCUSABLE,
-            url: 'https://better-xcloud.github.io/remote-play',
-            label: t('help'),
-        }));
-
-        RemotePlay.#$content = CE('div', {}, $fragment);
-    }
-
-    static #getXhomeToken(callback: any) {
-        if (RemotePlay.XHOME_TOKEN) {
-            callback();
-            return;
-        }
-
-        let GSSV_TOKEN;
-        try {
-            GSSV_TOKEN = JSON.parse(localStorage.getItem('xboxcom_xbl_user_info')!).tokens['http://gssv.xboxlive.com/'].token;
-        } catch (e) {
-            for (let i = 0; i < localStorage.length; i++){
-                const key = localStorage.key(i)!;
-                if (!key.startsWith('Auth.User.')) {
-                    continue;
-                }
-
-                const json = JSON.parse(localStorage.getItem(key)!);
-                for (const token of json.tokens) {
-                    if (!token.relyingParty.includes('gssv.xboxlive.com')) {
-                        continue;
-                    }
-
-                    GSSV_TOKEN = token.tokenData.token;
-                    break;
-                }
-
-                break;
-            }
-        }
-
-        const request = new Request('https://xhome.gssv-play-prod.xboxlive.com/v2/login/user', {
-                method: 'POST',
-                body: JSON.stringify({
-                    offeringId: 'xhome',
-                    token: GSSV_TOKEN,
-                }),
-                headers: {
-                    'Content-Type': 'application/json; charset=utf-8',
-                },
-            });
-        fetch(request).then(resp => resp.json())
-            .then(json => {
-                RemotePlay.#REGIONS = json.offeringSettings.regions;
-                RemotePlay.XHOME_TOKEN = json.gsToken;
-                callback();
-            });
-    }
-
-    static async #getConsolesList(callback: any) {
-        if (RemotePlay.#CONSOLES) {
-            callback();
-            return;
-        }
-
-        const options = {
-                method: 'GET',
-                headers: {
-                    'Authorization': `Bearer ${RemotePlay.XHOME_TOKEN}`,
-                },
-            };
-
-        // Test servers one by one
-        for (const region of RemotePlay.#REGIONS) {
-            try {
-                const request = new Request(`${region.baseUri}/v6/servers/home?mr=50`, options);
-                const resp = await fetch(request);
-
-                const json = await resp.json();
-                RemotePlay.#CONSOLES = json.results;
-
-                // Store working server
-                STATES.remotePlay.server = region.baseUri;
-
-                callback();
-            } catch (e) {}
-
-            if (RemotePlay.#CONSOLES) {
-                break;
-            }
-        }
-
-        // None of the servers worked
-        if (!STATES.remotePlay.server) {
-            RemotePlay.#CONSOLES = [];
-        }
-    }
-
-    static play(serverId: string, resolution?: string) {
-        if (resolution) {
-            setPref(PrefKey.REMOTE_PLAY_RESOLUTION, resolution);
-        }
-
-        STATES.remotePlay.config = {
-            serverId: serverId,
-        };
-        window.BX_REMOTE_PLAY_CONFIG = STATES.remotePlay.config;
-
-        localRedirect('/launch/fortnite/BT5P2X999VH2#remote-play');
-        RemotePlay.detachPopup();
-    }
-
-    static preload() {
-        RemotePlay.#initialize();
-    }
-
-    static detachPopup() {
-        // Detach popup from body
-        const $popup = document.querySelector('.bx-remote-play-popup');
-        $popup && $popup.remove();
-    }
-
-    static togglePopup(force = null) {
-        if (!getPref(PrefKey.REMOTE_PLAY_ENABLED) || !RemotePlay.isReady()) {
-            Toast.show(t('getting-consoles-list'));
-            return;
-        }
-
-        RemotePlay.#initialize();
-
-        if (AppInterface && AppInterface.showRemotePlayDialog) {
-            AppInterface.showRemotePlayDialog(JSON.stringify(RemotePlay.#CONSOLES));
-            (document.activeElement as HTMLElement).blur();
-            return;
-        }
-
-        if (document.querySelector('.bx-remote-play-popup')) {
-            if (force === false) {
-                RemotePlay.#$content.classList.add('bx-gone');
-            } else {
-                RemotePlay.#$content.classList.toggle('bx-gone');
-            }
-            return;
-        }
-
-        const $header = document.querySelector('#gamepass-root header')!;
-
-        const group = $header.firstElementChild!.getAttribute('data-group')!;
-        RemotePlay.#$content.setAttribute('data-group', group);
-        RemotePlay.#$content.classList.add('bx-remote-play-popup');
-        RemotePlay.#$content.classList.remove('bx-gone');
-
-        $header.insertAdjacentElement('afterend', RemotePlay.#$content);
-    }
-
-    static detect() {
-        if (!getPref(PrefKey.REMOTE_PLAY_ENABLED)) {
-            return;
-        }
-
-        STATES.remotePlay.isPlaying = window.location.pathname.includes('/launch/') && window.location.hash.startsWith('#remote-play');
-        if (STATES.remotePlay?.isPlaying) {
-            window.BX_REMOTE_PLAY_CONFIG = STATES.remotePlay.config;
-            // Remove /launch/... from URL
-            window.history.replaceState({origin: 'better-xcloud'}, '', 'https://www.xbox.com/' + location.pathname.substring(1, 6) + '/play');
-        } else {
-            window.BX_REMOTE_PLAY_CONFIG = null;
-        }
-    }
-
-    static isReady() {
-        return RemotePlay.#CONSOLES !== null && RemotePlay.#CONSOLES.length > 0;
-    }
-}

src/modules/shortcuts/shortcut-sound.ts

@@ -1,9 +1,15 @@
 import { t } from "@utils/translation";
 import { STATES } from "@utils/global";
-import { PrefKey, getPref, setPref } from "@utils/preferences";
 import { Toast } from "@utils/toast";
-import { BxEvent } from "@/utils/bx-event";
 import { ceilToNearest, floorToNearest } from "@/utils/utils";
+import { PrefKey } from "@/enums/pref-keys";
+import { getPref, setPref } from "@/utils/settings-storages/global-settings-storage";
+import { BxEvent } from "@/utils/bx-event";
+
+export enum SpeakerState {
+    ENABLED,
+    MUTED,
+}
 
 export class SoundShortcut {
     static adjustGainNodeVolume(amount: number): number {
@@ -27,14 +33,11 @@ export class SoundShortcut {
             newValue = currentValue + amount;
         }
 
-        newValue = setPref(PrefKey.AUDIO_VOLUME, newValue);
+        newValue = setPref(PrefKey.AUDIO_VOLUME, newValue, true);
         SoundShortcut.setGainNodeVolume(newValue);
 
         // Show toast
         Toast.show(`${t('stream')} ❯ ${t('volume')}`, newValue + '%', {instant: true});
-        BxEvent.dispatch(window, BxEvent.GAINNODE_VOLUME_CHANGED, {
-                volume: newValue,
-            });
 
         return newValue;
     }
@@ -51,10 +54,7 @@ export class SoundShortcut {
             let targetValue: number;
             if (settingValue === 0) {  // settingValue is 0 => set to 100
                 targetValue = 100;
-                setPref(PrefKey.AUDIO_VOLUME, targetValue);
+                setPref(PrefKey.AUDIO_VOLUME, targetValue, true);
-                BxEvent.dispatch(window, BxEvent.GAINNODE_VOLUME_CHANGED, {
-                        volume: targetValue,
-                    });
             } else if (gainValue === 0) {  // is being muted => set to settingValue
                 targetValue = settingValue;
             } else {  // not being muted => mute
@@ -70,6 +70,10 @@ export class SoundShortcut {
 
             SoundShortcut.setGainNodeVolume(targetValue);
             Toast.show(`${t('stream')} ❯ ${t('volume')}`, status, {instant: true});
+
+            BxEvent.dispatch(window, BxEvent.SPEAKER_STATE_CHANGED, {
+                speakerState: targetValue === 0 ? SpeakerState.MUTED : SpeakerState.ENABLED,
+            })
             return;
         }
 
@@ -85,6 +89,10 @@ export class SoundShortcut {
 
             const status = $media.muted ? t('muted') : t('unmuted');
             Toast.show(`${t('stream')} ❯ ${t('volume')}`, status, {instant: true});
+
+            BxEvent.dispatch(window, BxEvent.SPEAKER_STATE_CHANGED, {
+                speakerState: $media.muted ? SpeakerState.MUTED : SpeakerState.ENABLED,
+            })
         }
     }
 }

src/modules/stream-player.ts

@@ -1,9 +1,12 @@
+import { isFullVersion } from "@macros/build" with {type: "macro"};
+
 import { CE } from "@/utils/html";
 import { WebGL2Player } from "./player/webgl2-player";
-import { getPref, PrefKey } from "@/utils/preferences";
 import { Screenshot } from "@/utils/screenshot";
 import { StreamPlayerType, StreamVideoProcessing } from "@enums/stream-player";
 import { STATES } from "@/utils/global";
+import { PrefKey } from "@/enums/pref-keys";
+import { getPref } from "@/utils/settings-storages/global-settings-storage";
 
 export type StreamPlayerOptions = Partial<{
     processing: string,
@@ -14,35 +17,35 @@ export type StreamPlayerOptions = Partial<{
 }>;
 
 export class StreamPlayer {
-    #$video: HTMLVideoElement;
+    private $video: HTMLVideoElement;
-    #playerType: StreamPlayerType = StreamPlayerType.VIDEO;
+    private playerType: StreamPlayerType = StreamPlayerType.VIDEO;
 
-    #options: StreamPlayerOptions = {};
+    private options: StreamPlayerOptions = {};
 
-    #webGL2Player: WebGL2Player | null = null;
+    private webGL2Player: WebGL2Player | null = null;
 
-    #$videoCss: HTMLStyleElement | null = null;
+    private $videoCss: HTMLStyleElement | null = null;
-    #$usmMatrix: SVGFEConvolveMatrixElement | null = null;
+    private $usmMatrix: SVGFEConvolveMatrixElement | null = null;
 
     constructor($video: HTMLVideoElement, type: StreamPlayerType, options: StreamPlayerOptions) {
-        this.#setupVideoElements();
+        this.setupVideoElements();
 
-        this.#$video = $video;
+        this.$video = $video;
-        this.#options = options || {};
+        this.options = options || {};
         this.setPlayerType(type);
     }
 
-    #setupVideoElements() {
+    private setupVideoElements() {
-        this.#$videoCss = document.getElementById('bx-video-css') as HTMLStyleElement;
+        this.$videoCss = document.getElementById('bx-video-css') as HTMLStyleElement;
-        if (this.#$videoCss) {
+        if (this.$videoCss) {
-            this.#$usmMatrix = this.#$videoCss.querySelector('#bx-filter-usm-matrix') as any;
+            this.$usmMatrix = this.$videoCss.querySelector('#bx-filter-usm-matrix') as any;
             return;
         }
 
         const $fragment = document.createDocumentFragment();
 
-        this.#$videoCss = CE<HTMLStyleElement>('style', {id: 'bx-video-css'});
+        this.$videoCss = CE<HTMLStyleElement>('style', {id: 'bx-video-css'});
-        $fragment.appendChild(this.#$videoCss);
+        $fragment.appendChild(this.$videoCss);
 
         // Setup SVG filters
         const $svg = CE('svg', {
@@ -53,7 +56,7 @@ export class StreamPlayer {
             CE('filter', {
                     id: 'bx-filter-usm',
                     xmlns: 'http://www.w3.org/2000/svg',
-                }, this.#$usmMatrix = CE('feConvolveMatrix', {
+                }, this.$usmMatrix = CE('feConvolveMatrix', {
                     id: 'bx-filter-usm-matrix',
                     order: '3',
                     xmlns: 'http://www.w3.org/2000/svg',
@@ -64,29 +67,29 @@ export class StreamPlayer {
         document.documentElement.appendChild($fragment);
     }
 
-    #getVideoPlayerFilterStyle() {
+    private getVideoPlayerFilterStyle() {
         const filters = [];
 
-        const sharpness = this.#options.sharpness || 0;
+        const sharpness = this.options.sharpness || 0;
-        if (sharpness != 0) {
+        if (this.options.processing === StreamVideoProcessing.USM && sharpness != 0) {
             const level = (7 - ((sharpness / 2) - 1) * 0.5).toFixed(1); // 5, 5.5, 6, 6.5, 7
             const matrix = `0 -1 0 -1 ${level} -1 0 -1 0`;
-            this.#$usmMatrix?.setAttributeNS(null, 'kernelMatrix', matrix);
+            this.$usmMatrix?.setAttributeNS(null, 'kernelMatrix', matrix);
 
             filters.push(`url(#bx-filter-usm)`);
         }
 
-        const saturation = this.#options.saturation || 100;
+        const saturation = this.options.saturation || 100;
         if (saturation != 100) {
             filters.push(`saturate(${saturation}%)`);
         }
 
-        const contrast =  this.#options.contrast || 100;
+        const contrast =  this.options.contrast || 100;
         if (contrast != 100) {
             filters.push(`contrast(${contrast}%)`);
         }
 
-        const brightness = this.#options.brightness || 100;
+        const brightness = this.options.brightness || 100;
         if (brightness != 100) {
             filters.push(`brightness(${brightness}%)`);
         }
@@ -94,14 +97,14 @@ export class StreamPlayer {
         return filters.join(' ');
     }
 
-    #resizePlayer() {
+    private resizePlayer() {
         const PREF_RATIO = getPref(PrefKey.VIDEO_RATIO);
-        const $video = this.#$video;
+        const $video = this.$video;
         const isNativeTouchGame = STATES.currentStream.titleInfo?.details.hasNativeTouchSupport;
 
         let $webGL2Canvas;
-        if (this.#playerType == StreamPlayerType.WEBGL2) {
+        if (this.playerType == StreamPlayerType.WEBGL2) {
-            $webGL2Canvas = this.#webGL2Player?.getCanvas()!;
+            $webGL2Canvas = this.webGL2Player?.getCanvas()!;
         }
 
         let targetWidth;
@@ -163,67 +166,67 @@ export class StreamPlayer {
         }
 
         // Update video dimensions
-        if (isNativeTouchGame && this.#playerType == StreamPlayerType.WEBGL2) {
+        if (isNativeTouchGame && this.playerType == StreamPlayerType.WEBGL2) {
             window.BX_EXPOSED.streamSession.updateDimensions();
         }
     }
 
     setPlayerType(type: StreamPlayerType, refreshPlayer: boolean = false) {
-        if (this.#playerType !== type) {
+        if (this.playerType !== type) {
             // Switch from Video -> WebGL2
             if (type === StreamPlayerType.WEBGL2) {
                 // Initialize WebGL2 player
-                if (!this.#webGL2Player) {
+                if (!this.webGL2Player) {
-                    this.#webGL2Player = new WebGL2Player(this.#$video);
+                    this.webGL2Player = new WebGL2Player(this.$video);
                 } else {
-                    this.#webGL2Player.resume();
+                    this.webGL2Player.resume();
                 }
 
-                this.#$videoCss!.textContent = '';
+                this.$videoCss!.textContent = '';
 
-                this.#$video.classList.add('bx-pixel');
+                this.$video.classList.add('bx-pixel');
             } else {
                 // Cleanup WebGL2 Player
-                this.#webGL2Player?.stop();
+                this.webGL2Player?.stop();
 
-                this.#$video.classList.remove('bx-pixel');
+                this.$video.classList.remove('bx-pixel');
             }
         }
 
-        this.#playerType = type;
+        this.playerType = type;
         refreshPlayer && this.refreshPlayer();
     }
 
     setOptions(options: StreamPlayerOptions, refreshPlayer: boolean = false) {
-        this.#options = options;
+        this.options = options;
         refreshPlayer && this.refreshPlayer();
     }
 
     updateOptions(options: StreamPlayerOptions, refreshPlayer: boolean = false) {
-        this.#options = Object.assign(this.#options, options);
+        this.options = Object.assign(this.options, options);
         refreshPlayer && this.refreshPlayer();
     }
 
     getPlayerElement(playerType?: StreamPlayerType) {
         if (typeof playerType === 'undefined') {
-            playerType = this.#playerType;
+            playerType = this.playerType;
         }
 
         if (playerType === StreamPlayerType.WEBGL2) {
-            return this.#webGL2Player?.getCanvas();
+            return this.webGL2Player?.getCanvas();
         }
 
-        return this.#$video;
+        return this.$video;
     }
 
     getWebGL2Player() {
-        return this.#webGL2Player;
+        return this.webGL2Player;
     }
 
     refreshPlayer() {
-        if (this.#playerType === StreamPlayerType.WEBGL2) {
+        if (this.playerType === StreamPlayerType.WEBGL2) {
-            const options = this.#options;
+            const options = this.options;
-            const webGL2Player = this.#webGL2Player!;
+            const webGL2Player = this.webGL2Player!;
 
             if (options.processing === StreamVideoProcessing.USM) {
                 webGL2Player.setFilter(1);
@@ -231,21 +234,21 @@ export class StreamPlayer {
                 webGL2Player.setFilter(2);
             }
 
-            Screenshot.updateCanvasFilters('none');
+            isFullVersion() && Screenshot.updateCanvasFilters('none');
 
             webGL2Player.setSharpness(options.sharpness || 0);
             webGL2Player.setSaturation(options.saturation || 100);
             webGL2Player.setContrast(options.contrast || 100);
             webGL2Player.setBrightness(options.brightness || 100);
         } else {
-            let filters = this.#getVideoPlayerFilterStyle();
+            let filters = this.getVideoPlayerFilterStyle();
             let videoCss = '';
             if (filters) {
                 videoCss += `filter: ${filters} !important;`;
             }
 
             // Apply video filters to screenshots
-            if (getPref(PrefKey.SCREENSHOT_APPLY_FILTERS)) {
+            if (isFullVersion() && getPref(PrefKey.SCREENSHOT_APPLY_FILTERS)) {
                 Screenshot.updateCanvasFilters(filters);
             }
 
@@ -254,15 +257,26 @@ export class StreamPlayer {
                 css = `#game-stream video { ${videoCss} }`;
             }
 
-            this.#$videoCss!.textContent = css;
+            this.$videoCss!.textContent = css;
         }
 
-        this.#resizePlayer();
+        this.resizePlayer();
+    }
+
+    reloadPlayer() {
+        this.cleanUpWebGL2Player();
+
+        this.playerType = StreamPlayerType.VIDEO;
+        this.setPlayerType(StreamPlayerType.WEBGL2, false);
+    }
+
+    private cleanUpWebGL2Player() {
+        // Clean up WebGL2 Player
+        this.webGL2Player?.destroy();
+        this.webGL2Player = null;
     }
 
     destroy() {
-         // Cleanup WebGL2 Player
+        this.cleanUpWebGL2Player();
-         this.#webGL2Player?.destroy();
-         this.#webGL2Player = null;
     }
 }

src/modules/stream/stream-badges.ts

@@ -1,30 +1,52 @@
+import { isLiteVersion } from "@macros/build" with {type: "macro"};
+
 import { t } from "@utils/translation";
 import { BxEvent } from "@utils/bx-event";
-import { CE, createSvgIcon } from "@utils/html";
+import { CE, createSvgIcon, humanFileSize } from "@utils/html";
 import { STATES } from "@utils/global";
 import { BxLogger } from "@/utils/bx-logger";
 import { BxIcon } from "@/utils/bx-icon";
+import { GuideMenuTab } from "../ui/guide-menu";
+import { StreamStat, StreamStatsCollector } from "@/utils/stream-stats-collector";
+
+
+type StreamBadgeInfo = {
+    name: string,
+    $element?: HTMLElement,
+    icon: typeof BxIcon,
+    color: string,
+};
+
+type StreamServerInfo = {
+    server?: {
+        ipv6: boolean,
+        region?: string,
+    },
+
+    video?: {
+        width: number,
+        height: number,
+        codec: string,
+        profile?: string,
+    },
+
+    audio?: {
+        codec: string,
+        bitrate: number,
+    },
+};
 
 enum StreamBadge {
     PLAYTIME = 'playtime',
     BATTERY = 'battery',
-    DOWNLOAD = 'in',
+    DOWNLOAD = 'download',
-    UPLOAD = 'out',
+    UPLOAD = 'upload',
 
     SERVER = 'server',
     VIDEO = 'video',
     AUDIO = 'audio',
 }
 
-const StreamBadgeIcon: Partial<{[key in StreamBadge]: any}> = {
-    [StreamBadge.PLAYTIME]: BxIcon.PLAYTIME,
-    [StreamBadge.VIDEO]: BxIcon.DISPLAY,
-    [StreamBadge.BATTERY]: BxIcon.BATTERY,
-    [StreamBadge.DOWNLOAD]: BxIcon.DOWNLOAD,
-    [StreamBadge.UPLOAD]: BxIcon.UPLOAD,
-    [StreamBadge.SERVER]: BxIcon.SERVER,
-    [StreamBadge.AUDIO]: BxIcon.AUDIO,
-}
 
 export class StreamBadges {
     private static instance: StreamBadges;
@@ -36,91 +58,100 @@ export class StreamBadges {
         return StreamBadges.instance;
     }
 
-    #ipv6 = false;
+    private serverInfo: StreamServerInfo = {};
-    #resolution?: {width: number, height: number} | null = null;
-    #video?: {codec: string, profile?: string | null} | null = null;
-    #audio?: {codec: string, bitrate: number} | null = null;
-    #region = '';
 
-    startBatteryLevel = 100;
+    private badges: Record<StreamBadge, StreamBadgeInfo> = {
-    startTimestamp = 0;
+        [StreamBadge.PLAYTIME]: {
+            name: t('playtime'),
+            icon: BxIcon.PLAYTIME,
+            color: '#ff004d',
+        },
+        [StreamBadge.BATTERY]: {
+            name: t('battery'),
+            icon: BxIcon.BATTERY,
+            color: '#00b543',
+        },
+        [StreamBadge.DOWNLOAD]: {
+            name: t('download'),
+            icon: BxIcon.DOWNLOAD,
+            color: '#29adff',
+        },
+        [StreamBadge.UPLOAD]: {
+            name: t('upload'),
+            icon: BxIcon.UPLOAD,
+            color: '#ff77a8',
+        },
+        [StreamBadge.SERVER]: {
+            name: t('server'),
+            icon: BxIcon.SERVER,
+            color: '#ff6c24',
+        },
+        [StreamBadge.VIDEO]: {
+            name: t('video'),
+            icon: BxIcon.DISPLAY,
+            color: '#742f29',
+        },
+        [StreamBadge.AUDIO]: {
+            name: t('audio'),
+            icon: BxIcon.AUDIO,
+            color: '#5f574f',
+        },
+    };
 
-    #$container: HTMLElement | undefined;
+    private $container: HTMLElement | undefined;
-    #cachedDoms: Partial<{[key in StreamBadge]: HTMLElement}> = {};
 
-    #interval?: number | null;
+    private intervalId?: number | null;
-    readonly #REFRESH_INTERVAL = 3000;
+    private readonly REFRESH_INTERVAL = 3 * 1000;
 
     setRegion(region: string) {
-        this.#region = region;
+        this.serverInfo.server = {
+            region: region,
+            ipv6: false,
+        };
     }
 
-    #renderBadge(name: StreamBadge, value: string, color: string) {
+    renderBadge(name: StreamBadge, value: string) {
+        const badgeInfo = this.badges[name];
+
         let $badge;
-        if (this.#cachedDoms[name]) {
+        if (badgeInfo.$element) {
-            $badge = this.#cachedDoms[name]!;
+            $badge = badgeInfo.$element;
             $badge.lastElementChild!.textContent = value;
             return $badge;
         }
 
-        $badge = CE('div', {'class': 'bx-badge', 'title': t(`badge-${name}`)},
+        $badge = CE('div', {class: 'bx-badge', title: badgeInfo.name},
-            CE('span', {'class': 'bx-badge-name'}, createSvgIcon(StreamBadgeIcon[name])),
+            CE('span', {class: 'bx-badge-name'}, createSvgIcon(badgeInfo.icon)),
-            CE('span', {'class': 'bx-badge-value', 'style': `background-color: ${color}`}, value),
+            CE('span', {class: 'bx-badge-value', style: `background-color: ${badgeInfo.color}`}, value),
         );
 
         if (name === StreamBadge.BATTERY) {
             $badge.classList.add('bx-badge-battery');
         }
 
-        this.#cachedDoms[name] = $badge;
+        this.badges[name].$element = $badge;
         return $badge;
     }
 
-    async #updateBadges(forceUpdate = false) {
+    private async updateBadges(forceUpdate = false) {
-        if (!this.#$container || (!forceUpdate && !this.#$container.isConnected)) {
+        if (!this.$container || (!forceUpdate && !this.$container.isConnected)) {
-            this.#stop();
+            this.stop();
             return;
         }
 
-        // Playtime
+        const statsCollector = StreamStatsCollector.getInstance();
-        let now = +new Date;
+        await statsCollector.collect();
-        const diffSeconds = Math.ceil((now - this.startTimestamp) / 1000);
-        const playtime = this.#secondsToHm(diffSeconds);
 
-        // Battery
+        const play = statsCollector.getStat(StreamStat.PLAYTIME);
-        let batteryLevel = '100%';
+        const batt = statsCollector.getStat(StreamStat.BATTERY);
-        let batteryLevelInt = 100;
+        const dl = statsCollector.getStat(StreamStat.DOWNLOAD);
-        let isCharging = false;
+        const ul = statsCollector.getStat(StreamStat.UPLOAD);
-        if ('getBattery' in navigator) {
-            try {
-                const bm = await (navigator as NavigatorBattery).getBattery();
-                isCharging = bm.charging;
-                batteryLevelInt = Math.round(bm.level * 100);
-                batteryLevel = `${batteryLevelInt}%`;
-
-                if (batteryLevelInt != this.startBatteryLevel) {
-                    const diffLevel = Math.round(batteryLevelInt - this.startBatteryLevel);
-                    const sign = diffLevel > 0 ? '+' : '';
-                    batteryLevel += ` (${sign}${diffLevel}%)`;
-                }
-            } catch(e) {}
-        }
-
-        const stats = await STATES.currentStream.peerConnection?.getStats()!;
-        let totalIn = 0;
-        let totalOut = 0;
-        stats.forEach(stat => {
-            if (stat.type === 'candidate-pair' && stat.packetsReceived > 0 && stat.state === 'succeeded') {
-                totalIn += stat.bytesReceived;
-                totalOut += stat.bytesSent;
-            }
-        });
 
         const badges = {
-            [StreamBadge.DOWNLOAD]: totalIn ? this.#humanFileSize(totalIn) : null,
+            [StreamBadge.DOWNLOAD]: dl.toString(),
-            [StreamBadge.UPLOAD]: totalOut ? this.#humanFileSize(totalOut) : null,
+            [StreamBadge.UPLOAD]: ul.toString(),
-            [StreamBadge.PLAYTIME]: playtime,
+            [StreamBadge.PLAYTIME]: play.toString(),
-            [StreamBadge.BATTERY]: batteryLevel,
+            [StreamBadge.BATTERY]: batt.toString(),
         };
 
         let name: keyof typeof badges;
@@ -130,137 +161,95 @@ export class StreamBadges {
                 continue;
             }
 
-            const $elm = this.#cachedDoms[name]!;
+            const $elm = this.badges[name].$element;
-            $elm && ($elm.lastElementChild!.textContent = value);
+            if (!$elm) {
+                continue;
+            }
+
+            $elm.lastElementChild!.textContent = value;
 
             if (name === StreamBadge.BATTERY) {
-                if (this.startBatteryLevel === 100 && batteryLevelInt === 100) {
+                if (batt.current === 100 && batt.start === 100) {
                     // Hide battery badge when the battery is 100%
                     $elm.classList.add('bx-gone');
                 } else {
                     // Show charging status
-                    $elm.dataset.charging = isCharging.toString()
+                    $elm.dataset.charging = batt.isCharging.toString();
                     $elm.classList.remove('bx-gone');
                 }
             }
         }
     }
 
-    async #start() {
+    private async start() {
-        await this.#updateBadges(true);
+        await this.updateBadges(true);
-        this.#stop();
+        this.stop();
-        this.#interval = window.setInterval(this.#updateBadges.bind(this), this.#REFRESH_INTERVAL);
+        this.intervalId = window.setInterval(this.updateBadges.bind(this), this.REFRESH_INTERVAL);
     }
 
-    #stop() {
+    private stop() {
-        this.#interval && clearInterval(this.#interval);
+        this.intervalId && clearInterval(this.intervalId);
-        this.#interval = null;
+        this.intervalId = null;
-    }
-
-    #secondsToHm(seconds: number) {
-        const h = Math.floor(seconds / 3600);
-        const m = Math.floor(seconds % 3600 / 60) + 1;
-
-        const hDisplay = h > 0 ? `${h}h`: '';
-        const mDisplay = m > 0 ? `${m}m`: '';
-        return hDisplay + mDisplay;
-    }
-
-    // https://stackoverflow.com/a/20732091
-    #humanFileSize(size: number) {
-        const units = ['B', 'KB', 'MB', 'GB', 'TB'];
-
-        let i = size == 0 ? 0 : Math.floor(Math.log(size) / Math.log(1024));
-        return (size / Math.pow(1024, i)).toFixed(2) + ' ' + units[i];
     }
 
     async render() {
-        if (this.#$container) {
+        if (this.$container) {
-            this.#start();
+            this.start();
-            return this.#$container;
+            return this.$container;
         }
 
-        await this.#getServerStats();
+        await this.getServerStats();
-
-        // Video
-        let video = '';
-        if (this.#resolution) {
-            video = `${this.#resolution.height}p`;
-        }
-
-        if (this.#video) {
-            video && (video += '/');
-            video += this.#video.codec;
-            if (this.#video.profile) {
-                const profile = this.#video.profile;
-
-                let quality = profile;
-                if (profile.startsWith('4d')) {
-                    quality = t('visual-quality-high');
-                } else if (profile.startsWith('42e')) {
-                    quality = t('visual-quality-normal');
-                } else if (profile.startsWith('420')) {
-                    quality = t('visual-quality-low');
-                }
-
-                video += ` (${quality})`;
-            }
-        }
-
-        // Audio
-        let audio;
-        if (this.#audio) {
-            audio = this.#audio.codec;
-            const bitrate = this.#audio.bitrate / 1000;
-            audio += ` (${bitrate} kHz)`;
-        }
 
         // Battery
         let batteryLevel = '';
-        if ('getBattery' in navigator) {
+        if (STATES.browser.capabilities.batteryApi) {
             batteryLevel = '100%';
         }
 
-        // Server + Region
-        let server = this.#region;
-        server += '@' + (this.#ipv6 ? 'IPv6' : 'IPv4');
-
         const BADGES = [
-            [StreamBadge.PLAYTIME, '1m', '#ff004d'],
+            [StreamBadge.PLAYTIME, '1m'],
-            [StreamBadge.BATTERY, batteryLevel, '#00b543'],
+            [StreamBadge.BATTERY, batteryLevel],
-            [StreamBadge.DOWNLOAD, this.#humanFileSize(0), '#29adff'],
+            [StreamBadge.DOWNLOAD, humanFileSize(0)],
-            [StreamBadge.UPLOAD, this.#humanFileSize(0), '#ff77a8'],
+            [StreamBadge.UPLOAD, humanFileSize(0)],
-            [StreamBadge.SERVER, server, '#ff6c24'],
+            this.serverInfo.server ? this.badges.server.$element : [StreamBadge.SERVER, '?'],
-            video ? [StreamBadge.VIDEO, video, '#742f29'] : null,
+            this.serverInfo.video ? this.badges.video.$element : [StreamBadge.VIDEO, '?'],
-            audio ? [StreamBadge.AUDIO, audio, '#5f574f'] : null,
+            this.serverInfo.audio ? this.badges.audio.$element : [StreamBadge.AUDIO, '?'],
         ];
 
-        const $container = CE('div', {'class': 'bx-badges'});
+        const $container = CE('div', {class: 'bx-badges'});
         BADGES.forEach(item => {
             if (!item) {
                 return;
             }
 
-            const $badge = this.#renderBadge(...(item as [StreamBadge, string, string]));
+            let $badge: HTMLElement;
+            if (!(item instanceof HTMLElement)) {
+                $badge = this.renderBadge(...(item as [StreamBadge, string]));
+            } else {
+                $badge = item;
+            }
+
             $container.appendChild($badge);
         });
 
-        this.#$container = $container;
+        this.$container = $container;
-        await this.#start();
+        await this.start();
 
         return $container;
     }
 
-    async #getServerStats() {
+    private async getServerStats() {
         const stats = await STATES.currentStream.peerConnection!.getStats();
 
-        const allVideoCodecs: {[index: string]: RTCBasicStat} = {};
+        const allVideoCodecs: Record<string, RTCBasicStat> = {};
         let videoCodecId;
+        let videoWidth = 0;
+        let videoHeight = 0;
 
-        const allAudioCodecs: {[index: string]: RTCBasicStat} = {};
+        const allAudioCodecs: Record<string, RTCBasicStat> = {};
         let audioCodecId;
 
-        const allCandidates: {[index: string]: string} = {};
+        const allCandidates: Record<string, string> = {};
         let candidateId;
 
         stats.forEach((stat: RTCBasicStat) => {
@@ -277,6 +266,8 @@ export class StreamBadges {
                 // Get the codecId of the video/audio track currently being used
                 if (stat.kind === 'video') {
                     videoCodecId = stat.codecId;
+                    videoWidth = stat.frameWidth;
+                    videoHeight = stat.frameHeight;
                 } else if (stat.kind === 'audio') {
                     audioCodecId = stat.codecId;
                 }
@@ -290,71 +281,91 @@ export class StreamBadges {
         // Get video codec from codecId
         if (videoCodecId) {
             const videoStat = allVideoCodecs[videoCodecId];
-            const video: any = {
+            const video: StreamServerInfo['video'] = {
+                width: videoWidth,
+                height: videoHeight,
                 codec: videoStat.mimeType.substring(6),
             };
 
             if (video.codec === 'H264') {
                 const match = /profile-level-id=([0-9a-f]{6})/.exec(videoStat.sdpFmtpLine);
-                video.profile = match ? match[1] : null;
+                match && (video.profile = match[1]);
             }
 
-            this.#video = video;
+            let text = videoHeight + 'p';
+            text && (text += '/');
+            text += video.codec;
+            if (video.profile) {
+                const profile = video.profile;
+
+                let quality = profile;
+                if (profile.startsWith('4d')) {
+                    quality = t('visual-quality-high');
+                } else if (profile.startsWith('42e')) {
+                    quality = t('visual-quality-normal');
+                } else if (profile.startsWith('420')) {
+                    quality = t('visual-quality-low');
+                }
+
+                text += ` (${quality})`;
+            }
+
+            // Render badge
+            this.badges.video.$element = this.renderBadge(StreamBadge.VIDEO, text);
+
+            this.serverInfo.video = video;
         }
 
         // Get audio codec from codecId
         if (audioCodecId) {
             const audioStat = allAudioCodecs[audioCodecId];
-            this.#audio = {
+            const audio: StreamServerInfo['audio'] = {
                 codec: audioStat.mimeType.substring(6),
                 bitrate: audioStat.clockRate,
-            }
+            };
+
+            const bitrate = audio.bitrate / 1000;
+            const text = `${audio.codec} (${bitrate} kHz)`;
+            this.badges.audio.$element = this.renderBadge(StreamBadge.AUDIO, text);
+
+            this.serverInfo.audio = audio;
         }
 
         // Get server type
         if (candidateId) {
             BxLogger.info('candidate', candidateId, allCandidates);
-            this.#ipv6 = allCandidates[candidateId].includes(':');
+
+            // Server + Region
+            const server = this.serverInfo.server;
+            if (server) {
+                server.ipv6 = allCandidates[candidateId].includes(':');
+
+                let text = '';
+                if (server.region) {
+                    text += server.region;
+                }
+
+                text += '@' + (server.ipv6 ? 'IPv6' : 'IPv4');
+                this.badges.server.$element = this.renderBadge(StreamBadge.SERVER, text);
+            }
         }
     }
 
     static setupEvents() {
-        window.addEventListener(BxEvent.STREAM_PLAYING, e => {
+        // Since the Lite version doesn't have the "..." button on System menu
-            const $video = (e as any).$video;
+        // we need to display Stream badges in the Guide menu instead
-            const streamBadges = StreamBadges.getInstance();
+        isLiteVersion() && window.addEventListener(BxEvent.XCLOUD_GUIDE_MENU_SHOWN, async e => {
+            const where = (e as any).where as GuideMenuTab;
 
-            streamBadges.#resolution = {
+            if (where !== GuideMenuTab.HOME || !STATES.isPlaying) {
-                width: $video.videoWidth,
-                height: $video.videoHeight,
-            };
-            streamBadges.startTimestamp = +new Date;
-
-            // Get battery level
-            try {
-                'getBattery' in navigator && (navigator as NavigatorBattery).getBattery().then(bm => {
-                    streamBadges.startBatteryLevel = Math.round(bm.level * 100);
-                });
-            } catch(e) {}
-        });
-
-        /*
-        Don't do this until xCloud remove the Stream Menu page
-
-        window.addEventListener(BxEvent.XCLOUD_GUIDE_SHOWN, async e => {
-            const where = (e as any).where as XcloudGuideWhere;
-
-            if (where !== XcloudGuideWhere.HOME || !STATES.isPlaying) {
                 return;
             }
 
             const $btnQuit = document.querySelector('#gamepass-dialog-root a[class*=QuitGameButton]');
-            if (!$btnQuit) {
+            if ($btnQuit) {
-                return;
+                // Add badges
+                $btnQuit.insertAdjacentElement('beforebegin', await StreamBadges.getInstance().render());
             }
-
-            // Add badges
-            $btnQuit.insertAdjacentElement('beforebegin', await StreamBadges.getInstance().render());
         });
-        */
     }
 }

src/modules/stream/stream-settings-utils.ts

@@ -0,0 +1,77 @@
+import { StreamPlayerType, StreamVideoProcessing } from "@enums/stream-player";
+import { STATES } from "@utils/global";
+import { UserAgent } from "@utils/user-agent";
+import type { StreamPlayerOptions } from "../stream-player";
+import { PrefKey } from "@/enums/pref-keys";
+import { getPref, setPref } from "@/utils/settings-storages/global-settings-storage";
+
+export function onChangeVideoPlayerType() {
+    const playerType = getPref(PrefKey.VIDEO_PLAYER_TYPE);
+    const $videoProcessing = document.getElementById(`bx_setting_${PrefKey.VIDEO_PROCESSING}`) as HTMLSelectElement;
+    const $videoSharpness = document.getElementById(`bx_setting_${PrefKey.VIDEO_SHARPNESS}`) as HTMLElement;
+    const $videoPowerPreference = document.getElementById(`bx_setting_${PrefKey.VIDEO_POWER_PREFERENCE}`) as HTMLElement;
+    const $videoMaxFps = document.getElementById(`bx_setting_${PrefKey.VIDEO_MAX_FPS}`) as HTMLElement;
+
+    if (!$videoProcessing) {
+        return;
+    }
+
+    let isDisabled = false;
+
+    const $optCas = $videoProcessing.querySelector(`option[value=${StreamVideoProcessing.CAS}]`) as HTMLOptionElement;
+
+    if (playerType === StreamPlayerType.WEBGL2) {
+        $optCas && ($optCas.disabled = false);
+    } else {
+        // Only allow USM when player type is Video
+        $videoProcessing.value = StreamVideoProcessing.USM;
+        setPref(PrefKey.VIDEO_PROCESSING, StreamVideoProcessing.USM);
+
+        $optCas && ($optCas.disabled = true);
+
+        if (UserAgent.isSafari()) {
+            isDisabled = true;
+        }
+    }
+
+    $videoProcessing.disabled = isDisabled;
+    $videoSharpness.dataset.disabled = isDisabled.toString();
+
+    // Hide Power Preference setting if renderer isn't WebGL2
+    $videoPowerPreference.closest('.bx-settings-row')!.classList.toggle('bx-gone', playerType !== StreamPlayerType.WEBGL2);
+    $videoMaxFps.closest('.bx-settings-row')!.classList.toggle('bx-gone', playerType !== StreamPlayerType.WEBGL2);
+
+    updateVideoPlayer();
+}
+
+
+export function limitVideoPlayerFps() {
+    const targetFps = getPref(PrefKey.VIDEO_MAX_FPS);
+    const streamPlayer = STATES.currentStream.streamPlayer;
+    streamPlayer?.getWebGL2Player()?.setTargetFps(targetFps);
+}
+
+
+export function updateVideoPlayer() {
+    const streamPlayer = STATES.currentStream.streamPlayer;
+    if (!streamPlayer) {
+        return;
+    }
+
+    limitVideoPlayerFps();
+
+    const options = {
+        processing: getPref(PrefKey.VIDEO_PROCESSING),
+        sharpness: getPref(PrefKey.VIDEO_SHARPNESS),
+        saturation: getPref(PrefKey.VIDEO_SATURATION),
+        contrast: getPref(PrefKey.VIDEO_CONTRAST),
+        brightness: getPref(PrefKey.VIDEO_BRIGHTNESS),
+    } satisfies StreamPlayerOptions;
+
+    streamPlayer.setPlayerType(getPref(PrefKey.VIDEO_PLAYER_TYPE));
+    streamPlayer.updateOptions(options);
+    streamPlayer.refreshPlayer();
+
+}
+
+window.addEventListener('resize', updateVideoPlayer);

src/modules/stream/stream-stats.ts

@@ -1,18 +1,11 @@
-import { PrefKey } from "@utils/preferences"
 import { BxEvent } from "@utils/bx-event"
-import { getPref } from "@utils/preferences"
 import { CE } from "@utils/html"
 import { t } from "@utils/translation"
 import { STATES } from "@utils/global"
+import { PrefKey } from "@/enums/pref-keys"
+import { getPref } from "@/utils/settings-storages/global-settings-storage"
+import { StreamStat, StreamStatsCollector, type StreamStatGrade } from "@/utils/stream-stats-collector"
 
-export enum StreamStat {
-    PING = 'ping',
-    FPS = 'fps',
-    BITRATE = 'btr',
-    DECODE_TIME = 'dt',
-    PACKETS_LOST = 'pl',
-    FRAMES_LOST = 'fl',
-};
 
 export class StreamStats {
     private static instance: StreamStats;
@@ -24,54 +17,99 @@ export class StreamStats {
         return StreamStats.instance;
     }
 
-    #timeoutId?: number | null;
+    private intervalId?: number | null;
-    readonly #updateInterval = 1000;
+    private readonly REFRESH_INTERVAL = 1 * 1000;
 
-    #$container: HTMLElement | undefined;
+    private stats = {
-    #$fps: HTMLElement | undefined;
+        [StreamStat.CLOCK]: {
-    #$ping: HTMLElement | undefined;
+            name: t('clock'),
-    #$dt: HTMLElement | undefined;
+            $element: CE('span'),
-    #$pl: HTMLElement | undefined;
+        },
-    #$fl: HTMLElement | undefined;
+        [StreamStat.PLAYTIME]: {
-    #$br: HTMLElement | undefined;
+            name: t('playtime'),
+            $element: CE('span'),
+        },
+        [StreamStat.BATTERY]: {
+            name: t('battery'),
+            $element: CE('span'),
+        },
+        [StreamStat.PING]: {
+            name: t('stat-ping'),
+            $element: CE('span'),
+        },
+        [StreamStat.JITTER]: {
+            name: t('jitter'),
+            $element: CE('span'),
+        },
+        [StreamStat.FPS]: {
+            name: t('stat-fps'),
+            $element: CE('span'),
+        },
+        [StreamStat.BITRATE]: {
+            name: t('stat-bitrate'),
+            $element: CE('span'),
+        },
+        [StreamStat.DECODE_TIME]: {
+            name: t('stat-decode-time'),
+            $element: CE('span'),
+        },
+        [StreamStat.PACKETS_LOST]: {
+            name: t('stat-packets-lost'),
+            $element: CE('span'),
+        },
+        [StreamStat.FRAMES_LOST]: {
+            name: t('stat-frames-lost'),
+            $element: CE('span'),
+        },
+        [StreamStat.DOWNLOAD]: {
+            name: t('downloaded'),
+            $element: CE('span'),
+        },
+        [StreamStat.UPLOAD]: {
+            name: t('uploaded'),
+            $element: CE('span'),
+        },
+    };
 
-    #lastVideoStat?: RTCBasicStat | null;
+    private $container!: HTMLElement;
 
-    #quickGlanceObserver?: MutationObserver | null;
+    quickGlanceObserver?: MutationObserver | null;
 
-    start(glancing=false) {
+    constructor() {
+        this.render();
+    }
+
+    async start(glancing=false) {
         if (!this.isHidden() || (glancing && this.isGlancing())) {
             return;
         }
 
-        if (this.#$container) {
+        this.intervalId && clearInterval(this.intervalId);
-            this.#$container.classList.remove('bx-gone');
+        await this.update(true);
-            this.#$container.dataset.display = glancing ? 'glancing' : 'fixed';
-        }
 
-        this.#timeoutId = window.setTimeout(this.#update.bind(this), this.#updateInterval);
+        this.$container.classList.remove('bx-gone');
+        this.$container.dataset.display = glancing ? 'glancing' : 'fixed';
+
+        this.intervalId = window.setInterval(this.update.bind(this), this.REFRESH_INTERVAL);
     }
 
-    stop(glancing=false) {
+    async stop(glancing=false) {
         if (glancing && !this.isGlancing()) {
             return;
         }
 
-        this.#timeoutId && clearTimeout(this.#timeoutId);
+        this.intervalId && clearInterval(this.intervalId);
-        this.#timeoutId = null;
+        this.intervalId = null;
-        this.#lastVideoStat = null;
 
-        if (this.#$container) {
+        this.$container.removeAttribute('data-display');
-            this.#$container.removeAttribute('data-display');
+        this.$container.classList.add('bx-gone');
-            this.#$container.classList.add('bx-gone');
-        }
     }
 
-    toggle() {
+    async toggle() {
         if (this.isGlancing()) {
-            this.#$container && (this.#$container.dataset.display = 'fixed');
+            this.$container && (this.$container.dataset.display = 'fixed');
         } else {
-            this.isHidden() ? this.start() : this.stop();
+            this.isHidden() ? await this.start() : await this.stop();
         }
     }
 
@@ -81,29 +119,36 @@ export class StreamStats {
         this.hideSettingsUi();
     }
 
-    isHidden = () => this.#$container && this.#$container.classList.contains('bx-gone');
+    isHidden = () => this.$container.classList.contains('bx-gone');
-    isGlancing = () => this.#$container && this.#$container.dataset.display === 'glancing';
+    isGlancing = () => this.$container.dataset.display === 'glancing';
 
     quickGlanceSetup() {
-        if (this.#quickGlanceObserver) {
+        if (!STATES.isPlaying || this.quickGlanceObserver) {
             return;
         }
 
         const $uiContainer = document.querySelector('div[data-testid=ui-container]')!;
-        this.#quickGlanceObserver = new MutationObserver((mutationList, observer) => {
+        if (!$uiContainer) {
-            for (let record of mutationList) {
+            return;
-                if (record.attributeName && record.attributeName === 'aria-expanded') {
+        }
-                    const expanded = (record.target as HTMLElement).ariaExpanded;
+
-                    if (expanded === 'true') {
+        this.quickGlanceObserver = new MutationObserver((mutationList, observer) => {
-                        this.isHidden() && this.start(true);
+            for (const record of mutationList) {
-                    } else {
+                const $target = record.target as HTMLElement;
-                        this.stop(true);
+                if (!$target.className || !$target.className.startsWith('GripHandle')) {
-                    }
+                    continue;
+                }
+
+                const expanded = (record.target as HTMLElement).ariaExpanded;
+                if (expanded === 'true') {
+                    this.isHidden() && this.start(true);
+                } else {
+                    this.stop(true);
                 }
             }
         });
 
-        this.#quickGlanceObserver.observe($uiContainer, {
+        this.quickGlanceObserver.observe($uiContainer, {
             attributes: true,
             attributeFilter: ['aria-expanded'],
             subtree: true,
@@ -111,98 +156,52 @@ export class StreamStats {
     }
 
     quickGlanceStop() {
-        this.#quickGlanceObserver && this.#quickGlanceObserver.disconnect();
+        this.quickGlanceObserver && this.quickGlanceObserver.disconnect();
-        this.#quickGlanceObserver = null;
+        this.quickGlanceObserver = null;
     }
 
-    async #update() {
+    private async update(forceUpdate=false) {
-        if (this.isHidden() || !STATES.currentStream.peerConnection) {
+        if ((!forceUpdate && this.isHidden()) || !STATES.currentStream.peerConnection) {
             this.onStoppedPlaying();
             return;
         }
 
-        this.#timeoutId = null;
-        const startTime = performance.now();
-
         const PREF_STATS_CONDITIONAL_FORMATTING = getPref(PrefKey.STATS_CONDITIONAL_FORMATTING);
+        let grade: StreamStatGrade = '';
 
-        const stats = await STATES.currentStream.peerConnection.getStats();
+        // Collect stats
-        let grade = '';
+        const statsCollector = StreamStatsCollector.getInstance();
+        await statsCollector.collect();
 
-        stats.forEach(stat => {
+        let statKey: keyof typeof this.stats;
-            if (stat.type === 'inbound-rtp' && stat.kind === 'video') {
+        for (statKey in this.stats) {
-                // FPS
+            grade = '';
-                this.#$fps!.textContent = stat.framesPerSecond || 0;
 
-                // Packets Lost
+            const stat = this.stats[statKey];
-                const packetsLost = stat.packetsLost;
+            const value = statsCollector.getStat(statKey);
-                const packetsReceived = stat.packetsReceived;
+            const $element = stat.$element;
-                const packetsLostPercentage = (packetsLost * 100 / ((packetsLost + packetsReceived) || 1)).toFixed(2);
+            $element.textContent = value.toString();
-                this.#$pl!.textContent = packetsLostPercentage === '0.00' ? packetsLost : `${packetsLost} (${packetsLostPercentage}%)`;
 
-                // Frames dropped
+            // Get stat's grade
-                const framesDropped = stat.framesDropped;
+            if (PREF_STATS_CONDITIONAL_FORMATTING && 'grades' in value) {
-                const framesReceived = stat.framesReceived;
+                grade = statsCollector.calculateGrade(value.current, value.grades);
-                const framesDroppedPercentage = (framesDropped * 100 / ((framesDropped + framesReceived) || 1)).toFixed(2);
-                this.#$fl!.textContent = framesDroppedPercentage === '0.00' ? framesDropped : `${framesDropped} (${framesDroppedPercentage}%)`;
-
-                if (!this.#lastVideoStat) {
-                    this.#lastVideoStat = stat;
-                    return;
-                }
-
-                const lastStat = this.#lastVideoStat;
-                // Bitrate
-                const timeDiff = stat.timestamp - lastStat.timestamp;
-                const bitrate = 8 * (stat.bytesReceived - lastStat.bytesReceived) / timeDiff / 1000;
-                this.#$br!.textContent = `${bitrate.toFixed(2)} Mbps`;
-
-                // Decode time
-                const totalDecodeTimeDiff = stat.totalDecodeTime - lastStat.totalDecodeTime;
-                const framesDecodedDiff = stat.framesDecoded - lastStat.framesDecoded;
-                const currentDecodeTime = totalDecodeTimeDiff / framesDecodedDiff * 1000;
-
-                if (isNaN(currentDecodeTime)) {
-                    this.#$dt!.textContent = '??ms';
-                } else {
-                    this.#$dt!.textContent = `${currentDecodeTime.toFixed(2)}ms`;
-                }
-
-                if (PREF_STATS_CONDITIONAL_FORMATTING) {
-                    grade = (currentDecodeTime > 12) ? 'bad' : (currentDecodeTime > 9) ? 'ok' : (currentDecodeTime > 6) ? 'good' : '';
-                    this.#$dt!.dataset.grade = grade;
-                }
-
-                this.#lastVideoStat = stat;
-            } else if (stat.type === 'candidate-pair' && stat.packetsReceived > 0 && stat.state === 'succeeded') {
-                // Round Trip Time
-                const roundTripTime = !!stat.currentRoundTripTime ? stat.currentRoundTripTime * 1000 : -1;
-                this.#$ping!.textContent = roundTripTime === -1 ? '???' : roundTripTime.toString();
-
-                if (PREF_STATS_CONDITIONAL_FORMATTING) {
-                    grade = (roundTripTime > 100) ? 'bad' : (roundTripTime > 75) ? 'ok' : (roundTripTime > 40) ? 'good' : '';
-                    this.#$ping!.dataset.grade = grade;
-                }
             }
-        });
 
-        const lapsedTime = performance.now() - startTime;
+            if ($element.dataset.grade !== grade) {
-        this.#timeoutId = window.setTimeout(this.#update.bind(this), this.#updateInterval - lapsedTime);
+                $element.dataset.grade = grade;
+            }
+        }
     }
 
     refreshStyles() {
         const PREF_ITEMS = getPref(PrefKey.STATS_ITEMS);
-        const PREF_POSITION = getPref(PrefKey.STATS_POSITION);
-        const PREF_TRANSPARENT = getPref(PrefKey.STATS_TRANSPARENT);
-        const PREF_OPACITY = getPref(PrefKey.STATS_OPACITY);
-        const PREF_TEXT_SIZE = getPref(PrefKey.STATS_TEXT_SIZE);
 
-        const $container = this.#$container!;
+        const $container = this.$container;
         $container.dataset.stats = '[' + PREF_ITEMS.join('][') + ']';
-        $container.dataset.position = PREF_POSITION;
+        $container.dataset.position = getPref(PrefKey.STATS_POSITION);
-        $container.dataset.transparent = PREF_TRANSPARENT;
+        $container.dataset.transparent = getPref(PrefKey.STATS_TRANSPARENT);
-        $container.style.opacity = PREF_OPACITY + '%';
+        $container.style.opacity = getPref(PrefKey.STATS_OPACITY) + '%';
-        $container.style.fontSize = PREF_TEXT_SIZE;
+        $container.style.fontSize = getPref(PrefKey.STATS_TEXT_SIZE);
     }
 
     hideSettingsUi() {
@@ -211,52 +210,35 @@ export class StreamStats {
         }
     }
 
-    #render() {
+    private async render() {
-        if (this.#$container) {
+        this.$container = CE('div', {class: 'bx-stats-bar bx-gone'});
-            return;
-        }
 
-        const stats = {
+        let statKey: keyof typeof this.stats;
-            [StreamStat.PING]: [t('stat-ping'), this.#$ping = CE('span', {}, '0')],
+        for (statKey in this.stats) {
-            [StreamStat.FPS]: [t('stat-fps'), this.#$fps = CE('span', {}, '0')],
+            const stat = this.stats[statKey];
-            [StreamStat.BITRATE]: [t('stat-bitrate'), this.#$br = CE('span', {}, '0 Mbps')],
-            [StreamStat.DECODE_TIME]: [t('stat-decode-time'), this.#$dt = CE('span', {}, '0ms')],
-            [StreamStat.PACKETS_LOST]: [t('stat-packets-lost'), this.#$pl = CE('span', {}, '0')],
-            [StreamStat.FRAMES_LOST]: [t('stat-frames-lost'), this.#$fl = CE('span', {}, '0')],
-        };
-
-        const $barFragment = document.createDocumentFragment();
-        let statKey: keyof typeof stats;
-        for (statKey in stats) {
             const $div = CE('div', {
-                    'class': `bx-stat-${statKey}`,
+                class: `bx-stat-${statKey}`,
-                    title: stats[statKey][0]
+                title: stat.name,
-                },
+            },
                 CE('label', {}, statKey.toUpperCase()),
-                stats[statKey][1],
+                stat.$element,
             );
 
-            $barFragment.appendChild($div);
+            this.$container.appendChild($div);
         }
 
-        this.#$container = CE('div', {'class': 'bx-stats-bar bx-gone'}, $barFragment);
         this.refreshStyles();
-
+        document.documentElement.appendChild(this.$container);
-        document.documentElement.appendChild(this.#$container!);
     }
 
     static setupEvents() {
-        window.addEventListener(BxEvent.STREAM_LOADING, e => {
-            StreamStats.getInstance().#render();
-        });
-
         window.addEventListener(BxEvent.STREAM_PLAYING, e => {
             const PREF_STATS_QUICK_GLANCE = getPref(PrefKey.STATS_QUICK_GLANCE);
             const PREF_STATS_SHOW_WHEN_PLAYING = getPref(PrefKey.STATS_SHOW_WHEN_PLAYING);
 
             const streamStats = StreamStats.getInstance();
-            // Setup Stat's Quick Glance mode
 
+            // Setup Stat's Quick Glance mode
             if (PREF_STATS_SHOW_WHEN_PLAYING) {
                 streamStats.start();
             } else if (PREF_STATS_QUICK_GLANCE) {

src/modules/stream/stream-ui.ts

@@ -5,281 +5,268 @@ import { BxEvent } from "@utils/bx-event.ts";
 import { t } from "@utils/translation.ts";
 import { StreamBadges } from "./stream-badges.ts";
 import { StreamStats } from "./stream-stats.ts";
+import { SettingsNavigationDialog } from "../ui/dialog/settings-dialog.ts";
 
 
-function cloneStreamHudButton($orgButton: HTMLElement, label: string, svgIcon: typeof BxIcon) {
+export class StreamUiHandler {
-    const $container = $orgButton.cloneNode(true) as HTMLElement;
+    private static $btnStreamSettings: HTMLElement | null | undefined;
-    let timeout: number | null;
+    private static $btnStreamStats: HTMLElement | null | undefined;
+    private static $btnRefresh: HTMLElement | null | undefined;
+    private static $btnHome: HTMLElement | null | undefined;
+    private static observer: MutationObserver | undefined;
 
-    const onTransitionStart = (e: TransitionEvent) => {
+    private static cloneStreamHudButton($btnOrg: HTMLElement, label: string, svgIcon: typeof BxIcon): HTMLElement | null {
-        if (e.propertyName !== 'opacity') {
+        if (!$btnOrg) {
+            return null;
+        }
+
+        const $container = $btnOrg.cloneNode(true) as HTMLElement;
+        let timeout: number | null;
+
+        // Prevent touching other button while the bar is showing/hiding
+        if (STATES.browser.capabilities.touch) {
+            const onTransitionStart = (e: TransitionEvent) => {
+                if (e.propertyName !== 'opacity') {
+                    return;
+                }
+
+                timeout && clearTimeout(timeout);
+                (e.target as HTMLElement).style.pointerEvents = 'none';
+            };
+
+            const onTransitionEnd = (e: TransitionEvent) => {
+                if (e.propertyName !== 'opacity') {
+                    return;
+                }
+
+                const $streamHud = (e.target as HTMLElement).closest('#StreamHud') as HTMLElement;
+                if (!$streamHud) {
+                    return;
+                }
+
+                const left = $streamHud.style.left;
+                if (left === '0px') {
+                    const $target = e.target as HTMLElement;
+                    timeout && clearTimeout(timeout);
+                    timeout = window.setTimeout(() => {
+                        $target.style.pointerEvents = 'auto';
+                    }, 100);
+                }
+            };
+
+            $container.addEventListener('transitionstart', onTransitionStart);
+            $container.addEventListener('transitionend', onTransitionEnd);
+        }
+
+        const $button = $container.querySelector('button') as HTMLElement;
+        if (!$button) {
+            return null;
+        }
+        $button.setAttribute('title', label);
+
+        const $orgSvg = $button.querySelector('svg') as SVGElement;
+        if (!$orgSvg) {
+            return null;
+        }
+
+        const $svg = createSvgIcon(svgIcon);
+        $svg.style.fill = 'none';
+        $svg.setAttribute('class', $orgSvg.getAttribute('class') || '');
+        $svg.ariaHidden = 'true';
+
+        $orgSvg.replaceWith($svg);
+        return $container;
+    }
+
+    private static cloneCloseButton($btnOrg: HTMLElement, icon: typeof BxIcon, className: string, onChange: any): HTMLElement | null {
+        if (!$btnOrg) {
+            return null;
+        }
+        // Create button from the Close button
+        const $btn = $btnOrg.cloneNode(true) as HTMLElement;
+
+        const $svg = createSvgIcon(icon);
+        // Copy classes
+        $svg.setAttribute('class', $btn.firstElementChild!.getAttribute('class') || '');
+        $svg.style.fill = 'none';
+
+        $btn.classList.add(className);
+        // Remove icon
+        $btn.removeChild($btn.firstElementChild!);
+        // Add icon
+        $btn.appendChild($svg);
+        // Add "click" event listener
+        $btn.addEventListener('click', onChange);
+
+        return $btn;
+    }
+
+    private static async handleStreamMenu() {
+        const $btnCloseHud = document.querySelector('button[class*=StreamMenu-module__backButton]') as HTMLElement;
+        if (!$btnCloseHud) {
             return;
         }
 
-        timeout && clearTimeout(timeout);
+        let $btnRefresh = StreamUiHandler.$btnRefresh;
-        $container.style.pointerEvents = 'none';
+        let $btnHome = StreamUiHandler.$btnHome;
-    };
 
-    const onTransitionEnd = (e: TransitionEvent) => {
+        // Create Refresh button from the Close button
-        if (e.propertyName !== 'opacity') {
+        if (typeof $btnRefresh === 'undefined') {
+            $btnRefresh = StreamUiHandler.cloneCloseButton($btnCloseHud, BxIcon.REFRESH, 'bx-stream-refresh-button', () => {
+                confirm(t('confirm-reload-stream')) && window.location.reload();
+            });
+        }
+
+        if (typeof $btnHome === 'undefined') {
+            $btnHome = StreamUiHandler.cloneCloseButton($btnCloseHud, BxIcon.HOME, 'bx-stream-home-button', () => {
+                confirm(t('back-to-home-confirm')) && (window.location.href = window.location.href.substring(0, 31));
+            });
+        }
+
+        // Add to website
+        if ($btnRefresh && $btnHome) {
+            $btnCloseHud.insertAdjacentElement('afterend', $btnRefresh);
+            $btnRefresh.insertAdjacentElement('afterend', $btnHome);
+        }
+
+        // Render stream badges
+        const $menu = document.querySelector('div[class*=StreamMenu-module__menuContainer] > div[class*=Menu-module]');
+        $menu?.appendChild(await StreamBadges.getInstance().render());
+    }
+
+    private static handleSystemMenu($streamHud: HTMLElement) {
+        // Get the last button
+        const $orgButton = $streamHud.querySelector('div[class^=HUDButton]') as HTMLElement;
+        if (!$orgButton) {
             return;
         }
 
-        const left = document.getElementById('StreamHud')?.style.left;
+        const hideGripHandle = () => {
-        if (left === '0px') {
+            // Grip handle
-            timeout && clearTimeout(timeout);
+            const $gripHandle = document.querySelector('#StreamHud button[class^=GripHandle]') as HTMLElement;
-            timeout = window.setTimeout(() => {
+            if ($gripHandle && $gripHandle.ariaExpanded === 'true') {
-                    $container.style.pointerEvents = 'auto';
+                $gripHandle.dispatchEvent(new PointerEvent('pointerdown'));
-                }, 100);
+                $gripHandle.click();
-        }
+                $gripHandle.dispatchEvent(new PointerEvent('pointerdown'));
-    };
+                $gripHandle.click();
-
-    if (STATES.browserHasTouchSupport) {
-        $container.addEventListener('transitionstart', onTransitionStart);
-        $container.addEventListener('transitionend', onTransitionEnd);
-    }
-
-    const $button = $container.querySelector('button')!;
-    $button.setAttribute('title', label);
-
-    const $orgSvg = $button.querySelector('svg')!;
-    const $svg = createSvgIcon(svgIcon);
-    $svg.style.fill = 'none';
-    $svg.setAttribute('class', $orgSvg.getAttribute('class') || '');
-    $svg.ariaHidden = 'true';
-
-    $orgSvg.replaceWith($svg);
-    return $container;
-}
-
-
-function cloneCloseButton($$btnOrg: HTMLElement, icon: typeof BxIcon, className: string, onChange: any) {
-    // Create button from the Close button
-    const $btn = $$btnOrg.cloneNode(true) as HTMLElement;
-
-    // Refresh SVG
-    const $svg = createSvgIcon(icon);
-    // Copy classes
-    $svg.setAttribute('class', $btn.firstElementChild!.getAttribute('class') || '');
-    $svg.style.fill = 'none';
-
-    $btn.classList.add(className);
-    // Remove icon
-    $btn.removeChild($btn.firstElementChild!);
-    // Add icon
-    $btn.appendChild($svg);
-    // Add "click" event listener
-    $btn.addEventListener('click', onChange);
-
-    return $btn;
-}
-
-
-export function injectStreamMenuButtons() {
-    const $screen = document.querySelector('#PageContent section[class*=PureScreens]');
-    if (!$screen) {
-        return;
-    }
-
-    if (($screen as any).xObserving) {
-        return;
-    }
-
-    ($screen as any).xObserving = true;
-
-    const $settingsDialog = document.querySelector('.bx-stream-settings-dialog')!;
-    const $parent = $screen.parentElement;
-    const hideSettingsFunc = (e?: MouseEvent | TouchEvent) => {
-        if (e) {
-            const $target = e.target as HTMLElement;
-            e.stopPropagation();
-            if ($target != $parent && $target.id !== 'MultiTouchSurface' && !$target.querySelector('#BabylonCanvasContainer-main')) {
-                return;
-            }
-            if ($target.id === 'MultiTouchSurface') {
-                $target.removeEventListener('touchstart', hideSettingsFunc);
             }
         }
 
-        // Hide Stream settings dialog
+        // Create Stream Settings button
-        $settingsDialog.classList.add('bx-gone');
+        let $btnStreamSettings = StreamUiHandler.$btnStreamSettings;
+        if (typeof $btnStreamSettings === 'undefined') {
+            $btnStreamSettings = StreamUiHandler.cloneStreamHudButton($orgButton, t('better-xcloud'), BxIcon.BETTER_XCLOUD);
+            $btnStreamSettings?.addEventListener('click', e => {
+                hideGripHandle();
+                e.preventDefault();
 
-        $parent?.removeEventListener('click', hideSettingsFunc);
+                // Show Stream Settings dialog
-        // $parent.removeEventListener('touchstart', hideSettingsFunc);
+                SettingsNavigationDialog.getInstance().show();
-    }
+            });
 
-    let $btnStreamSettings: HTMLElement;
+            StreamUiHandler.$btnStreamSettings = $btnStreamSettings;
-    let $btnStreamStats: HTMLElement;
+        }
-    const streamStats = StreamStats.getInstance();
 
-    const observer = new MutationObserver(mutationList => {
+        // Create Stream Stats button
-        mutationList.forEach(item => {
+        const streamStats = StreamStats.getInstance();
-            if (item.type !== 'childList') {
+        let $btnStreamStats = StreamUiHandler.$btnStreamStats;
-                return;
+        if (typeof $btnStreamStats === 'undefined') {
-            }
+            $btnStreamStats = StreamUiHandler.cloneStreamHudButton($orgButton, t('stream-stats'), BxIcon.STREAM_STATS);
+            $btnStreamStats?.addEventListener('click', async (e) => {
+                hideGripHandle();
+                e.preventDefault();
 
-            item.addedNodes.forEach(async $node => {
+                // Toggle Stream Stats
-                if (!$node || $node.nodeType !== Node.ELEMENT_NODE) {
+                await streamStats.toggle();
-                    return;
-                }
-
-                let $elm: HTMLElement | null = $node as HTMLElement;
-
-                // Ignore SVG elements
-                if ($elm instanceof SVGSVGElement) {
-                    return;
-                }
-
-                // Error Page: .PureErrorPage.ErrorScreen
-                if ($elm.className?.includes('PureErrorPage')) {
-                    BxEvent.dispatch(window, BxEvent.STREAM_ERROR_PAGE);
-                    return;
-                }
-
-                // Render badges
-                if ($elm.className?.startsWith('StreamMenu-module__container')) {
-                    const $btnCloseHud = document.querySelector('button[class*=StreamMenu-module__backButton]') as HTMLElement;
-                    if (!$btnCloseHud) {
-                        return;
-                    }
-
-                    // Hide Stream Settings dialog when closing HUD
-                    $btnCloseHud.addEventListener('click', e => {
-                        $settingsDialog.classList.add('bx-gone');
-                    });
-
-                    // Create Refresh button from the Close button
-                    const $btnRefresh = cloneCloseButton($btnCloseHud, BxIcon.REFRESH, 'bx-stream-refresh-button', () => {
-                        confirm(t('confirm-reload-stream')) && window.location.reload();
-                    });
-
-                    const $btnHome = cloneCloseButton($btnCloseHud, BxIcon.HOME, 'bx-stream-home-button', () => {
-                        confirm(t('back-to-home-confirm')) && (window.location.href = window.location.href.substring(0, 31));
-                    });
-
-                    // Add to website
-                    $btnCloseHud.insertAdjacentElement('afterend', $btnRefresh);
-                    $btnRefresh.insertAdjacentElement('afterend', $btnHome);
-
-                    // Render stream badges
-                    const $menu = document.querySelector('div[class*=StreamMenu-module__menuContainer] > div[class*=Menu-module]');
-                    $menu?.appendChild(await StreamBadges.getInstance().render());
-
-                    hideSettingsFunc();
-                    return;
-                }
-
-                if ($elm.className?.startsWith('Overlay-module_') || $elm.className?.startsWith('InProgressScreen')) {
-                    $elm = $elm.querySelector('#StreamHud');
-                }
-
-                if (!$elm || ($elm.id || '') !== 'StreamHud') {
-                    return;
-                }
-
-                // Grip handle
-                const $gripHandle = $elm.querySelector('button[class^=GripHandle]') as HTMLElement;
-
-                const hideGripHandle = () => {
-                    if (!$gripHandle) {
-                        return;
-                    }
-
-                    $gripHandle.dispatchEvent(new PointerEvent('pointerdown'));
-                    $gripHandle.click();
-                    $gripHandle.dispatchEvent(new PointerEvent('pointerdown'));
-                    $gripHandle.click();
-                }
-
-                // Get the second last button
-                const $orgButton = $elm.querySelector('div[class^=HUDButton]') as HTMLElement;
-                if (!$orgButton) {
-                    return;
-                }
-
-                // Create Stream Settings button
-                if (!$btnStreamSettings) {
-                    $btnStreamSettings = cloneStreamHudButton($orgButton, t('stream-settings'), BxIcon.STREAM_SETTINGS);
-                    $btnStreamSettings.addEventListener('click', e => {
-                        hideGripHandle();
-                        e.preventDefault();
-
-                        // Show Stream Settings dialog
-                        $settingsDialog.classList.remove('bx-gone');
-
-                        $parent?.addEventListener('click', hideSettingsFunc);
-                        //$parent.addEventListener('touchstart', hideSettingsFunc);
-
-                        const $touchSurface = document.getElementById('MultiTouchSurface');
-                        $touchSurface && $touchSurface.style.display != 'none' && $touchSurface.addEventListener('touchstart', hideSettingsFunc);
-                    });
-                }
-
-                // Create Stream Stats button
-                if (!$btnStreamStats) {
-                    $btnStreamStats = cloneStreamHudButton($orgButton, t('stream-stats'), BxIcon.STREAM_STATS);
-                    $btnStreamStats.addEventListener('click', e => {
-                        hideGripHandle();
-                        e.preventDefault();
-
-                        // Toggle Stream Stats
-                        streamStats.toggle();
-
-                        const btnStreamStatsOn = (!streamStats.isHidden() && !streamStats.isGlancing());
-                        $btnStreamStats.classList.toggle('bx-stream-menu-button-on', btnStreamStatsOn);
-                    });
-                }
 
                 const btnStreamStatsOn = (!streamStats.isHidden() && !streamStats.isGlancing());
-                $btnStreamStats.classList.toggle('bx-stream-menu-button-on', btnStreamStatsOn);
+                $btnStreamStats!.classList.toggle('bx-stream-menu-button-on', btnStreamStatsOn);
-
-                if ($orgButton) {
-                    const $btnParent = $orgButton.parentElement!;
-
-                    // Insert buttons after Stream Settings button
-                    $btnParent.insertBefore($btnStreamStats, $btnParent.lastElementChild);
-                    $btnParent.insertBefore($btnStreamSettings, $btnStreamStats);
-
-                    // Move the Dots button to the beginning
-                    const $dotsButton = $btnParent.lastElementChild!;
-                    $dotsButton.parentElement!.insertBefore($dotsButton, $dotsButton.parentElement!.firstElementChild);
-                }
             });
-        });
-    });
-    observer.observe($screen, {subtree: true, childList: true});
-}
 
+            StreamUiHandler.$btnStreamStats = $btnStreamStats;
+        }
 
-export function showStreamSettings(tabId: string) {
+        const $btnParent = $orgButton.parentElement!;
-    const $wrapper = document.querySelector('.bx-stream-settings-dialog');
+
-    if (!$wrapper) {
+        if ($btnStreamSettings && $btnStreamStats) {
-        return;
+            const btnStreamStatsOn = (!streamStats.isHidden() && !streamStats.isGlancing());
+            $btnStreamStats.classList.toggle('bx-stream-menu-button-on', btnStreamStatsOn);
+
+            // Insert buttons after Stream Settings button
+            $btnParent.insertBefore($btnStreamStats, $btnParent.lastElementChild);
+            $btnParent.insertBefore($btnStreamSettings, $btnStreamStats);
+        }
+
+        // Move the Dots button to the beginning
+        const $dotsButton = $btnParent.lastElementChild!;
+        $dotsButton.parentElement!.insertBefore($dotsButton, $dotsButton.parentElement!.firstElementChild);
     }
 
-    // Select tab
+    static reset() {
-    if (tabId) {
+        StreamUiHandler.$btnStreamSettings = undefined;
-        const $tab = $wrapper.querySelector(`.bx-stream-settings-tabs svg[data-group=${tabId}]`);
+        StreamUiHandler.$btnStreamStats = undefined;
-        $tab && $tab.dispatchEvent(new Event('click'));
+        StreamUiHandler.$btnRefresh = undefined;
+        StreamUiHandler.$btnHome = undefined;
+
+        StreamUiHandler.observer && StreamUiHandler.observer.disconnect();
+        StreamUiHandler.observer = undefined;
     }
 
-    $wrapper.classList.remove('bx-gone');
+    static observe() {
+        StreamUiHandler.reset();
 
-    const $screen = document.querySelector('#PageContent section[class*=PureScreens]');
+        const $screen = document.querySelector('#PageContent section[class*=PureScreens]');
-    if ($screen && $screen.parentElement) {
+        if (!$screen) {
-        const $parent = $screen.parentElement;
-        if (!$parent || ($parent as any).bxClick) {
             return;
         }
 
-        ($parent as any).bxClick = true;
+        const observer = new MutationObserver(mutationList => {
+            mutationList.forEach(item => {
+                if (item.type !== 'childList') {
+                    return;
+                }
 
-        const onClick = (e: Event) => {
+                item.addedNodes.forEach(async $node => {
-            $wrapper.classList.add('bx-gone');
+                    if (!$node || $node.nodeType !== Node.ELEMENT_NODE) {
-            ($parent as any).bxClick = false;
+                        return;
-            $parent.removeEventListener('click', onClick);
+                    }
-        };
 
-        $parent.addEventListener('click', onClick);
+                    let $elm: HTMLElement | null = $node as HTMLElement;
+
+                    // Ignore non-HTML elements
+                    if (!($elm instanceof HTMLElement)) {
+                        return;
+                    }
+
+                    const className = $elm.className || '';
+
+                    // Error Page: .PureErrorPage.ErrorScreen
+                    if (className.includes('PureErrorPage')) {
+                        BxEvent.dispatch(window, BxEvent.STREAM_ERROR_PAGE);
+                        return;
+                    }
+
+                    // Render badges
+                    if (className.startsWith('StreamMenu-module__container')) {
+                        StreamUiHandler.handleStreamMenu();
+                        return;
+                    }
+
+                    if (className.startsWith('Overlay-module_') || className.startsWith('InProgressScreen')) {
+                        $elm = $elm.querySelector('#StreamHud');
+                    }
+
+                    if (!$elm || ($elm.id || '') !== 'StreamHud') {
+                        return;
+                    }
+
+                    // Handle System Menu bar
+                    StreamUiHandler.handleSystemMenu($elm);
+                });
+            });
+        });
+
+        observer.observe($screen, {subtree: true, childList: true});
+        StreamUiHandler.observer = observer;
     }
 }

src/modules/touch-controller.ts

@@ -1,14 +1,27 @@
-import { STATES } from "@utils/global";
 import { escapeHtml } from "@utils/html";
 import { Toast } from "@utils/toast";
 import { BxEvent } from "@utils/bx-event";
-import { BX_FLAGS, NATIVE_FETCH } from "@utils/bx-flags";
+import { NATIVE_FETCH } from "@utils/bx-flags";
-import { getPref, PrefKey } from "@utils/preferences";
 import { t } from "@utils/translation";
 import { BxLogger } from "@utils/bx-logger";
+import { PrefKey } from "@/enums/pref-keys";
+import { getPref } from "@/utils/settings-storages/global-settings-storage";
 
 const LOG_TAG = 'TouchController';
 
+type TouchControlLayout = {
+    name: string,
+    author: string,
+    content: any,
+};
+
+type TouchControlDefinition = {
+    name: string,
+    product_id: string,
+    default_layout: string,
+    layouts: Record<string, TouchControlLayout>,
+};
+
 export class TouchController {
     static readonly #EVENT_SHOW_DEFAULT_CONTROLLER = new MessageEvent('message', {
             data: JSON.stringify({
@@ -28,25 +41,40 @@ export class TouchController {
 
     static #$style: HTMLStyleElement;
 
-    static #enable = false;
+    static #enabled = false;
     static #dataChannel: RTCDataChannel | null;
 
-    static #customLayouts: {[index: string]: any} = {};
+    static #customLayouts: Record<string, TouchControlDefinition | null> = {};
-    static #baseCustomLayouts: {[index: string]: any} = {};
+    static #baseCustomLayouts: Record<string, Record<string, TouchControlLayout>> = {};
     static #currentLayoutId: string;
 
     static #customList: string[];
 
+    static #xboxTitleId: string | null = null;
+
+    static setXboxTitleId(xboxTitleId: string) {
+        TouchController.#xboxTitleId = xboxTitleId;
+    }
+
+    static getCustomLayouts() {
+        const xboxTitleId = TouchController.#xboxTitleId;
+        if (!xboxTitleId) {
+            return null;
+        }
+
+        return TouchController.#customLayouts[xboxTitleId];
+    }
+
     static enable() {
-        TouchController.#enable = true;
+        TouchController.#enabled = true;
     }
 
     static disable() {
-        TouchController.#enable = false;
+        TouchController.#enabled = false;
     }
 
     static isEnabled() {
-        return TouchController.#enable;
+        return TouchController.#enabled;
     }
 
     static #showDefault() {
@@ -70,8 +98,9 @@ export class TouchController {
     }
 
     static reset() {
-        TouchController.#enable = false;
+        TouchController.#enabled = false;
         TouchController.#dataChannel = null;
+        TouchController.#xboxTitleId = null;
 
         TouchController.#$style && (TouchController.#$style.textContent = '');
     }
@@ -83,12 +112,18 @@ export class TouchController {
     }
 
     static #dispatchLayouts(data: any) {
-        BxEvent.dispatch(window, BxEvent.CUSTOM_TOUCH_LAYOUTS_LOADED, {
+        // Load default layout
-            data: data,
+        TouchController.applyCustomLayout(null, 1000);
-        });
+
+        BxEvent.dispatch(window, BxEvent.CUSTOM_TOUCH_LAYOUTS_LOADED);
     };
 
-    static async getCustomLayouts(xboxTitleId: string, retries: number=1) {
+    static async requestCustomLayouts(retries: number=1) {
+        const xboxTitleId = TouchController.#xboxTitleId;
+        if (!xboxTitleId) {
+            return;
+        }
+
         if (xboxTitleId in TouchController.#customLayouts) {
             TouchController.#dispatchLayouts(TouchController.#customLayouts[xboxTitleId]);
             return;
@@ -102,7 +137,7 @@ export class TouchController {
             return;
         }
 
-        const baseUrl = `https://raw.githubusercontent.com/redphx/better-xcloud/gh-pages/touch-layouts${BX_FLAGS.UseDevTouchLayout ? '/dev' : ''}`;
+        const baseUrl = 'https://raw.githubusercontent.com/redphx/better-xcloud/gh-pages/touch-layouts';
         const url = `${baseUrl}/${xboxTitleId}.json`;
 
         // Get layout info
@@ -137,17 +172,17 @@ export class TouchController {
             window.setTimeout(() => TouchController.#dispatchLayouts(json), 1000);
         } catch (e) {
             // Retry
-            TouchController.getCustomLayouts(xboxTitleId, retries + 1);
+            TouchController.requestCustomLayouts(retries + 1);
         }
     }
 
-    static loadCustomLayout(xboxTitleId: string, layoutId: string, delay: number=0) {
+    static applyCustomLayout(layoutId: string | null, delay: number=0) {
         // TODO: fix this
         if (!window.BX_EXPOSED.touchLayoutManager) {
             const listener = (e: Event) => {
                 window.removeEventListener(BxEvent.TOUCH_LAYOUT_MANAGER_READY, listener);
-                if (TouchController.#enable) {
+                if (TouchController.#enabled) {
-                    TouchController.loadCustomLayout(xboxTitleId, layoutId, 0);
+                    TouchController.applyCustomLayout(layoutId, 0);
                 }
             };
             window.addEventListener(BxEvent.TOUCH_LAYOUT_MANAGER_READY, listener);
@@ -155,13 +190,30 @@ export class TouchController {
             return;
         }
 
+        const xboxTitleId = TouchController.#xboxTitleId;
+        if (!xboxTitleId) {
+            BxLogger.error(LOG_TAG, 'Invalid xboxTitleId');
+            return;
+        }
+
+        if (!layoutId) {
+            // Get default layout ID from definition
+            layoutId = TouchController.#customLayouts[xboxTitleId]?.default_layout || null;
+        }
+
+        if (!layoutId) {
+            BxLogger.error(LOG_TAG, 'Invalid layoutId, show default controller');
+            TouchController.#enabled && TouchController.#showDefault();
+            return;
+        }
+
         const layoutChanged = TouchController.#currentLayoutId !== layoutId;
         TouchController.#currentLayoutId = layoutId;
 
         // Get layout data
         const layoutData = TouchController.#customLayouts[xboxTitleId];
         if (!xboxTitleId || !layoutId || !layoutData) {
-            TouchController.#enable && TouchController.#showDefault();
+            TouchController.#enabled && TouchController.#showDefault();
             return;
         }
 
@@ -223,7 +275,7 @@ export class TouchController {
 
             touchLayoutManager && touchLayoutManager.changeLayoutForScope({
                 type: 'showLayout',
-                scope: '' + STATES.currentStream?.xboxTitleId,
+                scope: '' + TouchController.#xboxTitleId,
                 subscope: 'base',
                 layout: {
                     id: 'System.Standard',
@@ -249,7 +301,7 @@ export class TouchController {
 
             // Apply touch controller's style
             let filter = '';
-            if (TouchController.#enable) {
+            if (TouchController.#enabled) {
                 if (PREF_STYLE_STANDARD === 'white') {
                     filter = 'grayscale(1) brightness(2)';
                 } else if (PREF_STYLE_STANDARD === 'muted') {
@@ -280,9 +332,9 @@ export class TouchController {
 
                 // Dispatch a message to display generic touch controller
                 if (msg.data.includes('touchcontrols/showtitledefault')) {
-                    if (TouchController.#enable) {
+                    if (TouchController.#enabled) {
                         if (focused) {
-                            TouchController.getCustomLayouts(STATES.currentStream?.xboxTitleId!);
+                            TouchController.requestCustomLayouts();
                         } else {
                             TouchController.#showDefault();
                         }
@@ -300,7 +352,7 @@ export class TouchController {
                             TouchController.#show();
                         }
 
-                        STATES.currentStream.xboxTitleId = parseInt(json.titleid, 16).toString();
+                        TouchController.setXboxTitleId(parseInt(json.titleid, 16).toString());
                     }
                 } catch (e) {
                     BxLogger.error(LOG_TAG, 'Load custom layout', e);

src/modules/ui/dialog/navigation-dialog.ts

@@ -0,0 +1,658 @@
+import { GamepadKey } from "@/enums/mkb";
+import { PrefKey } from "@/enums/pref-keys";
+import { VIRTUAL_GAMEPAD_ID } from "@/modules/mkb/mkb-handler";
+import { BxEvent } from "@/utils/bx-event";
+import { STATES } from "@/utils/global";
+import { CE, isElementVisible } from "@/utils/html";
+import { setNearby } from "@/utils/navigation-utils";
+import { getPref } from "@/utils/settings-storages/global-settings-storage";
+
+export enum NavigationDirection {
+    UP = 1,
+    RIGHT,
+    DOWN,
+    LEFT,
+}
+
+export type NavigationNearbyElements = Partial<{
+    orientation: 'horizontal' | 'vertical',
+    selfOrientation: 'horizontal' | 'vertical',
+
+    focus: NavigationElement | (() => boolean),
+    loop: ((direction: NavigationDirection) => boolean),
+    [NavigationDirection.UP]: NavigationElement | (() => void) | 'previous' | 'next',
+    [NavigationDirection.DOWN]: NavigationElement | (() => void) | 'previous' | 'next',
+    [NavigationDirection.LEFT]: NavigationElement | (() => void) | 'previous' | 'next',
+    [NavigationDirection.RIGHT]: NavigationElement | (() => void) | 'previous' | 'next',
+}>;
+
+export interface NavigationElement extends HTMLElement {
+    nearby?: NavigationNearbyElements;
+}
+
+
+export abstract class NavigationDialog {
+    abstract getDialog(): NavigationDialog;
+    abstract getContent(): HTMLElement;
+
+    abstract focusIfNeeded(): void;
+
+    abstract $container: HTMLElement;
+    dialogManager: NavigationDialogManager;
+
+    constructor() {
+        this.dialogManager = NavigationDialogManager.getInstance();
+    }
+
+    show() {
+        NavigationDialogManager.getInstance().show(this);
+
+        const $currentFocus = this.getFocusedElement();
+        // If not focusing on any element
+        if (!$currentFocus) {
+            this.focusIfNeeded();
+        }
+    }
+
+    hide() {
+        NavigationDialogManager.getInstance().hide();
+    }
+
+    getFocusedElement() {
+        const $activeElement = document.activeElement as HTMLElement;
+        if (!$activeElement) {
+            return null;
+        }
+
+        // Check if focused element is a child of dialog
+        if (this.$container.contains($activeElement)) {
+            return $activeElement;
+        }
+
+        return null;
+    }
+
+    onBeforeMount(): void {}
+    onMounted(): void {}
+    onBeforeUnmount(): void {}
+    onUnmounted(): void {}
+
+    handleKeyPress(key: string): boolean {
+        return false;
+    }
+
+    handleGamepad(button: GamepadKey): boolean {
+        return false;
+    }
+}
+
+export class NavigationDialogManager {
+    private static instance: NavigationDialogManager;
+    public static getInstance(): NavigationDialogManager {
+        if (!NavigationDialogManager.instance) {
+            NavigationDialogManager.instance = new NavigationDialogManager();
+        }
+        return NavigationDialogManager.instance;
+    }
+
+    private static readonly GAMEPAD_POLLING_INTERVAL = 50;
+    private static readonly GAMEPAD_KEYS = [
+        GamepadKey.UP,
+        GamepadKey.DOWN,
+        GamepadKey.LEFT,
+        GamepadKey.RIGHT,
+        GamepadKey.A,
+        GamepadKey.B,
+        GamepadKey.LB,
+        GamepadKey.RB,
+        GamepadKey.LT,
+        GamepadKey.RT,
+    ];
+
+    private static readonly GAMEPAD_DIRECTION_MAP = {
+        [GamepadKey.UP]: NavigationDirection.UP,
+        [GamepadKey.DOWN]: NavigationDirection.DOWN,
+        [GamepadKey.LEFT]: NavigationDirection.LEFT,
+        [GamepadKey.RIGHT]: NavigationDirection.RIGHT,
+
+        [GamepadKey.LS_UP]: NavigationDirection.UP,
+        [GamepadKey.LS_DOWN]: NavigationDirection.DOWN,
+        [GamepadKey.LS_LEFT]: NavigationDirection.LEFT,
+        [GamepadKey.LS_RIGHT]: NavigationDirection.RIGHT,
+    };
+
+    private static readonly SIBLING_PROPERTY_MAP = {
+        'horizontal': {
+            [NavigationDirection.LEFT]: 'previousElementSibling',
+            [NavigationDirection.RIGHT]: 'nextElementSibling',
+        },
+
+        'vertical': {
+            [NavigationDirection.UP]: 'previousElementSibling',
+            [NavigationDirection.DOWN]: 'nextElementSibling',
+        },
+    };
+
+    private gamepadPollingIntervalId: number | null = null;
+    private gamepadLastStates: Array<[number, GamepadKey, boolean] | null> = [];
+    private gamepadHoldingIntervalId: number | null = null;
+
+    private $overlay: HTMLElement;
+    private $container: HTMLElement;
+    private dialog: NavigationDialog | null = null;
+
+    constructor() {
+        this.$overlay = CE('div', {class: 'bx-navigation-dialog-overlay bx-gone'});
+        this.$overlay.addEventListener('click', e => {
+            e.preventDefault();
+            e.stopPropagation();
+            this.hide();
+        });
+
+        document.documentElement.appendChild(this.$overlay);
+
+        this.$container = CE('div', {class: 'bx-navigation-dialog bx-gone'});
+        document.documentElement.appendChild(this.$container);
+
+        // Hide dialog when the Guide menu is shown
+        window.addEventListener(BxEvent.XCLOUD_GUIDE_MENU_SHOWN, e => this.hide());
+
+        // Calculate minimum width of controller-friendly <select> elements
+        if (getPref(PrefKey.UI_CONTROLLER_FRIENDLY)) {
+            const observer = new MutationObserver(mutationList => {
+                if (mutationList.length === 0 || mutationList[0].addedNodes.length === 0) {
+                    return;
+                }
+
+                // Get dialog
+                const $dialog = mutationList[0].addedNodes[0];
+                if (!$dialog || !($dialog instanceof HTMLElement)) {
+                    return;
+                }
+
+                // Find un-calculated <select> elements
+                this.calculateSelectBoxes($dialog);
+            });
+            observer.observe(this.$container, {childList: true});
+        }
+    }
+
+    calculateSelectBoxes($root: HTMLElement) {
+        const $selects = $root.querySelectorAll('.bx-select:not([data-calculated]) select');
+        $selects.forEach($select => {
+            const $parent = $select.parentElement! as HTMLElement;
+
+            // Don't apply to select.bx-full-width elements
+            if ($parent.classList.contains('bx-full-width')) {
+                $parent.dataset.calculated = 'true';
+                return;
+            }
+
+            const rect = $select.getBoundingClientRect();
+
+            let $label;
+            let width = Math.ceil(rect.width);
+            if (!width) {
+                return;
+            }
+
+            if (($select as HTMLSelectElement).multiple) {
+                $label = $parent.querySelector('.bx-select-value') as HTMLElement;
+                width += 20;  // Add checkbox's width
+            } else {
+                $label = $parent.querySelector('div') as HTMLElement;
+            }
+
+            // Set min-width
+            $label.style.minWidth = width + 'px';
+            $parent.dataset.calculated = 'true';
+        });
+    }
+
+    handleEvent(event: Event) {
+        switch (event.type) {
+            case 'keydown':
+                const $target = event.target as HTMLElement;
+                const keyboardEvent = event as KeyboardEvent;
+                const keyCode = keyboardEvent.code || keyboardEvent.key;
+
+                let handled = this.dialog?.handleKeyPress(keyCode);
+                if (handled) {
+                    event.preventDefault();
+                    event.stopPropagation();
+                    return;
+                }
+
+                if (keyCode === 'ArrowUp' || keyCode === 'ArrowDown') {
+                    handled = true;
+                    this.focusDirection(keyCode === 'ArrowUp' ? NavigationDirection.UP : NavigationDirection.DOWN);
+                } else if (keyCode === 'ArrowLeft' || keyCode === 'ArrowRight') {
+                    if (!($target instanceof HTMLInputElement && ($target.type === 'text' || $target.type === 'range'))) {
+                        handled = true;
+                        this.focusDirection(keyCode === 'ArrowLeft' ? NavigationDirection.LEFT : NavigationDirection.RIGHT);
+                    }
+                } else if (keyCode === 'Enter' || keyCode === 'NumpadEnter' || keyCode === 'Space') {
+                    if (!($target instanceof HTMLInputElement && $target.type === 'text')) {
+                        handled = true;
+                        $target.dispatchEvent(new MouseEvent('click'));
+                    }
+                } else if (keyCode === 'Escape') {
+                    handled = true;
+                    this.hide();
+                }
+
+                if (handled) {
+                    event.preventDefault();
+                    event.stopPropagation();
+                }
+
+                break;
+        }
+    }
+
+    isShowing() {
+        return this.$container && !this.$container.classList.contains('bx-gone');
+    }
+
+    private pollGamepad() {
+        const gamepads = window.navigator.getGamepads();
+
+        for (const gamepad of gamepads) {
+            if (!gamepad || !gamepad.connected) {
+                continue;
+            }
+
+            // Ignore virtual controller
+            if (gamepad.id === VIRTUAL_GAMEPAD_ID) {
+                continue;
+            }
+
+            const axes = gamepad.axes;
+            const buttons = gamepad.buttons;
+
+            let releasedButton: GamepadKey | null = null;
+            let heldButton: GamepadKey | null = null;
+
+            let lastState = this.gamepadLastStates[gamepad.index];
+            let lastTimestamp;
+            let lastKey;
+            let lastKeyPressed;
+            if (lastState) {
+                [lastTimestamp, lastKey, lastKeyPressed] = lastState;
+            }
+
+            if (lastTimestamp && lastTimestamp === gamepad.timestamp) {
+                continue;
+            }
+
+            for (const key of NavigationDialogManager.GAMEPAD_KEYS) {
+                // Key released
+                if (lastKey === key && !buttons[key].pressed) {
+                    releasedButton = key;
+                    break;
+                } else if (buttons[key].pressed) {
+                    // Key pressed
+                    heldButton = key;
+                    break;
+                }
+            }
+
+            // If not pressing any key => check analog sticks
+            if (heldButton === null && releasedButton === null && axes && axes.length >= 2) {
+                // [LEFT left-right, LEFT up-down]
+                if (lastKey) {
+                    const releasedHorizontal = Math.abs(axes[0]) < 0.1 && (lastKey === GamepadKey.LS_LEFT || lastKey === GamepadKey.LS_RIGHT);
+                    const releasedVertical = Math.abs(axes[1]) < 0.1 && (lastKey === GamepadKey.LS_UP || lastKey === GamepadKey.LS_DOWN);
+
+                    if (releasedHorizontal || releasedVertical) {
+                        releasedButton = lastKey;
+                    } else {
+                        heldButton = lastKey;
+                    }
+                } else {
+                    if (axes[0] < -0.5) {
+                        heldButton = GamepadKey.LS_LEFT;
+                    } else if (axes[0] > 0.5) {
+                        heldButton = GamepadKey.LS_RIGHT;
+                    } else if (axes[1] < -0.5) {
+                        heldButton = GamepadKey.LS_UP;
+                    } else if (axes[1] > 0.5) {
+                        heldButton = GamepadKey.LS_DOWN;
+                    }
+                }
+            }
+
+            // Save state if holding a button
+            if (heldButton !== null) {
+                this.gamepadLastStates[gamepad.index] = [gamepad.timestamp, heldButton, false];
+
+                this.clearGamepadHoldingInterval();
+
+                // Only set turbo for d-pad and stick
+                if (NavigationDialogManager.GAMEPAD_DIRECTION_MAP[heldButton as keyof typeof NavigationDialogManager.GAMEPAD_DIRECTION_MAP]) {
+                    this.gamepadHoldingIntervalId = window.setInterval(() => {
+                        const lastState = this.gamepadLastStates[gamepad.index];
+                        // Avoid pressing the incorrect key
+                        if (lastState) {
+                            [lastTimestamp, lastKey, lastKeyPressed] = lastState;
+                            if (lastKey === heldButton) {
+                                this.handleGamepad(gamepad, heldButton);
+                                return;
+                            }
+                        }
+
+                        this.clearGamepadHoldingInterval();
+                    }, 200);
+                }
+                continue;
+            }
+
+            // Continue if the button hasn't been released
+            if (releasedButton === null) {
+                this.clearGamepadHoldingInterval();
+                continue;
+            }
+
+            // Button released
+            this.gamepadLastStates[gamepad.index] = null;
+
+            if (lastKeyPressed) {
+                return;
+            }
+
+            if (releasedButton === GamepadKey.A) {
+                document.activeElement && document.activeElement.dispatchEvent(new MouseEvent('click'));
+                return;
+            } else if (releasedButton === GamepadKey.B) {
+                this.hide();
+                return;
+            }
+
+            if (this.handleGamepad(gamepad, releasedButton)) {
+                return;
+            }
+        }
+    }
+
+    private handleGamepad(gamepad: Gamepad, key: GamepadKey): boolean {
+        let handled = this.dialog?.handleGamepad(key);
+        if (handled) {
+            return true;
+        }
+
+        // Handle d-pad & sticks
+        let direction = NavigationDialogManager.GAMEPAD_DIRECTION_MAP[key as keyof typeof NavigationDialogManager.GAMEPAD_DIRECTION_MAP];
+        if (!direction) {
+            return false;
+        }
+
+        if (document.activeElement instanceof HTMLInputElement && document.activeElement.type === 'range') {
+            const $range = document.activeElement;
+            if (direction === NavigationDirection.LEFT || direction === NavigationDirection.RIGHT) {
+                $range.value = (parseInt($range.value) + parseInt($range.step) * (direction === NavigationDirection.LEFT ? -1 : 1)).toString();
+                $range.dispatchEvent(new InputEvent('input'));
+                handled = true;
+            }
+        }
+
+        if (!handled) {
+            this.focusDirection(direction);
+        }
+
+        this.gamepadLastStates[gamepad.index] && (this.gamepadLastStates[gamepad.index]![2] = true);
+        return true;
+    }
+
+    private clearGamepadHoldingInterval() {
+        this.gamepadHoldingIntervalId && window.clearInterval(this.gamepadHoldingIntervalId);
+        this.gamepadHoldingIntervalId = null;
+    }
+
+    show(dialog: NavigationDialog) {
+        this.clearGamepadHoldingInterval();
+
+        BxEvent.dispatch(window, BxEvent.XCLOUD_DIALOG_SHOWN);
+
+        // Stop xCloud's navigation polling
+        (window as any).BX_EXPOSED.disableGamepadPolling = true;
+
+        // Lock scroll bar
+        document.body.classList.add('bx-no-scroll');
+
+        // Show overlay
+        this.$overlay.classList.remove('bx-gone');
+        if (STATES.isPlaying) {
+            this.$overlay.classList.add('bx-invisible');
+        }
+
+        // Unmount current dialog
+        this.unmountCurrentDialog();
+
+        // Setup new dialog
+        this.dialog = dialog;
+        dialog.onBeforeMount();
+        this.$container.appendChild(dialog.getContent());
+        dialog.onMounted();
+
+        // Show content
+        this.$container.classList.remove('bx-gone');
+
+        // Add event listeners
+        this.$container.addEventListener('keydown', this);
+
+        // Start gamepad polling
+        this.startGamepadPolling();
+    }
+
+    hide() {
+        this.clearGamepadHoldingInterval();
+
+        // Unlock scroll bar
+        document.body.classList.remove('bx-no-scroll');
+
+        BxEvent.dispatch(window, BxEvent.XCLOUD_DIALOG_DISMISSED);
+
+        // Hide content
+        this.$overlay.classList.add('bx-gone');
+        this.$overlay.classList.remove('bx-invisible');
+        this.$container.classList.add('bx-gone');
+
+        // Remove event listeners
+        this.$container.removeEventListener('keydown', this);
+
+        // Stop gamepad polling
+        this.stopGamepadPolling();
+
+        // Unmount dialog
+        this.unmountCurrentDialog();
+
+        // Enable xCloud's navigation polling
+        (window as any).BX_EXPOSED.disableGamepadPolling = false;
+    }
+
+    focus($elm: NavigationElement | null): boolean {
+        if (!$elm) {
+            return false;
+        }
+
+        // console.log('focus', $elm);
+
+        if ($elm.nearby && $elm.nearby.focus) {
+            if ($elm.nearby.focus instanceof HTMLElement) {
+                return this.focus($elm.nearby.focus);
+            } else {
+                return $elm.nearby.focus();
+            }
+        }
+
+        $elm.focus();
+        return $elm === document.activeElement;
+    }
+
+    private getOrientation($elm: NavigationElement): NavigationNearbyElements['orientation'] {
+        const nearby = $elm.nearby || {};
+        if (nearby.selfOrientation) {
+            return nearby.selfOrientation;
+        }
+
+        let orientation;
+
+        let $current = $elm.parentElement! as NavigationElement;
+        while ($current !== this.$container) {
+            const tmp = $current.nearby?.orientation;
+            if ($current.nearby && tmp) {
+                orientation = tmp;
+                break;
+            }
+
+            $current = $current.parentElement!;
+        }
+
+        orientation = orientation || 'vertical';
+        setNearby($elm, {
+            selfOrientation: orientation,
+        });
+
+        return orientation;
+    }
+
+    findNextTarget($focusing: HTMLElement | null, direction: NavigationDirection, checkParent = false, checked: Array<HTMLElement> = []): HTMLElement | null {
+        if (!$focusing || $focusing === this.$container) {
+            return null;
+        }
+
+        if (checked.includes($focusing)) {
+            return null;
+        }
+
+        checked.push($focusing);
+
+        let $target: HTMLElement = $focusing;
+        const $parent = $target.parentElement;
+
+        const nearby = ($target as NavigationElement).nearby || {};
+        const orientation = this.getOrientation($target)!;
+
+        // @ts-ignore
+        let siblingProperty = (NavigationDialogManager.SIBLING_PROPERTY_MAP[orientation])[direction];
+        if (siblingProperty) {
+            let $sibling = $target as any;
+            while ($sibling[siblingProperty]) {
+                $sibling = $sibling[siblingProperty] as HTMLElement;
+
+                const $focusable = this.findFocusableElement($sibling, direction);
+                if ($focusable) {
+                    return $focusable;
+                }
+            }
+        }
+
+        if (nearby.loop) {
+            // Loop
+            if (nearby.loop(direction)) {
+                return null;
+            }
+        }
+
+        if (checkParent) {
+            return this.findNextTarget($parent, direction, checkParent, checked);
+        }
+
+        return null;
+    }
+
+    findFocusableElement($elm: HTMLElement | null, direction?: NavigationDirection): HTMLElement | null {
+        if (!$elm) {
+            return null;
+        }
+
+        // Ignore disabled element
+        const isDisabled = !!($elm as any).disabled;
+        if (isDisabled) {
+            return null;
+        }
+
+        // Ignore hidden element
+        if (!isElementVisible($elm)) {
+            return null;
+        }
+
+        // Accept element with tabIndex
+        if ($elm.tabIndex > -1) {
+            return $elm;
+        }
+
+        const focus = ($elm as NavigationElement).nearby?.focus;
+        if (focus) {
+            if (focus instanceof HTMLElement) {
+                return this.findFocusableElement(focus, direction);
+            } else if (typeof focus === 'function') {
+                if (focus()) {
+                    return document.activeElement as HTMLElement;
+                }
+            }
+        }
+
+        // Look for child focusable elemnet
+        const children = Array.from($elm.children);
+
+        // Search from right to left if the orientation is horizontal
+        const orientation = ($elm as NavigationElement).nearby?.orientation || 'vertical';
+        if (orientation === 'horizontal' || (orientation === 'vertical' && direction === NavigationDirection.UP)) {
+            children.reverse();
+        }
+
+        for (const $child of children) {
+            if (!$child || !($child instanceof HTMLElement)) {
+                return null;
+            }
+
+            const $target = this.findFocusableElement($child, direction);
+            if ($target) {
+                return $target;
+            }
+        }
+
+        return null;
+    }
+
+    private startGamepadPolling() {
+        this.stopGamepadPolling();
+
+        this.gamepadPollingIntervalId = window.setInterval(this.pollGamepad.bind(this), NavigationDialogManager.GAMEPAD_POLLING_INTERVAL);
+    }
+
+    private stopGamepadPolling() {
+        this.gamepadLastStates = [];
+
+        this.gamepadPollingIntervalId && window.clearInterval(this.gamepadPollingIntervalId);
+        this.gamepadPollingIntervalId = null;
+    }
+
+    private focusDirection(direction: NavigationDirection) {
+        const dialog = this.dialog;
+        if (!dialog) {
+            return;
+        }
+
+        // Get current focused element
+        const $focusing = dialog.getFocusedElement();
+        if (!$focusing || !this.findFocusableElement($focusing, direction)) {
+            dialog.focusIfNeeded();
+            return null;
+        }
+
+        const $target = this.findNextTarget($focusing, direction, true);
+        this.focus($target);
+    }
+
+    private unmountCurrentDialog() {
+        const dialog = this.dialog;
+
+        dialog && dialog.onBeforeUnmount();
+        this.$container.firstChild?.remove();
+        dialog && dialog.onUnmounted();
+
+        this.dialog = null;
+    }
+}

src/modules/ui/dialog/remote-play-dialog.ts

@@ -0,0 +1,135 @@
+import { ButtonStyle, CE, createButton } from "@/utils/html";
+import { NavigationDialog, type NavigationElement } from "./navigation-dialog";
+import { PrefKey } from "@/enums/pref-keys";
+import { BxIcon } from "@/utils/bx-icon";
+import { getPref, setPref } from "@/utils/settings-storages/global-settings-storage";
+import { t } from "@/utils/translation";
+import { RemotePlayConsoleState, RemotePlayManager } from "@/modules/remote-play-manager";
+import { BxSelectElement } from "@/web-components/bx-select";
+import { BxEvent } from "@/utils/bx-event";
+
+
+export class RemotePlayNavigationDialog extends NavigationDialog {
+    private static instance: RemotePlayNavigationDialog;
+    public static getInstance(): RemotePlayNavigationDialog {
+        if (!RemotePlayNavigationDialog.instance) {
+            RemotePlayNavigationDialog.instance = new RemotePlayNavigationDialog();
+        }
+        return RemotePlayNavigationDialog.instance;
+    }
+
+    private readonly STATE_LABELS: Record<RemotePlayConsoleState, string> = {
+        [RemotePlayConsoleState.ON]: t('powered-on'),
+        [RemotePlayConsoleState.OFF]: t('powered-off'),
+        [RemotePlayConsoleState.STANDBY]: t('standby'),
+        [RemotePlayConsoleState.UNKNOWN]: t('unknown'),
+    };
+
+    $container!: HTMLElement;
+
+    constructor() {
+        super();
+        this.setupDialog();
+    }
+
+    private setupDialog() {
+        const $fragment = CE('div', {'class': 'bx-remote-play-container'});
+
+        const $settingNote = CE('p', {});
+
+        const currentResolution = getPref(PrefKey.REMOTE_PLAY_RESOLUTION);
+        let $resolutions : HTMLSelectElement | NavigationElement = CE<HTMLSelectElement>('select', {},
+            CE('option', {value: '1080p'}, '1080p'),
+            CE('option', {value: '720p'}, '720p'),
+        );
+
+        if (getPref(PrefKey.UI_CONTROLLER_FRIENDLY)) {
+            $resolutions = BxSelectElement.wrap($resolutions as HTMLSelectElement);
+        }
+
+        $resolutions.addEventListener('input', (e: Event) => {
+            const value = (e.target as HTMLSelectElement).value;
+
+            $settingNote.textContent = value === '1080p' ? '✅ ' + t('can-stream-xbox-360-games') : '❌ ' + t('cant-stream-xbox-360-games');
+            setPref(PrefKey.REMOTE_PLAY_RESOLUTION, value);
+        });
+
+        ($resolutions as any).value = currentResolution;
+        BxEvent.dispatch($resolutions, 'input', {
+            manualTrigger: true,
+        });
+
+        const $qualitySettings = CE('div', {
+            class: 'bx-remote-play-settings',
+        }, CE('div', {},
+            CE('label', {}, t('target-resolution'), $settingNote),
+            $resolutions,
+        ));
+
+        $fragment.appendChild($qualitySettings);
+
+        // Render consoles list
+        const manager = RemotePlayManager.getInstance();
+        const consoles = manager.getConsoles();
+
+        for (let con of consoles) {
+            const $child = CE('div', {class: 'bx-remote-play-device-wrapper'},
+                CE('div', {class: 'bx-remote-play-device-info'},
+                    CE('div', {},
+                        CE('span', {class: 'bx-remote-play-device-name'}, con.deviceName),
+                        CE('span', {class: 'bx-remote-play-console-type'}, con.consoleType.replace('Xbox', ''))
+                    ),
+                    CE('div', {class: 'bx-remote-play-power-state'}, this.STATE_LABELS[con.powerState]),
+                ),
+
+                // Connect button
+                createButton({
+                    classes: ['bx-remote-play-connect-button'],
+                    label: t('console-connect'),
+                    style: ButtonStyle.PRIMARY | ButtonStyle.FOCUSABLE,
+                    onClick: e => manager.play(con.serverId),
+                }),
+            );
+
+            $fragment.appendChild($child);
+        }
+
+        // Add buttons
+        $fragment.appendChild(
+            CE('div', {
+                class: 'bx-remote-play-buttons',
+                _nearby: {
+                    orientation: 'horizontal',
+                },
+            },
+                createButton({
+                    icon: BxIcon.QUESTION,
+                    style: ButtonStyle.GHOST | ButtonStyle.FOCUSABLE,
+                    url: 'https://better-xcloud.github.io/remote-play',
+                    label: t('help'),
+                }),
+
+                createButton({
+                    style: ButtonStyle.GHOST | ButtonStyle.FOCUSABLE,
+                    label: t('close'),
+                    onClick: e => this.hide(),
+                }),
+            ),
+        );
+
+        this.$container = $fragment;
+    }
+
+    getDialog(): NavigationDialog {
+        return this;
+    }
+
+    getContent(): HTMLElement {
+        return this.$container;
+    }
+
+    focusIfNeeded(): void {
+        const $btnConnect = this.$container.querySelector('.bx-remote-play-device-wrapper button') as HTMLElement;
+        $btnConnect && $btnConnect.focus();
+    }
+}

src/modules/ui/fullscreen-text.ts

@@ -0,0 +1,33 @@
+import { CE } from "@/utils/html";
+
+export class FullscreenText {
+    private static instance: FullscreenText;
+    public static getInstance(): FullscreenText {
+        if (!FullscreenText.instance) {
+            FullscreenText.instance = new FullscreenText();
+        }
+        return FullscreenText.instance;
+    }
+
+    $text: HTMLElement;
+
+    constructor() {
+        this.$text = CE('div', {
+            class: 'bx-fullscreen-text bx-gone',
+        });
+
+        document.documentElement.appendChild(this.$text);
+    }
+
+    show(msg: string) {
+        document.body.classList.add('bx-no-scroll');
+
+        this.$text.classList.remove('bx-gone');
+        this.$text.textContent = msg;
+    }
+
+    hide() {
+        document.body.classList.remove('bx-no-scroll');
+        this.$text.classList.add('bx-gone');
+    }
+}

src/modules/ui/game-tile.ts

@@ -0,0 +1,92 @@
+import { BxEvent } from "@/utils/bx-event";
+import { BxIcon } from "@/utils/bx-icon";
+import { CE, createSvgIcon, getReactProps, isElementVisible, secondsToHms } from "@/utils/html";
+import { XcloudApi } from "@/utils/xcloud-api";
+
+export class GameTile {
+    static #timeout: number | null;
+
+    static async #showWaitTime($elm: HTMLElement, productId: string) {
+        if (($elm as any).hasWaitTime) {
+            return;
+        }
+        ($elm as any).hasWaitTime = true;
+
+        let totalWaitTime;
+
+        const api = XcloudApi.getInstance();
+        const info = await api.getTitleInfo(productId);
+        if (info) {
+            const waitTime = await api.getWaitTime(info.titleId);
+            if (waitTime) {
+                totalWaitTime = waitTime.estimatedAllocationTimeInSeconds;
+            }
+        }
+
+        if (typeof totalWaitTime === 'number' && isElementVisible($elm)) {
+            const $div = CE('div', {'class': 'bx-game-tile-wait-time'},
+                createSvgIcon(BxIcon.PLAYTIME),
+                CE('span', {}, secondsToHms(totalWaitTime)),
+            );
+            $elm.insertAdjacentElement('afterbegin', $div);
+        }
+    }
+
+    static #requestWaitTime($elm: HTMLElement, productId: string) {
+        GameTile.#timeout && clearTimeout(GameTile.#timeout);
+        GameTile.#timeout = window.setTimeout(async () => {
+            GameTile.#showWaitTime($elm, productId);
+        }, 500);
+    }
+
+    static #findProductId($elm: HTMLElement): string | null {
+        let productId = null;
+
+        try {
+            if (($elm.tagName === 'BUTTON' && $elm.className.includes('MruGameCard')) || (($elm.tagName === 'A' && $elm.className.includes('GameCard')))) {
+                let props = getReactProps($elm.parentElement!);
+
+                // When context menu is enabled
+                if (Array.isArray(props.children)) {
+                    productId = props.children[0].props.productId;
+                } else {
+                    productId = props.children.props.productId;
+                }
+            } else if ($elm.tagName === 'A' && $elm.className.includes('GameItem'))  {
+                let props = getReactProps($elm.parentElement!);
+                props = props.children.props;
+                if (props.location !== 'NonStreamableGameItem') {
+                    if ('productId' in props) {
+                        productId = props.productId;
+                    } else {
+                        // Search page
+                        productId = props.children.props.productId;
+                    }
+                }
+            }
+        } catch (e) {}
+
+        return productId;
+    }
+
+    static setup() {
+        window.addEventListener(BxEvent.NAVIGATION_FOCUS_CHANGED, e => {
+            const $elm = (e as any).element;
+            const className = $elm.className || '';
+            if (className.includes('MruGameCard')) {
+                // Show the wait time of every games in the "Jump back in" section all at once
+                const $ol = $elm.closest('ol');
+                if ($ol && !($ol as any).hasWaitTime) {
+                    ($ol as any).hasWaitTime = true;
+                    $ol.querySelectorAll('button[class*=MruGameCard]').forEach(($elm: HTMLElement) => {
+                        const productId = GameTile.#findProductId($elm);
+                        productId && GameTile.#showWaitTime($elm, productId);
+                    });
+                }
+            } else {
+                const productId = GameTile.#findProductId($elm);
+                productId && GameTile.#requestWaitTime($elm, productId);
+            }
+        });
+    }
+}

src/modules/ui/global-settings.ts

@@ -1,411 +0,0 @@
-import { STATES, AppInterface, SCRIPT_VERSION } from "@utils/global";
-import { CE, createButton, ButtonStyle } from "@utils/html";
-import { BxIcon } from "@utils/bx-icon";
-import { getPreferredServerRegion } from "@utils/region";
-import { UserAgent } from "@utils/user-agent";
-import { getPref, Preferences, PrefKey, setPref, toPrefElement } from "@utils/preferences";
-import { t, Translations } from "@utils/translation";
-import { PatcherCache } from "../patcher";
-import { UserAgentProfile } from "@enums/user-agent";
-
-const SETTINGS_UI = {
-    'Better xCloud': {
-        items: [
-            PrefKey.BETTER_XCLOUD_LOCALE,
-            PrefKey.REMOTE_PLAY_ENABLED,
-        ],
-    },
-
-    [t('server')]: {
-        items: [
-            PrefKey.SERVER_REGION,
-            PrefKey.STREAM_PREFERRED_LOCALE,
-            PrefKey.PREFER_IPV6_SERVER,
-        ],
-    },
-
-    [t('stream')]: {
-        items: [
-            PrefKey.STREAM_TARGET_RESOLUTION,
-            PrefKey.STREAM_CODEC_PROFILE,
-
-            PrefKey.BITRATE_VIDEO_MAX,
-
-            PrefKey.AUDIO_ENABLE_VOLUME_CONTROL,
-            PrefKey.STREAM_DISABLE_FEEDBACK_DIALOG,
-
-            PrefKey.SCREENSHOT_APPLY_FILTERS,
-
-            PrefKey.AUDIO_MIC_ON_PLAYING,
-            PrefKey.GAME_FORTNITE_FORCE_CONSOLE,
-            PrefKey.STREAM_COMBINE_SOURCES,
-        ],
-    },
-
-    [t('game-bar')]: {
-        items: [
-            PrefKey.GAME_BAR_POSITION,
-        ],
-    },
-
-    [t('local-co-op')]: {
-        items: [
-            PrefKey.LOCAL_CO_OP_ENABLED,
-        ],
-    },
-
-    [t('mouse-and-keyboard')]: {
-        items: [
-            PrefKey.NATIVE_MKB_ENABLED,
-            PrefKey.MKB_ENABLED,
-            PrefKey.MKB_HIDE_IDLE_CURSOR,
-        ],
-    },
-
-    [t('touch-controller')]: {
-        note: !STATES.userAgentHasTouchSupport ? '⚠️ ' + t('device-unsupported-touch') : null,
-        unsupported: !STATES.userAgentHasTouchSupport,
-        items: [
-            PrefKey.STREAM_TOUCH_CONTROLLER,
-            PrefKey.STREAM_TOUCH_CONTROLLER_AUTO_OFF,
-            PrefKey.STREAM_TOUCH_CONTROLLER_DEFAULT_OPACITY,
-            PrefKey.STREAM_TOUCH_CONTROLLER_STYLE_STANDARD,
-            PrefKey.STREAM_TOUCH_CONTROLLER_STYLE_CUSTOM,
-        ],
-    },
-
-    [t('loading-screen')]: {
-        items: [
-            PrefKey.UI_LOADING_SCREEN_GAME_ART,
-            PrefKey.UI_LOADING_SCREEN_WAIT_TIME,
-            PrefKey.UI_LOADING_SCREEN_ROCKET,
-        ],
-    },
-
-    [t('ui')]: {
-        items: [
-            PrefKey.UI_LAYOUT,
-            PrefKey.UI_HOME_CONTEXT_MENU_DISABLED,
-            PrefKey.STREAM_SIMPLIFY_MENU,
-            PrefKey.SKIP_SPLASH_VIDEO,
-            !AppInterface && PrefKey.UI_SCROLLBAR_HIDE,
-            PrefKey.HIDE_DOTS_ICON,
-            PrefKey.REDUCE_ANIMATIONS,
-        ],
-    },
-
-    [t('other')]: {
-        items: [
-            PrefKey.BLOCK_SOCIAL_FEATURES,
-            PrefKey.BLOCK_TRACKING,
-        ],
-    },
-
-    [t('advanced')]: {
-        items: [
-            PrefKey.USER_AGENT_PROFILE,
-        ],
-    },
-};
-
-
-export function setupSettingsUi() {
-    // Avoid rendering the Settings multiple times
-    if (document.querySelector('.bx-settings-container')) {
-        return;
-    }
-
-    const PREF_PREFERRED_REGION = getPreferredServerRegion();
-    const PREF_LATEST_VERSION = getPref(PrefKey.LATEST_VERSION);
-
-    let $btnReload: HTMLButtonElement;
-
-    // Setup Settings UI
-    const $container = CE<HTMLElement>('div', {
-        'class': 'bx-settings-container bx-gone',
-    });
-
-    let $updateAvailable;
-
-    const $wrapper = CE<HTMLElement>('div', {'class': 'bx-settings-wrapper'},
-            CE<HTMLElement>('div', {'class': 'bx-settings-title-wrapper'},
-                CE('a', {
-                    'class': 'bx-settings-title',
-                    'href': 'https://github.com/redphx/better-xcloud/releases',
-                    'target': '_blank',
-                }, 'Better xCloud ' + SCRIPT_VERSION),
-                createButton({
-                    icon: BxIcon.QUESTION,
-                    style: ButtonStyle.FOCUSABLE,
-                    label: t('help'),
-                    url: 'https://better-xcloud.github.io/features/',
-                }),
-            )
-        );
-    $updateAvailable = CE('a', {
-        'class': 'bx-settings-update bx-gone',
-        'href': 'https://github.com/redphx/better-xcloud/releases/latest',
-        'target': '_blank',
-    });
-
-    $wrapper.appendChild($updateAvailable);
-
-    // Show new version indicator
-    if (!SCRIPT_VERSION.includes('beta') && PREF_LATEST_VERSION && PREF_LATEST_VERSION != SCRIPT_VERSION) {
-        $updateAvailable.textContent = `🌟 Version ${PREF_LATEST_VERSION} available`;
-        $updateAvailable.classList.remove('bx-gone');
-    }
-
-    if (AppInterface) {
-        // Show Android app settings button
-        const $btn = createButton({
-            label: t('android-app-settings'),
-            icon: BxIcon.STREAM_SETTINGS,
-            style: ButtonStyle.FULL_WIDTH | ButtonStyle.FOCUSABLE,
-            onClick: e => {
-                AppInterface.openAppSettings && AppInterface.openAppSettings();
-            },
-        });
-
-        $wrapper.appendChild($btn);
-    } else {
-        // Show link to Android app
-        const userAgent = UserAgent.getDefault().toLowerCase();
-        if (userAgent.includes('android')) {
-            const $btn = createButton({
-                label: '🔥 ' + t('install-android'),
-                style: ButtonStyle.FULL_WIDTH | ButtonStyle.FOCUSABLE,
-                url: 'https://better-xcloud.github.io/android',
-            });
-
-            $wrapper.appendChild($btn);
-        }
-    }
-
-    const onChange = async (e: Event) => {
-        // Clear PatcherCache;
-        PatcherCache.clear();
-
-        $btnReload.classList.add('bx-danger');
-
-        // Highlight the Settings button in the Header to remind user to reload the page
-        const $btnHeaderSettings = document.querySelector('.bx-header-settings-button');
-        $btnHeaderSettings && $btnHeaderSettings.classList.add('bx-danger');
-
-        if ((e.target as HTMLElement).id === 'bx_setting_' + PrefKey.BETTER_XCLOUD_LOCALE) {
-            // Update locale
-            Translations.refreshCurrentLocale();
-            await Translations.updateTranslations();
-
-            $btnReload.textContent = t('settings-reloading');
-            $btnReload.click();
-        }
-    };
-
-    // Render settings
-    for (let groupLabel in SETTINGS_UI) {
-        const $group = CE('span', {'class': 'bx-settings-group-label'}, groupLabel);
-
-        // Render note
-        if (SETTINGS_UI[groupLabel].note) {
-            const $note = CE('b', {}, SETTINGS_UI[groupLabel].note);
-            $group.appendChild($note);
-        }
-
-        $wrapper.appendChild($group);
-
-        // Don't render settings if this is an unsupported feature
-        if (SETTINGS_UI[groupLabel].unsupported) {
-            continue;
-        }
-
-        const settingItems = SETTINGS_UI[groupLabel].items;
-        for (let settingId of settingItems) {
-            // Don't render custom settings
-            if (!settingId) {
-                continue;
-            }
-
-            const setting = Preferences.SETTINGS[settingId];
-            if (!setting) {
-                continue;
-            }
-
-            let settingLabel = setting.label;
-            let settingNote = setting.note || '';
-
-            // Add Experimental text
-            if (setting.experimental) {
-                settingLabel = '🧪 ' + settingLabel;
-                if (!settingNote) {
-                    settingNote = t('experimental')
-                } else {
-                    settingNote = `${t('experimental')}: ${settingNote}`
-                }
-            }
-
-            let $control: any;
-            let $inpCustomUserAgent: HTMLInputElement;
-            let labelAttrs: any = {
-                tabindex: '-1',
-            };
-
-            if (settingId === PrefKey.USER_AGENT_PROFILE) {
-                let defaultUserAgent = (window.navigator as any).orgUserAgent || window.navigator.userAgent;
-                $inpCustomUserAgent = CE('input', {
-                    id: `bx_setting_inp_${settingId}`,
-                    type: 'text',
-                    placeholder: defaultUserAgent,
-                    'class': 'bx-settings-custom-user-agent',
-                });
-                $inpCustomUserAgent.addEventListener('change', e => {
-                    const profile = $control.value;
-                    const custom = (e.target as HTMLInputElement).value.trim();
-
-                    UserAgent.updateStorage(profile, custom);
-                    onChange(e);
-                });
-
-                $control = toPrefElement(PrefKey.USER_AGENT_PROFILE, (e: Event) => {
-                    const value = (e.target as HTMLInputElement).value as UserAgentProfile;
-                    let isCustom = value === UserAgentProfile.CUSTOM;
-                    let userAgent = UserAgent.get(value as UserAgentProfile);
-
-                    UserAgent.updateStorage(value);
-
-                    $inpCustomUserAgent.value = userAgent;
-                    $inpCustomUserAgent.readOnly = !isCustom;
-                    $inpCustomUserAgent.disabled = !isCustom;
-
-                    !(e.target as HTMLInputElement).disabled && onChange(e);
-                });
-            } else if (settingId === PrefKey.SERVER_REGION) {
-                let selectedValue;
-
-                $control = CE<HTMLSelectElement>('select', {
-                        id: `bx_setting_${settingId}`,
-                        title: settingLabel,
-                        tabindex: 0,
-                    });
-                $control.name = $control.id;
-
-                $control.addEventListener('change', (e: Event) => {
-                    setPref(settingId, (e.target as HTMLSelectElement).value);
-                    onChange(e);
-                });
-
-                selectedValue = PREF_PREFERRED_REGION;
-
-                setting.options = {};
-                for (let regionName in STATES.serverRegions) {
-                    const region = STATES.serverRegions[regionName];
-                    let value = regionName;
-
-                    let label = `${region.shortName} - ${regionName}`;
-                    if (region.isDefault) {
-                        label += ` (${t('default')})`;
-                        value = 'default';
-
-                        if (selectedValue === regionName) {
-                            selectedValue = 'default';
-                        }
-                    }
-
-                    setting.options[value] = label;
-                }
-
-                for (let value in setting.options) {
-                    const label = setting.options[value];
-
-                    const $option = CE('option', {value: value}, label);
-                    $control.appendChild($option);
-                }
-
-                // Select preferred region
-                $control.value = selectedValue;
-            } else {
-                if (settingId === PrefKey.BETTER_XCLOUD_LOCALE) {
-                    $control = toPrefElement(settingId, (e: Event) => {
-                        localStorage.setItem('better_xcloud_locale', (e.target as HTMLSelectElement).value);
-                        onChange(e);
-                    });
-                } else {
-                    $control = toPrefElement(settingId, onChange);
-                }
-            }
-
-            if (!!$control.id) {
-                labelAttrs['for'] = $control.id;
-            } else {
-                labelAttrs['for'] = `bx_setting_${settingId}`;
-            }
-
-            // Disable unsupported settings
-            if (setting.unsupported) {
-                ($control as HTMLInputElement).disabled = true;
-            }
-
-            // Make disabled control elements un-focusable
-            if ($control.disabled && !!$control.getAttribute('tabindex')) {
-                $control.setAttribute('tabindex', -1);
-            }
-
-            const $label = CE('label', labelAttrs, settingLabel);
-            if (settingNote) {
-                $label.appendChild(CE('b', {}, settingNote));
-            }
-            const $elm = CE<HTMLElement>('div', {'class': 'bx-settings-row'},
-                    $label,
-                    $control,
-                );
-
-            $wrapper.appendChild($elm);
-
-            // Add User-Agent input
-            if (settingId === PrefKey.USER_AGENT_PROFILE) {
-                $wrapper.appendChild($inpCustomUserAgent!);
-                // Trigger 'change' event
-                $control.disabled = true;
-                $control.dispatchEvent(new Event('change'));
-                $control.disabled = false;
-            }
-        }
-    }
-
-    // Setup Reload button
-    $btnReload = createButton({
-        label: t('settings-reload'),
-        classes: ['bx-settings-reload-button'],
-        style: ButtonStyle.FOCUSABLE | ButtonStyle.FULL_WIDTH | ButtonStyle.TALL,
-        onClick: e => {
-            window.location.reload();
-            $btnReload.disabled = true;
-            $btnReload.textContent = t('settings-reloading');
-        },
-    });
-    $btnReload.setAttribute('tabindex', '0');
-
-    $wrapper.appendChild($btnReload);
-
-    // Donation link
-    const $donationLink = CE('a', {
-            'class': 'bx-donation-link',
-            href: 'https://ko-fi.com/redphx',
-            target: '_blank',
-            tabindex: 0,
-        }, `❤️ ${t('support-better-xcloud')}`);
-    $wrapper.appendChild($donationLink);
-
-    // Show Game Pass app version
-    try {
-        const appVersion = (document.querySelector('meta[name=gamepass-app-version]') as HTMLMetaElement).content;
-        const appDate = new Date((document.querySelector('meta[name=gamepass-app-date]') as HTMLMetaElement).content).toISOString().substring(0, 10);
-        $wrapper.appendChild(CE<HTMLElement>('div', {'class': 'bx-settings-app-version'}, `xCloud website version ${appVersion} (${appDate})`));
-    } catch (e) {}
-
-    $container.appendChild($wrapper);
-
-    // Add Settings UI to the web page
-    const $pageContent = document.getElementById('PageContent');
-    $pageContent?.parentNode?.insertBefore($container, $pageContent);
-}

src/modules/ui/guide-menu.ts

@@ -1,80 +1,212 @@
+import { isFullVersion } from "@macros/build" with {type: "macro"};
+
 import { BxEvent } from "@/utils/bx-event";
 import { AppInterface, STATES } from "@/utils/global";
-import { createButton, ButtonStyle } from "@/utils/html";
+import { createButton, ButtonStyle, CE } from "@/utils/html";
 import { t } from "@/utils/translation";
+import { SettingsNavigationDialog } from "./dialog/settings-dialog";
+import { TrueAchievements } from "@/utils/true-achievements";
+import { BxIcon } from "@/utils/bx-icon";
 
 export enum GuideMenuTab {
-    HOME,
+    HOME = 'home',
 }
 
 export class GuideMenu {
-    static #injectHome($root: HTMLElement) {
+    static #BUTTONS = {
-        // Find the last divider
+        scriptSettings: createButton({
-        const $dividers = $root.querySelectorAll('div[class*=Divider-module__divider]');
+            label: t('better-xcloud'),
-        if (!$dividers) {
+            style: ButtonStyle.FULL_WIDTH | ButtonStyle.FOCUSABLE | ButtonStyle.PRIMARY,
-            return;
+            onClick: e => {
-        }
+                // Wait until the Guide dialog is closed
-        const $lastDivider = $dividers[$dividers.length - 1];
+                window.addEventListener(BxEvent.XCLOUD_DIALOG_DISMISSED, e => {
+                    setTimeout(() => SettingsNavigationDialog.getInstance().show(), 50);
+                }, {once: true});
 
-        // Add "Close app" button
+                // Close all xCloud's dialogs
-        if (AppInterface) {
+                GuideMenu.#closeGuideMenu();
-            const $btnQuit = createButton({
+            },
-                label: t('close-app'),
+        }),
-                style: ButtonStyle.FULL_WIDTH | ButtonStyle.FOCUSABLE | ButtonStyle.DANGER,
-                onClick: e => {
-                    AppInterface.closeApp();
-                },
-            });
 
-            $lastDivider.insertAdjacentElement('afterend', $btnQuit);
+        closeApp: AppInterface && createButton({
-        }
+            icon: BxIcon.POWER,
-    }
+            label: t('close-app'),
+            title: t('close-app'),
+            style: ButtonStyle.FULL_WIDTH | ButtonStyle.FOCUSABLE | ButtonStyle.DANGER,
+            onClick: e => {
+                AppInterface.closeApp();
+            },
 
-    static #injectHomePlaying($root: HTMLElement) {
+            attributes: {
-        const $btnQuit = $root.querySelector('a[class*=QuitGameButton]');
+                'data-state': 'normal',
-        if (!$btnQuit) {
+            },
-            return;
+        }),
-        }
 
-        // Add buttons
+        reloadPage: createButton({
-        const $btnReload = createButton({
+            icon: BxIcon.REFRESH,
-            label: t('reload-stream'),
+            label: t('reload-page'),
+            title: t('reload-page'),
             style: ButtonStyle.FULL_WIDTH | ButtonStyle.FOCUSABLE,
             onClick: e => {
-                confirm(t('confirm-reload-stream')) && window.location.reload();
+                if (STATES.isPlaying) {
-            },
+                    confirm(t('confirm-reload-stream')) && window.location.reload();
-        });
+                } else {
+                    window.location.reload();
+                }
 
-        const $btnHome = createButton({
+                // Close all xCloud's dialogs
+                GuideMenu.#closeGuideMenu();
+            },
+        }),
+
+        backToHome: createButton({
+            icon: BxIcon.HOME,
             label: t('back-to-home'),
+            title: t('back-to-home'),
             style: ButtonStyle.FULL_WIDTH | ButtonStyle.FOCUSABLE,
             onClick: e => {
                 confirm(t('back-to-home-confirm')) && (window.location.href = window.location.href.substring(0, 31));
+
+                // Close all xCloud's dialogs
+                GuideMenu.#closeGuideMenu();
             },
+            attributes: {
+                'data-state': 'playing',
+            },
+        }),
+    }
+
+    static #$renderedButtons: HTMLElement;
+
+    static #closeGuideMenu() {
+        if (window.BX_EXPOSED.dialogRoutes) {
+            window.BX_EXPOSED.dialogRoutes.closeAll();
+            return;
+        }
+
+        // Use alternative method for Lite version
+        const $btnClose = document.querySelector('#gamepass-dialog-root button[class^=Header-module__closeButton]') as HTMLElement;
+        $btnClose && $btnClose.click();
+    }
+
+    static #renderButtons() {
+        if (GuideMenu.#$renderedButtons) {
+            return GuideMenu.#$renderedButtons;
+        }
+
+        const $div = CE('div', {
+            class: 'bx-guide-home-buttons',
         });
 
-        $btnQuit.insertAdjacentElement('afterend', $btnReload);
+        const buttons = [
-        $btnReload.insertAdjacentElement('afterend', $btnHome);
+            GuideMenu.#BUTTONS.scriptSettings,
+            [
+                GuideMenu.#BUTTONS.backToHome,
+                GuideMenu.#BUTTONS.reloadPage,
+                GuideMenu.#BUTTONS.closeApp,
+            ],
+        ];
 
-        // Hide xCloud's Home button
+        for (const $button of buttons) {
-        const $btnXcloudHome = $root.querySelector('div[class^=HomeButtonWithDivider]') as HTMLElement;
+            if (!$button) {
-        $btnXcloudHome && ($btnXcloudHome.style.display = 'none');
+                continue;
+            }
+
+            if ($button instanceof HTMLElement) {
+                $div.appendChild($button);
+            } else if (Array.isArray($button)) {
+                const $wrapper = CE('div', {});
+                for (const $child of $button) {
+                    $child && $wrapper.appendChild($child);
+                }
+                $div.appendChild($wrapper);
+            }
+        }
+
+        GuideMenu.#$renderedButtons = $div;
+        return $div;
+    }
+
+    static #injectHome($root: HTMLElement, isPlaying = false) {
+        if (isFullVersion()) {
+            const $achievementsProgress = $root.querySelector('button[class*=AchievementsButton-module__progressBarContainer]');
+            if ($achievementsProgress) {
+                TrueAchievements.injectAchievementsProgress($achievementsProgress as HTMLElement);
+            }
+        }
+
+        // Find the element to add buttons to
+        let $target: HTMLElement | null = null;
+        if (isPlaying) {
+            // Quit button
+            $target = $root.querySelector('a[class*=QuitGameButton]');
+
+            // Hide xCloud's Home button
+            const $btnXcloudHome = $root.querySelector('div[class^=HomeButtonWithDivider]') as HTMLElement;
+            $btnXcloudHome && ($btnXcloudHome.style.display = 'none');
+        } else {
+            // Last divider
+            const $dividers = $root.querySelectorAll('div[class*=Divider-module__divider]');
+            if ($dividers) {
+                $target = $dividers[$dividers.length - 1] as HTMLElement;
+            }
+        }
+
+        if (!$target) {
+            return false;
+        }
+
+        const $buttons = GuideMenu.#renderButtons();
+        $buttons.dataset.isPlaying = isPlaying.toString();
+        $target.insertAdjacentElement('afterend', $buttons);
     }
 
     static async #onShown(e: Event) {
         const where = (e as any).where as GuideMenuTab;
 
         if (where === GuideMenuTab.HOME) {
-            const $root = document.querySelector('#gamepass-dialog-root div[role=dialog]') as HTMLElement;
+            const $root = document.querySelector('#gamepass-dialog-root div[role=dialog] div[role=tabpanel] div[class*=HomeLandingPage]') as HTMLElement;
-            if (STATES.isPlaying) {
+            $root && GuideMenu.#injectHome($root, STATES.isPlaying);
-                GuideMenu.#injectHomePlaying($root);
-            } else {
-                GuideMenu.#injectHome($root);
-            }
         }
     }
 
-    static observe() {
+    static addEventListeners() {
         window.addEventListener(BxEvent.XCLOUD_GUIDE_MENU_SHOWN, GuideMenu.#onShown);
     }
+
+    static observe($addedElm: HTMLElement) {
+        const className = $addedElm.className;
+
+        if (isFullVersion() && className.includes('AchievementsButton-module__progressBarContainer')) {
+            TrueAchievements.injectAchievementsProgress($addedElm);
+            return;
+        }
+
+        if (!className.startsWith('NavigationAnimation') &&
+                !className.startsWith('DialogRoutes') &&
+                !className.startsWith('Dialog-module__container')) {
+            return;
+        }
+
+        // Achievement Details page
+        if (isFullVersion()) {
+            const $achievDetailPage = $addedElm.querySelector('div[class*=AchievementDetailPage]');
+            if ($achievDetailPage) {
+                TrueAchievements.injectAchievementDetailPage($achievDetailPage as HTMLElement);
+                return;
+            }
+        }
+
+        // Find navigation bar
+        const $selectedTab = $addedElm.querySelector('div[class^=NavigationMenu] button[aria-selected=true');
+        if ($selectedTab) {
+            let $elm: Element | null = $selectedTab;
+            let index;
+            for (index = 0; ($elm = $elm?.previousElementSibling); index++);
+
+            if (index === 0) {
+                BxEvent.dispatch(window, BxEvent.XCLOUD_GUIDE_MENU_SHOWN, {where: GuideMenuTab.HOME});
+            }
+        }
+    }
 }

src/modules/ui/header.ts

@@ -1,85 +1,94 @@
 import { SCRIPT_VERSION } from "@utils/global";
-import { createButton, ButtonStyle } from "@utils/html";
+import { createButton, ButtonStyle, CE, isElementVisible } from "@utils/html";
 import { BxIcon } from "@utils/bx-icon";
 import { getPreferredServerRegion } from "@utils/region";
-import { PrefKey, getPref } from "@utils/preferences";
+import { RemotePlayManager } from "@/modules/remote-play-manager";
-import { RemotePlay } from "@modules/remote-play";
 import { t } from "@utils/translation";
-import { setupSettingsUi } from "./global-settings";
+import { SettingsNavigationDialog } from "./dialog/settings-dialog";
+import { PrefKey } from "@/enums/pref-keys";
+import { getPref } from "@/utils/settings-storages/global-settings-storage";
 
-
+export class HeaderSection {
-function injectSettingsButton($parent?: HTMLElement) {
+    static #$remotePlayBtn = createButton({
-    if (!$parent) {
+        classes: ['bx-header-remote-play-button', 'bx-gone'],
-        return;
+        icon: BxIcon.REMOTE_PLAY,
-    }
+        title: t('remote-play'),
-
+        style: ButtonStyle.GHOST | ButtonStyle.FOCUSABLE | ButtonStyle.CIRCULAR,
-    const PREF_PREFERRED_REGION = getPreferredServerRegion(true);
-    const PREF_LATEST_VERSION = getPref(PrefKey.LATEST_VERSION);
-
-    const $headerFragment = document.createDocumentFragment();
-
-    // Remote Play button
-    if (getPref(PrefKey.REMOTE_PLAY_ENABLED)) {
-        const $remotePlayBtn = createButton({
-            classes: ['bx-header-remote-play-button'],
-            icon: BxIcon.REMOTE_PLAY,
-            title: t('remote-play'),
-            style: ButtonStyle.GHOST | ButtonStyle.FOCUSABLE,
-            onClick: e => {
-                RemotePlay.togglePopup();
-            },
-        });
-        $headerFragment.appendChild($remotePlayBtn);
-    }
-
-    // Setup Settings button
-    const $settingsBtn = createButton({
-        classes: ['bx-header-settings-button'],
-        label: PREF_PREFERRED_REGION,
-        style: ButtonStyle.GHOST | ButtonStyle.FOCUSABLE | ButtonStyle.FULL_HEIGHT,
         onClick: e => {
-            setupSettingsUi();
+            RemotePlayManager.getInstance().togglePopup();
-
-            const $settings = document.querySelector('.bx-settings-container')!;
-            $settings.classList.toggle('bx-gone');
-            window.scrollTo(0, 0);
-            document.activeElement && (document.activeElement as HTMLElement).blur();
         },
     });
 
-    // Show new update status
+    static #$settingsBtn = createButton({
-    if (!SCRIPT_VERSION.includes('beta') && PREF_LATEST_VERSION && PREF_LATEST_VERSION !== SCRIPT_VERSION) {
+        classes: ['bx-header-settings-button'],
-        $settingsBtn.setAttribute('data-update-available', 'true');
+        label: '???',
-    }
+        style: ButtonStyle.FROSTED | ButtonStyle.DROP_SHADOW | ButtonStyle.FOCUSABLE | ButtonStyle.FULL_HEIGHT,
-
+        onClick: e => {
-    // Add the Settings button to the web page
+            SettingsNavigationDialog.getInstance().show();
-    $headerFragment.appendChild($settingsBtn);
+        },
-    $parent.appendChild($headerFragment);
-}
-
-
-export function checkHeader() {
-    const $button = document.querySelector('.bx-header-settings-button');
-
-    if (!$button) {
-        const $rightHeader = document.querySelector('#PageContent div[class*=EdgewaterHeader-module__rightSectionSpacing]');
-        injectSettingsButton($rightHeader as HTMLElement);
-    }
-}
-
-
-export function watchHeader() {
-    const $header = document.querySelector('#PageContent header');
-    if (!$header) {
-        return;
-    }
-
-    let timeout: number | null;
-    const observer = new MutationObserver(mutationList => {
-        timeout && clearTimeout(timeout);
-        timeout = window.setTimeout(checkHeader, 2000);
     });
-    observer.observe($header, {subtree: true, childList: true});
 
-    checkHeader();
+    static #$buttonsWrapper = CE('div', {},
+        getPref(PrefKey.REMOTE_PLAY_ENABLED) ? HeaderSection.#$remotePlayBtn : null,
+        HeaderSection.#$settingsBtn,
+    );
+
+    static #observer: MutationObserver;
+    static #timeout: number | null;
+
+    static #injectSettingsButton($parent?: HTMLElement) {
+        if (!$parent) {
+            return;
+        }
+
+        const PREF_LATEST_VERSION = getPref(PrefKey.LATEST_VERSION);
+
+        // Setup Settings button
+        const $btnSettings = HeaderSection.#$settingsBtn;
+        if (isElementVisible(HeaderSection.#$buttonsWrapper)) {
+            return;
+        }
+
+        $btnSettings.querySelector('span')!.textContent = getPreferredServerRegion(true) || t('better-xcloud');
+
+        // Show new update status
+        if (!SCRIPT_VERSION.includes('beta') && PREF_LATEST_VERSION && PREF_LATEST_VERSION !== SCRIPT_VERSION) {
+            $btnSettings.setAttribute('data-update-available', 'true');
+        }
+
+        // Add the Settings button to the web page
+        $parent.appendChild(HeaderSection.#$buttonsWrapper);
+    }
+
+    static checkHeader() {
+        let $target = document.querySelector('#PageContent div[class*=EdgewaterHeader-module__rightSectionSpacing]');
+        if (!$target) {
+            $target = document.querySelector('div[class^=UnsupportedMarketPage-module__buttons]');
+        }
+
+        $target && HeaderSection.#injectSettingsButton($target as HTMLElement);
+    }
+
+    static showRemotePlayButton() {
+        HeaderSection.#$remotePlayBtn.classList.remove('bx-gone');
+    }
+
+    static watchHeader() {
+        const $root = document.querySelector('#PageContent header') || document.querySelector('#root');
+        if (!$root) {
+            return;
+        }
+
+        HeaderSection.#timeout && clearTimeout(HeaderSection.#timeout);
+        HeaderSection.#timeout = null;
+
+        HeaderSection.#observer && HeaderSection.#observer.disconnect();
+        HeaderSection.#observer = new MutationObserver(mutationList => {
+            HeaderSection.#timeout && clearTimeout(HeaderSection.#timeout);
+            HeaderSection.#timeout = window.setTimeout(HeaderSection.checkHeader, 2000);
+        });
+        HeaderSection.#observer.observe($root, {subtree: true, childList: true});
+
+        HeaderSection.checkHeader();
+    }
 }

src/modules/ui/product-details.ts

@@ -0,0 +1,58 @@
+import { BX_FLAGS } from "@/utils/bx-flags";
+import { BxIcon } from "@/utils/bx-icon";
+import { AppInterface } from "@/utils/global";
+import { ButtonStyle, CE, createButton } from "@/utils/html";
+import { t } from "@/utils/translation";
+
+export class ProductDetailsPage {
+    private static $btnShortcut = AppInterface && createButton({
+        icon: BxIcon.CREATE_SHORTCUT,
+        label: t('create-shortcut'),
+        style: ButtonStyle.FOCUSABLE,
+        tabIndex: 0,
+        onClick: e => {
+            AppInterface.createShortcut(window.location.pathname.substring(6));
+        },
+    });
+
+    private static $btnWallpaper = AppInterface && createButton({
+        icon: BxIcon.DOWNLOAD,
+        label: t('wallpaper'),
+        style: ButtonStyle.FOCUSABLE,
+        tabIndex: 0,
+        onClick: async e => {
+            try {
+                const matches = /\/games\/(?<titleSlug>[^\/]+)\/(?<productId>\w+)/.exec(window.location.pathname);
+                if (!matches?.groups) {
+                    return;
+                }
+
+                const titleSlug = matches.groups.titleSlug.replaceAll('\%' + '7C', '-');
+                const productId = matches.groups.productId;
+                AppInterface.downloadWallpapers(titleSlug, productId);
+            } catch (e) {}
+        },
+    });
+
+    private static injectTimeoutId: number | null = null;
+
+    static injectButtons() {
+        if (!AppInterface) {
+            return;
+        }
+
+        ProductDetailsPage.injectTimeoutId && clearTimeout(ProductDetailsPage.injectTimeoutId);
+        ProductDetailsPage.injectTimeoutId = window.setTimeout(() => {
+            // Find action buttons container
+            const $container = document.querySelector('div[class*=ActionButtons-module__container]');
+            if ($container && $container.parentElement) {
+                $container.parentElement.appendChild(CE('div', {
+                    class: 'bx-product-details-buttons',
+                },
+                    BX_FLAGS.DeviceInfo.deviceType === 'android' && ProductDetailsPage.$btnShortcut,
+                    ProductDetailsPage.$btnWallpaper,
+                ));
+            }
+        }, 500);
+    }
+}

src/modules/ui/ui.ts

@@ -1,20 +1,4 @@
-import { AppInterface, STATES } from "@utils/global";
+import { CE } from "@utils/html";
-import { CE, createButton, ButtonStyle, createSvgIcon } from "@utils/html";
-import { BxIcon } from "@utils/bx-icon";
-import { BxEvent } from "@utils/bx-event";
-import { MkbRemapper } from "@modules/mkb/mkb-remapper";
-import { getPref, Preferences, PrefKey, setPref, toPrefElement } from "@utils/preferences";
-import { StreamStats } from "@modules/stream/stream-stats";
-import { TouchController } from "@modules/touch-controller";
-import { t } from "@utils/translation";
-import { VibrationManager } from "@modules/vibration-manager";
-import { Screenshot } from "@/utils/screenshot";
-import { ControllerShortcut } from "../controller-shortcut";
-import { SoundShortcut } from "../shortcuts/shortcut-sound";
-import { NativeMkbHandler } from "../mkb/native-mkb-handler";
-import { UserAgent } from "@/utils/user-agent";
-import type { StreamPlayerOptions } from "../stream-player";
-import { StreamPlayerType, StreamVideoProcessing } from "@enums/stream-player";
 
 
 export function localRedirect(path: string) {
@@ -27,7 +11,7 @@ export function localRedirect(path: string) {
 
     const $anchor = CE<HTMLAnchorElement>('a', {
             href: url,
-            class: 'bx-hidden bx-offscreen'
+            class: 'bx-hidden bx-offscreen',
         }, '');
     $anchor.addEventListener('click', e => {
         // Remove element after clicking on it
@@ -40,451 +24,4 @@ export function localRedirect(path: string) {
     $anchor.click();
 }
 
-function setupStreamSettingsDialog() {
+(window as any).localRedirect = localRedirect;
-    const SETTINGS_UI = [
-        {
-            icon: BxIcon.DISPLAY,
-            group: 'stream',
-            items: [
-                {
-                    group: 'audio',
-                    label: t('audio'),
-                    help_url: 'https://better-xcloud.github.io/ingame-features/#audio',
-                    items: [
-                        {
-                            pref: PrefKey.AUDIO_VOLUME,
-                            onChange: (e: any, value: number) => {
-                                SoundShortcut.setGainNodeVolume(value);
-                            },
-                            params: {
-                                disabled: !getPref(PrefKey.AUDIO_ENABLE_VOLUME_CONTROL),
-                            },
-                            onMounted: ($elm: HTMLElement) => {
-                                const $range = $elm.querySelector('input[type=range') as HTMLInputElement;
-                                window.addEventListener(BxEvent.GAINNODE_VOLUME_CHANGED, e => {
-                                    $range.value = (e as any).volume;
-                                    BxEvent.dispatch($range, 'input', {
-                                            ignoreOnChange: true,
-                                        });
-                                });
-                            },
-                        },
-                    ],
-                },
-
-                {
-                    group: 'video',
-                    label: t('video'),
-                    help_url: 'https://better-xcloud.github.io/ingame-features/#video',
-                    items: [
-                        {
-                            pref: PrefKey.VIDEO_PLAYER_TYPE,
-                            onChange: onChangeVideoPlayerType,
-                        },
-
-                        {
-                            pref: PrefKey.VIDEO_RATIO,
-                            onChange: updateVideoPlayer,
-                        },
-
-                        {
-                            pref: PrefKey.VIDEO_PROCESSING,
-                            onChange: updateVideoPlayer,
-                        },
-
-                        {
-                            pref: PrefKey.VIDEO_SHARPNESS,
-                            onChange: updateVideoPlayer,
-                        },
-
-                        {
-                            pref: PrefKey.VIDEO_SATURATION,
-                            onChange: updateVideoPlayer,
-                        },
-
-                        {
-                            pref: PrefKey.VIDEO_CONTRAST,
-                            onChange: updateVideoPlayer,
-                        },
-
-                        {
-                            pref: PrefKey.VIDEO_BRIGHTNESS,
-                            onChange: updateVideoPlayer,
-                        },
-                    ],
-                },
-            ],
-        },
-
-        {
-            icon: BxIcon.CONTROLLER,
-            group: 'controller',
-            items: [
-                {
-                    group: 'controller',
-                    label: t('controller'),
-                    help_url: 'https://better-xcloud.github.io/ingame-features/#controller',
-                    items: [
-                        {
-                            pref: PrefKey.CONTROLLER_ENABLE_VIBRATION,
-                            unsupported: !VibrationManager.supportControllerVibration(),
-                            onChange: VibrationManager.updateGlobalVars,
-                        },
-
-                        {
-                            pref: PrefKey.CONTROLLER_DEVICE_VIBRATION,
-                            unsupported: !VibrationManager.supportDeviceVibration(),
-                            onChange: VibrationManager.updateGlobalVars,
-                        },
-
-                        (VibrationManager.supportControllerVibration() || VibrationManager.supportDeviceVibration()) && {
-                            pref: PrefKey.CONTROLLER_VIBRATION_INTENSITY,
-                            unsupported: !VibrationManager.supportDeviceVibration(),
-                            onChange: VibrationManager.updateGlobalVars,
-                        },
-                    ],
-                },
-
-                STATES.userAgentHasTouchSupport && {
-                    group: 'touch-controller',
-                    label: t('touch-controller'),
-                    items: [
-                        {
-                            label: t('layout'),
-                            content: CE('select', {disabled: true}, CE('option', {}, t('default'))),
-                            onMounted: ($elm: HTMLSelectElement) => {
-                                $elm.addEventListener('change', e => {
-                                    TouchController.loadCustomLayout(STATES.currentStream?.xboxTitleId!, $elm.value, 1000);
-                                });
-
-                                window.addEventListener(BxEvent.CUSTOM_TOUCH_LAYOUTS_LOADED, e => {
-                                    const data = (e as any).data;
-
-                                    if (STATES.currentStream?.xboxTitleId && ($elm as any).xboxTitleId === STATES.currentStream?.xboxTitleId) {
-                                        $elm.dispatchEvent(new Event('change'));
-                                        return;
-                                    }
-
-                                    ($elm as any).xboxTitleId = STATES.currentStream?.xboxTitleId;
-
-                                    // Clear options
-                                    while ($elm.firstChild) {
-                                        $elm.removeChild($elm.firstChild);
-                                    }
-
-                                    $elm.disabled = !data;
-                                    if (!data) {
-                                        $elm.appendChild(CE('option', {value: ''}, t('default')));
-                                        $elm.value = '';
-                                        $elm.dispatchEvent(new Event('change'));
-                                        return;
-                                    }
-
-                                    // Add options
-                                    const $fragment = document.createDocumentFragment();
-                                    for (const key in data.layouts) {
-                                        const layout = data.layouts[key];
-
-                                        let name;
-                                        if (layout.author) {
-                                            name = `${layout.name} (${layout.author})`;
-                                        } else {
-                                            name = layout.name;
-                                        }
-
-                                        const $option = CE('option', {value: key}, name);
-                                        $fragment.appendChild($option);
-                                    }
-
-                                    $elm.appendChild($fragment);
-                                    $elm.value = data.default_layout;
-                                    $elm.dispatchEvent(new Event('change'));
-                                });
-                            },
-                        },
-                    ],
-                }
-            ],
-        },
-
-        getPref(PrefKey.MKB_ENABLED) && {
-            icon: BxIcon.VIRTUAL_CONTROLLER,
-            group: 'mkb',
-            items: [
-                {
-                    group: 'mkb',
-                    label: t('virtual-controller'),
-                    help_url: 'https://better-xcloud.github.io/mouse-and-keyboard/',
-                    content: MkbRemapper.INSTANCE.render(),
-                },
-            ],
-        },
-
-        AppInterface && getPref(PrefKey.NATIVE_MKB_ENABLED) === 'on' && {
-            icon: BxIcon.NATIVE_MKB,
-            group: 'native-mkb',
-            items: [
-                {
-                    group: 'native-mkb',
-                    label: t('native-mkb'),
-                    items: [
-                        {
-                            pref: PrefKey.NATIVE_MKB_SCROLL_VERTICAL_SENSITIVITY,
-                            onChange: (e: any, value: number) => {
-                                NativeMkbHandler.getInstance().setVerticalScrollMultiplier(value / 100);
-                            },
-                        },
-                        {
-                            pref: PrefKey.NATIVE_MKB_SCROLL_HORIZONTAL_SENSITIVITY,
-                            onChange: (e: any, value: number) => {
-                                NativeMkbHandler.getInstance().setHorizontalScrollMultiplier(value / 100);
-                            },
-                        },
-                    ],
-                },
-            ],
-        },
-
-        {
-            icon: BxIcon.COMMAND,
-            group: 'shortcuts',
-            items: [
-                {
-                    group: 'shortcuts_controller',
-                    label: t('controller-shortcuts'),
-                    content: ControllerShortcut.renderSettings(),
-                },
-            ],
-        },
-
-        {
-            icon: BxIcon.STREAM_STATS,
-            group: 'stats',
-            items: [
-                {
-                    group: 'stats',
-                    label: t('stream-stats'),
-                    help_url: 'https://better-xcloud.github.io/stream-stats/',
-                    items: [
-                        {
-                            pref: PrefKey.STATS_SHOW_WHEN_PLAYING,
-                        },
-                        {
-                            pref: PrefKey.STATS_QUICK_GLANCE,
-                            onChange: (e: InputEvent) => {
-                                const streamStats = StreamStats.getInstance();
-                                (e.target! as HTMLInputElement).checked ? streamStats.quickGlanceSetup() : streamStats.quickGlanceStop();
-                            },
-                        },
-                        {
-                            pref: PrefKey.STATS_ITEMS,
-                            onChange: StreamStats.refreshStyles,
-                        },
-                        {
-                            pref: PrefKey.STATS_POSITION,
-                            onChange: StreamStats.refreshStyles,
-                        },
-                        {
-                            pref: PrefKey.STATS_TEXT_SIZE,
-                            onChange: StreamStats.refreshStyles,
-                        },
-                        {
-                            pref: PrefKey.STATS_OPACITY,
-                            onChange: StreamStats.refreshStyles,
-                        },
-                        {
-                            pref: PrefKey.STATS_TRANSPARENT,
-                            onChange: StreamStats.refreshStyles,
-                        },
-                        {
-                            pref: PrefKey.STATS_CONDITIONAL_FORMATTING,
-                            onChange: StreamStats.refreshStyles,
-                        },
-                    ],
-                },
-            ],
-        },
-    ];
-
-    let $tabs: HTMLElement;
-    let $settings: HTMLElement;
-
-    const $wrapper = CE<HTMLElement>('div', {'class': 'bx-stream-settings-dialog bx-gone'},
-            $tabs = CE<HTMLElement>('div', {'class': 'bx-stream-settings-tabs'}),
-            $settings = CE<HTMLElement>('div', {'class': 'bx-stream-settings-tab-contents'}),
-        );
-
-    for (const settingTab of SETTINGS_UI) {
-        if (!settingTab) {
-            continue;
-        }
-
-        const $svg = createSvgIcon(settingTab.icon);
-        $svg.addEventListener('click', e => {
-            // Switch tab
-            for (const $child of Array.from($settings.children)) {
-                if ($child.getAttribute('data-group') === settingTab.group) {
-                    $child.classList.remove('bx-gone');
-                } else {
-                    $child.classList.add('bx-gone');
-                }
-            }
-
-            // Highlight current tab button
-            for (const $child of Array.from($tabs.children)) {
-                $child.classList.remove('bx-active');
-            }
-
-            $svg.classList.add('bx-active');
-        });
-
-        $tabs.appendChild($svg);
-
-        const $group = CE<HTMLElement>('div', {'data-group': settingTab.group, 'class': 'bx-gone'});
-
-        for (const settingGroup of settingTab.items) {
-            if (!settingGroup) {
-                continue;
-            }
-
-            $group.appendChild(CE('h2', {},
-                    CE('span', {}, settingGroup.label),
-                    settingGroup.help_url && createButton({
-                            icon: BxIcon.QUESTION,
-                            style: ButtonStyle.GHOST,
-                            url: settingGroup.help_url,
-                            title: t('help'),
-                        }),
-                ));
-            if (settingGroup.note) {
-                if (typeof settingGroup.note === 'string') {
-                    settingGroup.note = document.createTextNode(settingGroup.note);
-                }
-                $group.appendChild(settingGroup.note);
-            }
-
-            if (settingGroup.content) {
-                $group.appendChild(settingGroup.content);
-                continue;
-            }
-
-            if (!settingGroup.items) {
-                settingGroup.items = [];
-            }
-
-            for (const setting of settingGroup.items) {
-                if (!setting) {
-                    continue;
-                }
-
-                const pref = setting.pref;
-
-                let $control;
-                if (setting.content) {
-                    $control = setting.content;
-                } else if (!setting.unsupported) {
-                    $control = toPrefElement(pref, setting.onChange, setting.params);
-                }
-
-                const label = Preferences.SETTINGS[pref as PrefKey]?.label || setting.label;
-                const note = Preferences.SETTINGS[pref as PrefKey]?.note || setting.note;
-
-                const $content = CE('div', {'class': 'bx-stream-settings-row', 'data-type': settingGroup.group},
-                    CE('label', {for: `bx_setting_${pref}`},
-                        label,
-                        note && CE('div', {'class': 'bx-stream-settings-dialog-note'}, note),
-                        setting.unsupported && CE('div', {'class': 'bx-stream-settings-dialog-note'}, t('browser-unsupported-feature')),
-                    ),
-                    !setting.unsupported && $control,
-                );
-
-                $group.appendChild($content);
-
-                setting.onMounted && setting.onMounted($control);
-            }
-        }
-
-        $settings.appendChild($group);
-    }
-
-    // Select first tab
-    $tabs.firstElementChild!.dispatchEvent(new Event('click'));
-
-    document.documentElement.appendChild($wrapper);
-}
-
-
-function onChangeVideoPlayerType() {
-    const playerType = getPref(PrefKey.VIDEO_PLAYER_TYPE);
-    const $videoProcessing = document.getElementById('bx_setting_video_processing') as HTMLSelectElement;
-    const $videoSharpness = document.getElementById('bx_setting_video_sharpness') as HTMLElement;
-
-    let isDisabled = false;
-
-    if (playerType === StreamPlayerType.WEBGL2) {
-        ($videoProcessing.querySelector(`option[value=${StreamVideoProcessing.CAS}]`) as HTMLOptionElement).disabled = false;
-    } else {
-        // Only allow USM when player type is Video
-        $videoProcessing.value = StreamVideoProcessing.USM;
-        setPref(PrefKey.VIDEO_PROCESSING, StreamVideoProcessing.USM);
-
-        ($videoProcessing.querySelector(`option[value=${StreamVideoProcessing.CAS}]`) as HTMLOptionElement).disabled = true;
-
-        if (UserAgent.isSafari()) {
-            isDisabled = true;
-        }
-    }
-
-    $videoProcessing.disabled = isDisabled;
-    $videoSharpness.dataset.disabled = isDisabled.toString();
-
-    updateVideoPlayer();
-}
-
-
-export function updateVideoPlayer() {
-    const streamPlayer = STATES.currentStream.streamPlayer;
-    if (!streamPlayer) {
-        return;
-    }
-
-    const options = {
-        processing: getPref(PrefKey.VIDEO_PROCESSING),
-        sharpness: getPref(PrefKey.VIDEO_SHARPNESS),
-        saturation: getPref(PrefKey.VIDEO_SATURATION),
-        contrast: getPref(PrefKey.VIDEO_CONTRAST),
-        brightness: getPref(PrefKey.VIDEO_BRIGHTNESS),
-    } satisfies StreamPlayerOptions;
-
-    streamPlayer.setPlayerType(getPref(PrefKey.VIDEO_PLAYER_TYPE));
-    streamPlayer.updateOptions(options);
-    streamPlayer.refreshPlayer();
-}
-
-
-function preloadFonts() {
-    const $link = CE<HTMLLinkElement>('link', {
-            rel: 'preload',
-            href: 'https://redphx.github.io/better-xcloud/fonts/promptfont.otf',
-            as: 'font',
-            type: 'font/otf',
-            crossorigin: '',
-        });
-
-    document.querySelector('head')?.appendChild($link);
-}
-
-
-export function setupStreamUi() {
-    // Prevent initializing multiple times
-    if (!document.querySelector('.bx-stream-settings-dialog')) {
-        preloadFonts();
-
-        window.addEventListener('resize', updateVideoPlayer);
-        setupStreamSettingsDialog();
-
-        Screenshot.setup();
-    }
-
-    onChangeVideoPlayerType();
-}

src/modules/vibration-manager.ts

@@ -1,6 +1,7 @@
 import { AppInterface } from "@utils/global";
 import { BxEvent } from "@utils/bx-event";
-import { PrefKey, getPref } from "@utils/preferences";
+import { PrefKey } from "@/enums/pref-keys";
+import { ControllerDeviceVibration, getPref } from "@/utils/settings-storages/global-settings-storage";
 
 const VIBRATION_DATA_MAP = {
     'gamepadIndex': 8,
@@ -53,7 +54,7 @@ export class VibrationManager {
         return !!window.navigator.vibrate;
     }
 
-    static updateGlobalVars() {
+    static updateGlobalVars(stopVibration: boolean = true) {
         window.BX_ENABLE_CONTROLLER_VIBRATION = VibrationManager.supportControllerVibration() ? getPref(PrefKey.CONTROLLER_ENABLE_VIBRATION) : false;
         window.BX_VIBRATION_INTENSITY = getPref(PrefKey.CONTROLLER_VIBRATION_INTENSITY) / 100;
 
@@ -63,14 +64,14 @@ export class VibrationManager {
         }
 
         // Stop vibration
-        window.navigator.vibrate(0);
+        stopVibration && window.navigator.vibrate(0);
 
         const value = getPref(PrefKey.CONTROLLER_DEVICE_VIBRATION);
         let enabled;
 
-        if (value === 'on') {
+        if (value === ControllerDeviceVibration.ON) {
             enabled = true;
-        } else if (value === 'auto') {
+        } else if (value === ControllerDeviceVibration.AUTO) {
             enabled = true;
             const gamepads = window.navigator.getGamepads();
             for (const gamepad of gamepads) {
@@ -134,10 +135,10 @@ export class VibrationManager {
     }
 
     static initialSetup() {
-        window.addEventListener('gamepadconnected', VibrationManager.updateGlobalVars);
+        window.addEventListener('gamepadconnected', e => VibrationManager.updateGlobalVars());
-        window.addEventListener('gamepaddisconnected', VibrationManager.updateGlobalVars);
+        window.addEventListener('gamepaddisconnected', e => VibrationManager.updateGlobalVars());
 
-        VibrationManager.updateGlobalVars();
+        VibrationManager.updateGlobalVars(false);
 
         window.addEventListener(BxEvent.DATA_CHANNEL_CREATED, e => {
             const dataChannel = (e as any).dataChannel;

src/types/index.d.ts

@@ -1,7 +1,9 @@
+type BuildVariant = 'full' | 'lite';
+
 // Get type of an array's element
 type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
 
-type PartialRecord<K extends keyof any, T> = Partial<Record<K, T>>
+type PartialRecord<K extends keyof any, T> = Partial<Record<K, T>>;
 
 interface Window {
     AppInterface: any;
@@ -24,18 +26,34 @@ interface NavigatorBattery extends Navigator {
 }
 
 type BxStates = {
+    supportedRegion: boolean;
+    serverRegions: any;
+    selectedRegion: any;
+    gsToken: string;
+    isSignedIn: boolean;
+
     isPlaying: boolean;
     appContext: any | null;
-    serverRegions: any;
 
-    userAgentHasTouchSupport: boolean;
+    browser: {
-    browserHasTouchSupport: boolean;
+        capabilities: {
+            touch: boolean;
+            batteryApi: boolean;
+        };
+    };
+
+    userAgent: {
+        isTv: boolean;
+        capabilities: {
+            touch: boolean;
+            mkb: boolean;
+        };
+    };
 
     currentStream: Partial<{
-        titleId: string;
+        titleSlug: string;
-        xboxTitleId: string;
-        productId: string;
         titleInfo: XcloudTitleInfo;
+        xboxTitleId: number;
 
         streamPlayer: StreamPlayer | null;
 
@@ -50,16 +68,18 @@ type BxStates = {
         config: {
             serverId: string;
         };
+        titleId?: string;
     }>;
 
     pointerServerPort: number;
 }
 
-type DualEnum = {[index: string]: number} & {[index: number]: string};
-
 type XcloudTitleInfo = {
+    titleId: string,
+
     details: {
         productId: string;
+        xboxTitleId: number;
         supportedInputTypes: InputType[];
         supportedTabs: any[];
         hasNativeTouchSupport: boolean;
@@ -69,12 +89,19 @@ type XcloudTitleInfo = {
     };
 
     product: {
+        title: string;
         heroImageUrl: string;
         titledHeroImageUrl: string;
         tileImageUrl: string;
     };
 };
 
+type XcloudWaitTimeInfo = Partial<{
+    estimatedAllocationTimeInSeconds: number,
+    estimatedProvisioningTimeInSeconds: number,
+    estimatedTotalWaitTimeInSeconds: number,
+}>;
+
 declare module '*.js';
 declare module '*.svg';
 declare module '*.styl';
@@ -97,3 +124,42 @@ type MkbMouseWheel = {
     vertical: number;
     horizontal: number;
 }
+
+type XboxAchievement = {
+    version: number;
+    id: string;
+    name: string;
+    gamerscore: number;
+    isSecret: boolean;
+    isUnlocked: boolean;
+    description: {
+        locked: string;
+        unlocked: string;
+    };
+
+    imageUrl: string,
+    requirements: Array<{
+        current: number;
+        target: number;
+        percentComplete: number;
+    }>;
+
+    percentComplete: 0,
+    rarity: {
+        currentCategory: string;
+        currentPercentage: number;
+    };
+
+    rewards: Array<{
+        value: number;
+        valueType: string;
+        type: string;
+    }>;
+
+    title: {
+        id: string;
+        scid: string;
+        productId: string;
+        name: string;
+    }
+};

src/types/network.ts

@@ -0,0 +1,3 @@
+export type RemotePlayConsoleAddresses = {
+    [key: string]: number[],
+}

src/types/preferences.d.ts

@@ -1,8 +1,10 @@
 export type PreferenceSetting = {
     default: any;
+    optionsGroup?: string;
     options?: {[index: string]: string};
     multipleOptions?: {[index: string]: string};
-    unsupported?: string | boolean;
+    unsupported?: boolean;
+    unsupported_note?: string | HTMLElement;
     note?: string | HTMLElement;
     type?: SettingElementType;
     ready?: (setting: PreferenceSetting) => void;

src/types/setting-definition.d.ts

@@ -0,0 +1,62 @@
+import type { PrefKey } from "@/enums/pref-keys";
+import type { SettingElementType } from "@/utils/setting-element";
+
+export type SuggestedSettingCategory = 'recommended' | 'lowest' | 'highest' | 'default';
+export type RecommendedSettings = {
+    schema_version: 1,
+    device_name: string,
+    device_type: 'android' | 'android-tv' | 'android-handheld' | 'webos',
+    settings: {
+        app: any,
+        script: {
+            _base?: 'lowest' | 'highest',
+        } & PartialRecord<PrefKey, any>,
+    },
+};
+
+export type SettingDefinition = {
+    default: any;
+} & Partial<{
+    label: string;
+    note: string | HTMLElement;
+    experimental: boolean;
+    unsupported: boolean;
+    unsupportedNote: string | HTMLElement;
+    suggest: PartialRecord<SuggestedSettingCategory, any>,
+    ready: (setting: SettingDefinition) => void;
+    type: SettingElementType,
+    requiredVariants: BuildVariant | Array<BuildVariant>;
+    // migrate?: (this: Preferences, savedPrefs: any, value: any) => void;
+}> & (
+    {} | {
+        options: {[index: string]: string};
+        optionsGroup?: string;
+    } | {
+        multipleOptions: {[index: string]: string};
+        params: MultipleOptionsParams;
+    } | {
+        type: SettingElementType.NUMBER_STEPPER;
+        min: number;
+        max: number;
+        params: NumberStepperParams;
+
+        steps?: number;
+    }
+);
+
+export type SettingDefinitions = {[index in PrefKey]: SettingDefinition};
+
+export type MultipleOptionsParams = Partial<{
+    size?: number;
+}>
+
+export type NumberStepperParams = Partial<{
+    suffix: string;
+    disabled: boolean;
+    hideSlider: boolean;
+
+    ticks: number;
+    exactTicks: number;
+
+    customTextValue: (value: any) => string | null;
+}>

src/types/stream-stats.d.ts

@@ -3,6 +3,8 @@ type RTCBasicStat = {
     bytesReceived: number,
     clockRate: number,
     codecId: string,
+    frameWidth: number,
+    frameHeight: number,
     framesDecoded: number,
     id: string,
     kind: string,

src/utils/bx-event.ts

@@ -1,58 +1,68 @@
 import { AppInterface } from "@utils/global";
+import { BxLogger } from "./bx-logger";
+import { BX_FLAGS } from "./bx-flags";
 
-export enum BxEvent {
-    JUMP_BACK_IN_READY = 'bx-jump-back-in-ready',
-    POPSTATE = 'bx-popstate',
-
-    TITLE_INFO_READY = 'bx-title-info-ready',
-
-    STREAM_LOADING = 'bx-stream-loading',
-    STREAM_STARTING = 'bx-stream-starting',
-    STREAM_STARTED = 'bx-stream-started',
-    STREAM_PLAYING = 'bx-stream-playing',
-    STREAM_STOPPED = 'bx-stream-stopped',
-    STREAM_ERROR_PAGE = 'bx-stream-error-page',
-
-    STREAM_WEBRTC_CONNECTED = 'bx-stream-webrtc-connected',
-    STREAM_WEBRTC_DISCONNECTED = 'bx-stream-webrtc-disconnected',
-
-    // STREAM_EVENT_TARGET_READY = 'bx-stream-event-target-ready',
-    STREAM_SESSION_READY = 'bx-stream-session-ready',
-
-    CUSTOM_TOUCH_LAYOUTS_LOADED = 'bx-custom-touch-layouts-loaded',
-    TOUCH_LAYOUT_MANAGER_READY = 'bx-touch-layout-manager-ready',
-
-    REMOTE_PLAY_READY = 'bx-remote-play-ready',
-    REMOTE_PLAY_FAILED = 'bx-remote-play-failed',
-
-    XCLOUD_SERVERS_READY = 'bx-servers-ready',
-
-    DATA_CHANNEL_CREATED = 'bx-data-channel-created',
-
-    GAME_BAR_ACTION_ACTIVATED = 'bx-game-bar-action-activated',
-    MICROPHONE_STATE_CHANGED = 'bx-microphone-state-changed',
-
-    CAPTURE_SCREENSHOT = 'bx-capture-screenshot',
-    GAINNODE_VOLUME_CHANGED = 'bx-gainnode-volume-changed',
-
-    POINTER_LOCK_REQUESTED = 'bx-pointer-lock-requested',
-    POINTER_LOCK_EXITED = 'bx-pointer-lock-exited',
-
-    // xCloud Dialog events
-    XCLOUD_DIALOG_SHOWN = 'bx-xcloud-dialog-shown',
-    XCLOUD_DIALOG_DISMISSED = 'bx-xcloud-dialog-dismissed',
-
-    XCLOUD_GUIDE_MENU_SHOWN = 'bx-xcloud-guide-menu-shown',
-
-    XCLOUD_POLLING_MODE_CHANGED = 'bx-xcloud-polling-mode-changed',
-}
-
-export enum XcloudEvent {
-    MICROPHONE_STATE_CHANGED = 'microphoneStateChanged',
-}
 
 export namespace BxEvent {
-    export function dispatch(target: HTMLElement | Window, eventName: string, data?: any) {
+    export const JUMP_BACK_IN_READY = 'bx-jump-back-in-ready';
+    export const POPSTATE = 'bx-popstate';
+
+    export const TITLE_INFO_READY = 'bx-title-info-ready';
+
+    export const SETTINGS_CHANGED = 'bx-settings-changed';
+
+    export const STREAM_LOADING = 'bx-stream-loading';
+    export const STREAM_STARTING = 'bx-stream-starting';
+    export const STREAM_STARTED = 'bx-stream-started';
+    export const STREAM_PLAYING = 'bx-stream-playing';
+    export const STREAM_STOPPED = 'bx-stream-stopped';
+    export const STREAM_ERROR_PAGE = 'bx-stream-error-page';
+
+    export const STREAM_WEBRTC_CONNECTED = 'bx-stream-webrtc-connected';
+    export const STREAM_WEBRTC_DISCONNECTED = 'bx-stream-webrtc-disconnected';
+
+    // export const STREAM_EVENT_TARGET_READY = 'bx-stream-event-target-ready';
+    export const STREAM_SESSION_READY = 'bx-stream-session-ready';
+
+    export const CUSTOM_TOUCH_LAYOUTS_LOADED = 'bx-custom-touch-layouts-loaded';
+    export const TOUCH_LAYOUT_MANAGER_READY = 'bx-touch-layout-manager-ready';
+
+    export const REMOTE_PLAY_READY = 'bx-remote-play-ready';
+    export const REMOTE_PLAY_FAILED = 'bx-remote-play-failed';
+
+    export const XCLOUD_SERVERS_READY = 'bx-servers-ready';
+    export const XCLOUD_SERVERS_UNAVAILABLE = 'bx-servers-unavailable';
+
+    export const DATA_CHANNEL_CREATED = 'bx-data-channel-created';
+
+    export const GAME_BAR_ACTION_ACTIVATED = 'bx-game-bar-action-activated';
+    export const MICROPHONE_STATE_CHANGED = 'bx-microphone-state-changed';
+    export const SPEAKER_STATE_CHANGED = 'bx-speaker-state-changed';
+
+    export const CAPTURE_SCREENSHOT = 'bx-capture-screenshot';
+
+    export const POINTER_LOCK_REQUESTED = 'bx-pointer-lock-requested';
+    export const POINTER_LOCK_EXITED = 'bx-pointer-lock-exited';
+
+    export const NAVIGATION_FOCUS_CHANGED = 'bx-nav-focus-changed';
+
+    // xCloud Dialog events
+    export const XCLOUD_DIALOG_SHOWN = 'bx-xcloud-dialog-shown';
+    export const XCLOUD_DIALOG_DISMISSED = 'bx-xcloud-dialog-dismissed';
+
+    export const XCLOUD_GUIDE_MENU_SHOWN = 'bx-xcloud-guide-menu-shown';
+
+    export const XCLOUD_POLLING_MODE_CHANGED = 'bx-xcloud-polling-mode-changed';
+
+    export const XCLOUD_RENDERING_COMPONENT = 'bx-xcloud-rendering-component';
+
+    export const XCLOUD_ROUTER_HISTORY_READY = 'bx-xcloud-router-history-ready';
+
+    export function dispatch(target: Element | Window | null, eventName: string, data?: any) {
+        if (!target) {
+            return;
+        }
+
         if (!eventName) {
             alert('BxEvent.dispatch(): eventName is null');
             return;
@@ -68,6 +78,8 @@ export namespace BxEvent {
 
         target.dispatchEvent(event);
         AppInterface && AppInterface.onEvent(eventName);
+
+        BX_FLAGS.Debug && BxLogger.warning('BxEvent', 'dispatch', eventName, data)
     }
 }
 

src/utils/bx-exposed.ts

@@ -1,44 +1,49 @@
+import { isFullVersion } from "@macros/build" with {type: "macro"};
+
 import { ControllerShortcut } from "@/modules/controller-shortcut";
 import { BxEvent } from "@utils/bx-event";
-import { STATES } from "@utils/global";
+import { deepClone, STATES } from "@utils/global";
-import { getPref, PrefKey } from "@utils/preferences";
 import { BxLogger } from "./bx-logger";
 import { BX_FLAGS } from "./bx-flags";
+import { NavigationDialogManager } from "@/modules/ui/dialog/navigation-dialog";
+import { PrefKey } from "@/enums/pref-keys";
+import { getPref, StreamTouchController } from "./settings-storages/global-settings-storage";
 
-export enum InputType {
+export enum SupportedInputType {
     CONTROLLER = 'Controller',
     MKB = 'MKB',
     CUSTOM_TOUCH_OVERLAY = 'CustomTouchOverlay',
     GENERIC_TOUCH = 'GenericTouch',
     NATIVE_TOUCH = 'NativeTouch',
     BATIVE_SENSOR = 'NativeSensor',
-}
+};
+export type SupportedInputTypeValue = (typeof SupportedInputType)[keyof typeof SupportedInputType];
 
 export const BxExposed = {
     getTitleInfo: () => STATES.currentStream.titleInfo,
 
-    modifyTitleInfo: (titleInfo: XcloudTitleInfo): XcloudTitleInfo => {
+    modifyTitleInfo: isFullVersion() && function(titleInfo: XcloudTitleInfo): XcloudTitleInfo {
         // Clone the object since the original is read-only
-        titleInfo = structuredClone(titleInfo);
+        titleInfo = deepClone(titleInfo);
 
         let supportedInputTypes = titleInfo.details.supportedInputTypes;
 
         if (BX_FLAGS.ForceNativeMkbTitles?.includes(titleInfo.details.productId)) {
-            supportedInputTypes.push(InputType.MKB);
+            supportedInputTypes.push(SupportedInputType.MKB);
         }
 
         // Remove native MKB support on mobile browsers or by user's choice
         if (getPref(PrefKey.NATIVE_MKB_ENABLED) === 'off') {
-            supportedInputTypes = supportedInputTypes.filter(i => i !== InputType.MKB);
+            supportedInputTypes = supportedInputTypes.filter(i => i !== SupportedInputType.MKB);
         }
 
-        titleInfo.details.hasMkbSupport = supportedInputTypes.includes(InputType.MKB);
+        titleInfo.details.hasMkbSupport = supportedInputTypes.includes(SupportedInputType.MKB);
 
-        if (STATES.userAgentHasTouchSupport) {
+        if (STATES.userAgent.capabilities.touch) {
             let touchControllerAvailability = getPref(PrefKey.STREAM_TOUCH_CONTROLLER);
 
             // Disable touch control when gamepad found
-            if (touchControllerAvailability !== 'off' && getPref(PrefKey.STREAM_TOUCH_CONTROLLER_AUTO_OFF)) {
+            if (touchControllerAvailability !== StreamTouchController.OFF && getPref(PrefKey.STREAM_TOUCH_CONTROLLER_AUTO_OFF)) {
                 const gamepads = window.navigator.getGamepads();
                 let gamepadFound = false;
 
@@ -49,26 +54,26 @@ export const BxExposed = {
                     }
                 }
 
-                gamepadFound && (touchControllerAvailability = 'off');
+                gamepadFound && (touchControllerAvailability = StreamTouchController.OFF);
             }
 
-            if (touchControllerAvailability === 'off') {
+            if (touchControllerAvailability === StreamTouchController.OFF) {
                 // Disable touch on all games (not native touch)
-                supportedInputTypes = supportedInputTypes.filter(i => i !== InputType.CUSTOM_TOUCH_OVERLAY && i !== InputType.GENERIC_TOUCH);
+                supportedInputTypes = supportedInputTypes.filter(i => i !== SupportedInputType.CUSTOM_TOUCH_OVERLAY && i !== SupportedInputType.GENERIC_TOUCH);
                 // Empty TABs
                 titleInfo.details.supportedTabs = [];
             }
 
             // Pre-check supported input types
-            titleInfo.details.hasNativeTouchSupport = supportedInputTypes.includes(InputType.NATIVE_TOUCH);
+            titleInfo.details.hasNativeTouchSupport = supportedInputTypes.includes(SupportedInputType.NATIVE_TOUCH);
             titleInfo.details.hasTouchSupport = titleInfo.details.hasNativeTouchSupport ||
-                    supportedInputTypes.includes(InputType.CUSTOM_TOUCH_OVERLAY) ||
+                    supportedInputTypes.includes(SupportedInputType.CUSTOM_TOUCH_OVERLAY) ||
-                    supportedInputTypes.includes(InputType.GENERIC_TOUCH);
+                    supportedInputTypes.includes(SupportedInputType.GENERIC_TOUCH);
 
-            if (!titleInfo.details.hasTouchSupport && touchControllerAvailability === 'all') {
+            if (!titleInfo.details.hasTouchSupport && touchControllerAvailability === StreamTouchController.ALL) {
                 // Add generic touch support for non touch-supported games
                 titleInfo.details.hasFakeTouchSupport = true;
-                supportedInputTypes.push(InputType.GENERIC_TOUCH);
+                supportedInputTypes.push(SupportedInputType.GENERIC_TOUCH);
             }
         }
 
@@ -107,6 +112,36 @@ export const BxExposed = {
         }
     },
 
-    handleControllerShortcut: ControllerShortcut.handle,
+    handleControllerShortcut: isFullVersion() && ControllerShortcut.handle,
-    resetControllerShortcut: ControllerShortcut.reset,
+    resetControllerShortcut: isFullVersion() && ControllerShortcut.reset,
+
+    overrideSettings: {
+        'Tv_settings': {
+            hasCompletedOnboarding: true,
+        },
+    },
+
+    disableGamepadPolling: false,
+
+    backButtonPressed: () => {
+        const navigationDialogManager = NavigationDialogManager.getInstance();
+        if (navigationDialogManager.isShowing()) {
+            navigationDialogManager.hide();
+            return true;
+        }
+
+        const dict = {
+            bubbles: true,
+            cancelable: true,
+            key: 'XF86Back',
+            code: 'XF86Back',
+            keyCode: 4,
+            which: 4,
+        };
+
+        document.body.dispatchEvent(new KeyboardEvent('keydown', dict));
+        document.body.dispatchEvent(new KeyboardEvent('keyup', dict));
+
+        return false;
+    },
 };

src/utils/bx-flags.ts

@@ -1,28 +1,39 @@
-type BxFlags = Partial<{
+import { BxLogger } from "./bx-logger";
+
+type BxFlags = {
+    Debug: boolean;
+
     CheckForUpdate: boolean;
-    PreloadRemotePlay: boolean;
-    PreloadUi: boolean;
     EnableXcloudLogging: boolean;
     SafariWorkaround: boolean;
 
-    UseDevTouchLayout: boolean;
-
     ForceNativeMkbTitles: string[];
     FeatureGates: {[key: string]: boolean} | null,
-}>
+
+    DeviceInfo: {
+        deviceType: 'android' | 'android-tv' | 'android-handheld' | 'webos' | 'unknown',
+        userAgent?: string,
+
+        androidInfo?: {
+            board: string,
+        },
+    }
+}
 
 // Setup flags
 const DEFAULT_FLAGS: BxFlags = {
+    Debug: false,
+
     CheckForUpdate: true,
-    PreloadRemotePlay: true,
-    PreloadUi: false,
     EnableXcloudLogging: false,
     SafariWorkaround: true,
 
-    UseDevTouchLayout: false,
-
     ForceNativeMkbTitles: [],
     FeatureGates: null,
+
+    DeviceInfo: {
+        deviceType: 'unknown',
+    },
 }
 
 export const BX_FLAGS: BxFlags = Object.assign(DEFAULT_FLAGS, window.BX_FLAGS || {});
@@ -30,4 +41,10 @@ try {
     delete window.BX_FLAGS;
 } catch (e) {}
 
+if (!BX_FLAGS.DeviceInfo.userAgent) {
+    BX_FLAGS.DeviceInfo.userAgent = window.navigator.userAgent;
+}
+
+BxLogger.info('BxFlags', BX_FLAGS);
+
 export const NATIVE_FETCH = window.fetch;

src/utils/bx-icon.ts

@@ -1,19 +1,25 @@
+import iconBetterXcloud from "@assets/svg/better-xcloud.svg" with { type: "text" };
+import iconTrueAchievements from "@assets/svg/true-achievements.svg" with { type: "text" };
+import iconClose from "@assets/svg/close.svg" with { type: "text" };
 import iconCommand from "@assets/svg/command.svg" with { type: "text" };
 import iconController from "@assets/svg/controller.svg" with { type: "text" };
 import iconCopy from "@assets/svg/copy.svg" with { type: "text" };
+import iconCreateShortcut from "@assets/svg/create-shortcut.svg" with { type: "text" };
 import iconCursorText from "@assets/svg/cursor-text.svg" with { type: "text" };
 import iconDisplay from "@assets/svg/display.svg" with { type: "text" };
 import iconHome from "@assets/svg/home.svg" with { type: "text" };
 import iconNativeMkb from "@assets/svg/native-mkb.svg" with { type: "text" };
 import iconNew from "@assets/svg/new.svg" with { type: "text" };
+import iconPower from "@assets/svg/power.svg" with { type: "text" };
 import iconQuestion from "@assets/svg/question.svg" with { type: "text" };
 import iconRefresh from "@assets/svg/refresh.svg" with { type: "text" };
 import iconRemotePlay from "@assets/svg/remote-play.svg" with { type: "text" };
+import iconSpeakerSlash from "@assets/svg/speaker-slash.svg" with { type: "text" };
 import iconStreamSettings from "@assets/svg/stream-settings.svg" with { type: "text" };
 import iconStreamStats from "@assets/svg/stream-stats.svg" with { type: "text" };
-import iconTrash from "@assets/svg/trash.svg" with { type: "text" };
-import iconTouchControlEnable from "@assets/svg/touch-control-enable.svg" with { type: "text" };
 import iconTouchControlDisable from "@assets/svg/touch-control-disable.svg" with { type: "text" };
+import iconTouchControlEnable from "@assets/svg/touch-control-enable.svg" with { type: "text" };
+import iconTrash from "@assets/svg/trash.svg" with { type: "text" };
 import iconVirtualController from "@assets/svg/virtual-controller.svg" with { type: "text" };
 
 // Game Bar
@@ -33,10 +39,14 @@ import iconUpload from "@assets/svg/upload.svg" with { type: "text" };
 
 
 export const BxIcon = {
+    BETTER_XCLOUD: iconBetterXcloud,
+    TRUE_ACHIEVEMENTS: iconTrueAchievements,
     STREAM_SETTINGS: iconStreamSettings,
     STREAM_STATS: iconStreamStats,
+    CLOSE: iconClose,
     COMMAND: iconCommand,
     CONTROLLER: iconController,
+    CREATE_SHORTCUT: iconCreateShortcut,
     DISPLAY: iconDisplay,
     HOME: iconHome,
     NATIVE_MKB: iconNativeMkb,
@@ -44,6 +54,7 @@ export const BxIcon = {
     COPY: iconCopy,
     TRASH: iconTrash,
     CURSOR_TEXT: iconCursorText,
+    POWER: iconPower,
     QUESTION: iconQuestion,
     REFRESH: iconRefresh,
     VIRTUAL_CONTROLLER: iconVirtualController,
@@ -54,6 +65,7 @@ export const BxIcon = {
     CARET_LEFT: iconCaretLeft,
     CARET_RIGHT: iconCaretRight,
     SCREENSHOT: iconCamera,
+    SPEAKER_MUTED: iconSpeakerSlash,
     TOUCH_CONTROL_ENABLE: iconTouchControlEnable,
     TOUCH_CONTROL_DISABLE: iconTouchControlDisable,
 

src/utils/bx-logger.ts

@@ -1,4 +1,4 @@
-enum TextColor {
+const enum TextColor {
     INFO = '#008746',
     WARNING = '#c1a404',
     ERROR = '#c10404',
@@ -19,7 +19,7 @@ export class BxLogger {
         BxLogger.#log(TextColor.ERROR, tag, ...args);
     }
 
-    static #log(color: TextColor, tag: string, ...args: any) {
+    static #log(color: string, tag: string, ...args: any) {
         console.log(`%c${BxLogger.#PREFIX}`, `color:${color};font-weight:bold;`, tag, '//', ...args);
     }
 }

src/utils/css.ts

@@ -1,38 +1,61 @@
 import { CE } from "@utils/html";
-import { PrefKey, getPref } from "@utils/preferences";
+import { compressCss, renderStylus } from "@macros/build" with {type: "macro"};
-import { renderStylus } from "@macros/build" with {type: "macro"};
+import { UiSection } from "@/enums/ui-sections";
+import { PrefKey } from "@/enums/pref-keys";
+import { getPref } from "./settings-storages/global-settings-storage";
 
 
 export function addCss() {
-    let css = renderStylus();
+    const STYLUS_CSS = renderStylus() as unknown as string;
+    let css = STYLUS_CSS;
 
+    const PREF_HIDE_SECTIONS = getPref(PrefKey.UI_HIDE_SECTIONS);
+    const selectorToHide = [];
+
+    // Hide "News" section
+    if (PREF_HIDE_SECTIONS.includes(UiSection.NEWS)) {
+        selectorToHide.push('#BodyContent > div[class*=CarouselRow-module]');
+    }
+
+    // Hide "All games" section
+    if (PREF_HIDE_SECTIONS.includes(UiSection.ALL_GAMES)) {
+        selectorToHide.push('#BodyContent div[class*=AllGamesRow-module__gridContainer]');
+        selectorToHide.push('#BodyContent div[class*=AllGamesRow-module__rowHeader]');
+    }
+
+    // Hide "Most popular" section
+    if (PREF_HIDE_SECTIONS.includes(UiSection.MOST_POPULAR)) {
+        selectorToHide.push('#BodyContent div[class*=HomePage-module__bottomSpacing]:has(a[href="/play/gallery/popular"])');
+    }
+
+    // Hide "Play with touch" section
+    if (PREF_HIDE_SECTIONS.includes(UiSection.TOUCH)) {
+        selectorToHide.push('#BodyContent div[class*=HomePage-module__bottomSpacing]:has(a[href="/play/gallery/touch"])');
+    }
+
+   // Hide "Start a party" button in the Guide menu
     if (getPref(PrefKey.BLOCK_SOCIAL_FEATURES)) {
-        css += `
+        selectorToHide.push('#gamepass-dialog-root div[class^=AchievementsPreview-module__container] + button[class*=HomeLandingPage-module__button]');
-/* Hide "Play with friends" section */
+    }
-div[class^=HomePage-module__bottomSpacing]:has(button[class*=SocialEmptyCard]),
+
-button[class*=SocialEmptyCard],
+    if (selectorToHide) {
-/* Hide "Start a party" button in the Guide menu */
+        css += selectorToHide.join(',') + '{ display: none; }';
-#gamepass-dialog-root div[class^=AchievementsPreview-module__container] + button[class*=HomeLandingPage-module__button]
-{
-    display: none;
-}
-`;
     }
 
     // Reduce animations
     if (getPref(PrefKey.REDUCE_ANIMATIONS)) {
-        css += `
+        css += compressCss(`
 div[class*=GameCard-module__gameTitleInnerWrapper],
 div[class*=GameCard-module__card],
 div[class*=ScrollArrows-module] {
     transition: none !important;
 }
-`;
+`);
     }
 
     // Hide the top-left dots icon while playing
     if (getPref(PrefKey.HIDE_DOTS_ICON)) {
-        css += `
+        css += compressCss(`
 div[class*=Grip-module__container] {
     visibility: hidden;
 }
@@ -54,18 +77,18 @@ button[class*=GripHandle-module__container][aria-expanded=false] {
 div[class*=StreamHUD-module__buttonsContainer] {
     padding: 0px !important;
 }
-`;
+`);
     }
 
-    css += `
+    css += compressCss(`
 div[class*=StreamMenu-module__menu] {
     min-width: 100vw !important;
 }
-`;
+`);
 
     // Simplify Stream's menu
     if (getPref(PrefKey.STREAM_SIMPLIFY_MENU)) {
-        css += `
+        css += compressCss(`
 div[class*=Menu-module__scrollable] {
     --bxStreamMenuItemSize: 80px;
     --streamMenuItemSize: calc(var(--bxStreamMenuItemSize) + 40px) !important;
@@ -96,9 +119,9 @@ svg[class*=MenuItem-module__icon] {
     padding: 0 !important;
     margin: 0 !important;
 }
-`;
+`);
     } else {
-        css += `
+        css += compressCss(`
 body[data-media-type=tv] .bx-badges {
     top: calc(var(--streamMenuItemSize) + 30px);
 }
@@ -120,12 +143,12 @@ body:not([data-media-type=tv]) div[class*=MenuItem-module__label] {
     margin-left: 8px !important;
     margin-right: 8px !important;
 }
-`;
+`);
     }
 
     // Hide scrollbar
     if (getPref(PrefKey.UI_SCROLLBAR_HIDE)) {
-        css += `
+        css += compressCss(`
 html {
     scrollbar-width: none;
 }
@@ -133,9 +156,22 @@ html {
 body::-webkit-scrollbar {
     display: none;
 }
-`;
+`);
     }
 
     const $style = CE('style', {}, css);
     document.documentElement.appendChild($style);
 }
+
+
+export function preloadFonts() {
+    const $link = CE<HTMLLinkElement>('link', {
+            rel: 'preload',
+            href: 'https://redphx.github.io/better-xcloud/fonts/promptfont.otf',
+            as: 'font',
+            type: 'font/otf',
+            crossorigin: '',
+        });
+
+    document.querySelector('head')?.appendChild($link);
+}

src/utils/feature-gates.ts

@@ -1,8 +1,12 @@
+import { PrefKey } from "@/enums/pref-keys";
 import { BX_FLAGS } from "./bx-flags";
-import { getPref, PrefKey } from "./preferences";
+import { getPref } from "./settings-storages/global-settings-storage";
 
 export let FeatureGates: {[key: string]: boolean} = {
     'PwaPrompt': false,
+    'EnableWifiWarnings': false,
+    'EnableUpdateRequiredPage': false,
+    'ShowForcedUpdateScreen': false,
 };
 
 // Disable context menu in Home page

src/utils/gamepad.ts

@@ -1,13 +1,14 @@
-import { EmulatedMkbHandler } from "@modules/mkb/mkb-handler";
+import { VIRTUAL_GAMEPAD_ID } from "@modules/mkb/mkb-handler";
-import { PrefKey, getPref } from "@utils/preferences";
 import { t } from "@utils/translation";
 import { Toast } from "@utils/toast";
 import { BxLogger } from "@utils/bx-logger";
+import { PrefKey } from "@/enums/pref-keys";
+import { getPref } from "./settings-storages/global-settings-storage";
 
 // Show a toast when connecting/disconecting controller
 export function showGamepadToast(gamepad: Gamepad) {
     // Don't show Toast for virtual controller
-    if (gamepad.id === EmulatedMkbHandler.VIRTUAL_GAMEPAD_ID) {
+    if (gamepad.id === VIRTUAL_GAMEPAD_ID) {
         return;
     }
 

src/utils/global.ts

@@ -1,6 +1,8 @@
+import type { BaseSettingsStore } from "./settings-storages/base-settings-storage";
 import { UserAgent } from "./user-agent";
 
 export const SCRIPT_VERSION = Bun.env.SCRIPT_VERSION!;
+export const SCRIPT_VARIANT = Bun.env.BUILD_VARIANT! as BuildVariant;
 
 export const AppInterface = window.AppInterface;
 
@@ -11,16 +13,49 @@ const isTv = userAgent.includes('smart-tv') || userAgent.includes('smarttv') ||
 const isVr = window.navigator.userAgent.includes('VR') && window.navigator.userAgent.includes('OculusBrowser');
 const browserHasTouchSupport = 'ontouchstart' in window || navigator.maxTouchPoints > 0;
 const userAgentHasTouchSupport = !isTv && !isVr && browserHasTouchSupport;
+const supportMkb = AppInterface || !userAgent.match(/(android|iphone|ipad)/);
 
 export const STATES: BxStates = {
+    supportedRegion: true,
+    serverRegions: {},
+    selectedRegion: {},
+    gsToken: '',
+    isSignedIn: false,
+
     isPlaying: false,
     appContext: {},
-    serverRegions: {},
+
-    userAgentHasTouchSupport: userAgentHasTouchSupport,
+    browser: {
-    browserHasTouchSupport: browserHasTouchSupport,
+        capabilities: {
+            touch: browserHasTouchSupport,
+            batteryApi: 'getBattery' in window.navigator,
+        },
+    },
+
+    userAgent: {
+        isTv: isTv,
+        capabilities: {
+            touch: userAgentHasTouchSupport,
+            mkb: supportMkb,
+        }
+    },
 
     currentStream: {},
     remotePlay: {},
 
     pointerServerPort: 9269,
 };
+
+export const STORAGE: {[key: string]: BaseSettingsStore} = {};
+
+export function deepClone(obj: any): any {
+    if ('structuredClone' in window) {
+        return structuredClone(obj);
+    }
+
+    if (!obj) {
+        return {};
+    }
+
+    return JSON.parse(JSON.stringify(obj));
+}

src/utils/history.ts

@@ -1,7 +1,8 @@
 import { BxEvent } from "@utils/bx-event";
 import { LoadingScreen } from "@modules/loading-screen";
-import { RemotePlay } from "@modules/remote-play";
+import { RemotePlayManager } from "@/modules/remote-play-manager";
-import { checkHeader } from "@modules/ui/header";
+import { HeaderSection } from "@/modules/ui/header";
+import { NavigationDialogManager } from "@/modules/ui/dialog/navigation-dialog";
 
 export function patchHistoryMethod(type: 'pushState' | 'replaceState') {
     const orig = window.history[type];
@@ -23,18 +24,19 @@ export function onHistoryChanged(e: PopStateEvent) {
         return;
     }
 
-    window.setTimeout(RemotePlay.detect, 10);
+    window.setTimeout(RemotePlayManager.detect, 10);
 
+    // Hide Global settings
     const $settings = document.querySelector('.bx-settings-container');
     if ($settings) {
         $settings.classList.add('bx-gone');
     }
 
-    // Hide Remote Play popup
+    // Hide Navigation dialog
-    RemotePlay.detachPopup();
+    NavigationDialogManager.getInstance().hide();
 
     LoadingScreen.reset();
-    window.setTimeout(checkHeader, 2000);
+    window.setTimeout(HeaderSection.watchHeader, 2000);
 
     BxEvent.dispatch(window, BxEvent.STREAM_STOPPED);
 }

src/utils/html.ts

@@ -1,7 +1,39 @@
 import type { BxIcon } from "@utils/bx-icon";
+import { setNearby } from "./navigation-utils";
+import type { NavigationNearbyElements } from "@/modules/ui/dialog/navigation-dialog";
 
-type BxButton = {
+export enum ButtonStyle {
-    style?: number | string | ButtonStyle;
+    PRIMARY = 1,
+    DANGER = 2,
+    GHOST = 4,
+    FROSTED = 8,
+    DROP_SHADOW = 16,
+    FOCUSABLE = 32,
+    FULL_WIDTH = 64,
+    FULL_HEIGHT = 128,
+    TALL = 256,
+    CIRCULAR = 512,
+    NORMAL_CASE = 1024,
+    NORMAL_LINK = 2048,
+}
+
+const ButtonStyleClass = {
+    [ButtonStyle.PRIMARY]: 'bx-primary',
+    [ButtonStyle.DANGER]: 'bx-danger',
+    [ButtonStyle.GHOST]: 'bx-ghost',
+    [ButtonStyle.FROSTED]: 'bx-frosted',
+    [ButtonStyle.DROP_SHADOW]: 'bx-drop-shadow',
+    [ButtonStyle.FOCUSABLE]: 'bx-focusable',
+    [ButtonStyle.FULL_WIDTH]: 'bx-full-width',
+    [ButtonStyle.FULL_HEIGHT]: 'bx-full-height',
+    [ButtonStyle.TALL]: 'bx-tall',
+    [ButtonStyle.CIRCULAR]: 'bx-circular',
+    [ButtonStyle.NORMAL_CASE]: 'bx-normal-case',
+    [ButtonStyle.NORMAL_LINK]: 'bx-normal-link',
+}
+
+export type BxButton = {
+    style?: ButtonStyle;
     url?: string;
     classes?: string[];
     icon?: typeof BxIcon;
@@ -9,12 +41,18 @@ type BxButton = {
     title?: string;
     disabled?: boolean;
     onClick?: EventListener;
+    tabIndex?: number;
+    attributes?: {[key: string]: any},
 }
 
-type ButtonStyle = {[index: string]: number} & {[index: number]: string};
-
 // Quickly create a tree of elements without having to use innerHTML
-function createElement<T=HTMLElement>(elmName: string, props: {[index: string]: any}={}, ..._: any): T {
+type CreateElementOptions = {
+    [index: string]: any;
+    _nearby?: NavigationNearbyElements;
+};
+
+
+function createElement<T=HTMLElement>(elmName: string, props: CreateElementOptions={}, ..._: any): T {
     let $elm;
     const hasNs = 'xmlns' in props;
 
@@ -25,6 +63,11 @@ function createElement<T=HTMLElement>(elmName: string, props: {[index: string]:
         $elm = document.createElement(elmName);
     }
 
+    if (props['_nearby']) {
+        setNearby($elm, props['_nearby']);
+        delete props['_nearby'];
+    }
+
     for (const key in props) {
         if ($elm.hasOwnProperty(key)) {
             continue;
@@ -33,18 +76,23 @@ function createElement<T=HTMLElement>(elmName: string, props: {[index: string]:
         if (hasNs) {
             $elm.setAttributeNS(null, key, props[key]);
         } else {
-            $elm.setAttribute(key, props[key]);
+            if (key === 'on') {
+                for (const eventName in props[key]) {
+                    $elm.addEventListener(eventName, props[key][eventName]);
+                }
+            } else {
+                $elm.setAttribute(key, props[key]);
+            }
         }
     }
 
     for (let i = 2, size = arguments.length; i < size; i++) {
         const arg = arguments[i];
-        const argType = typeof arg;
 
-        if (argType === 'string' || argType === 'number') {
+        if (arg instanceof Node) {
-            $elm.appendChild(document.createTextNode(arg));
-        } else if (arg) {
             $elm.appendChild(arg);
+        } else if (arg !== null && arg !== false && typeof arg !== 'undefined') {
+            $elm.appendChild(document.createTextNode(arg));
         }
     }
 
@@ -60,16 +108,7 @@ export const createSvgIcon = (icon: typeof BxIcon) => {
     return svgParser(icon.toString());
 }
 
-export const ButtonStyle: DualEnum = {};
+const ButtonStyleIndices = Object.keys(ButtonStyleClass).map(i => parseInt(i));
-ButtonStyle[ButtonStyle.PRIMARY = 1] = 'bx-primary';
-ButtonStyle[ButtonStyle.DANGER = 2] = 'bx-danger';
-ButtonStyle[ButtonStyle.GHOST = 4] = 'bx-ghost';
-ButtonStyle[ButtonStyle.FOCUSABLE = 8] = 'bx-focusable';
-ButtonStyle[ButtonStyle.FULL_WIDTH = 16] = 'bx-full-width';
-ButtonStyle[ButtonStyle.FULL_HEIGHT = 32] = 'bx-full-height';
-ButtonStyle[ButtonStyle.TALL = 64] = 'bx-tall';
-
-const ButtonStyleIndices = Object.keys(ButtonStyle).splice(0, Object.keys(ButtonStyle).length / 2).map(i => parseInt(i));
 
 export const createButton = <T=HTMLButtonElement>(options: BxButton): T => {
     let $btn;
@@ -82,8 +121,8 @@ export const createButton = <T=HTMLButtonElement>(options: BxButton): T => {
     }
 
     const style = (options.style || 0) as number;
-    style && ButtonStyleIndices.forEach(index => {
+    style && ButtonStyleIndices.forEach((index: keyof typeof ButtonStyleClass) => {
-            (style & index) && $btn.classList.add(ButtonStyle[index] as string);
+            (style & index) && $btn.classList.add(ButtonStyleClass[index] as string);
         });
 
     options.classes && $btn.classList.add(...options.classes);
@@ -93,10 +132,27 @@ export const createButton = <T=HTMLButtonElement>(options: BxButton): T => {
     options.title && $btn.setAttribute('title', options.title);
     options.disabled && (($btn as HTMLButtonElement).disabled = true);
     options.onClick && $btn.addEventListener('click', options.onClick);
+    $btn.tabIndex = typeof options.tabIndex === 'number' ? options.tabIndex : 0;
+
+    for (const key in options.attributes) {
+        if (!$btn.hasOwnProperty(key)) {
+            $btn.setAttribute(key, options.attributes[key]);
+        }
+    }
 
     return $btn as T;
 }
 
+export function getReactProps($elm: HTMLElement): any | null {
+    for (const key in $elm) {
+        if (key.startsWith('__reactProps')) {
+            return ($elm as any)[key];
+        }
+    }
+
+    return null;
+}
+
 export function escapeHtml(html: string): string {
     const text = document.createTextNode(html);
     const $span = document.createElement('span');
@@ -105,5 +161,67 @@ export function escapeHtml(html: string): string {
     return $span.innerHTML;
 }
 
+export function isElementVisible($elm: HTMLElement): boolean {
+    const rect = $elm.getBoundingClientRect();
+    return (rect.x >= 0 || rect.y >= 0) && !!rect.width && !!rect.height;
+}
+
 export const CTN = document.createTextNode.bind(document);
 window.BX_CE = createElement;
+
+export function removeChildElements($parent: HTMLElement) {
+    while ($parent.firstElementChild) {
+        $parent.firstElementChild.remove();
+    }
+}
+
+export function clearFocus() {
+    if (document.activeElement instanceof HTMLElement) {
+        document.activeElement.blur();
+    }
+}
+
+export function clearDataSet($elm: HTMLElement) {
+    Object.keys($elm.dataset).forEach(key => {
+        delete $elm.dataset[key];
+    });
+}
+
+// https://stackoverflow.com/a/20732091
+const FILE_SIZE_UNITS = ['B', 'KB', 'MB', 'GB', 'TB'];
+export function humanFileSize(size: number) {
+    const i = size == 0 ? 0 : Math.floor(Math.log(size) / Math.log(1024));
+    return (size / Math.pow(1024, i)).toFixed(2) + ' ' + FILE_SIZE_UNITS[i];
+}
+
+export function secondsToHm(seconds: number) {
+    let h = Math.floor(seconds / 3600);
+    let m = Math.floor(seconds % 3600 / 60) + 1;
+
+    if (m === 60) {
+        h += 1;
+        m = 0;
+    }
+
+    const output = [];
+    h > 0 && output.push(`${h}h`);
+    m > 0 && output.push(`${m}m`);
+
+    return output.join(' ');
+}
+
+export function secondsToHms(seconds: number) {
+    let h = Math.floor(seconds / 3600);
+    seconds %= 3600;
+    let m = Math.floor(seconds / 60);
+    let s = seconds % 60;
+
+    const output = [];
+    h > 0 && output.push(`${h}h`);
+    m > 0 && output.push(`${m}m`);
+    if (s > 0 || output.length === 0) {
+        output.push(`${s}s`);
+    }
+
+    return output.join(' ');
+}

src/utils/local-db.ts

@@ -1,7 +1,8 @@
 import { MkbPreset } from "@modules/mkb/mkb-preset";
-import { PrefKey, setPref } from "@utils/preferences";
 import { t } from "@utils/translation";
 import type { MkbStoredPreset, MkbStoredPresets } from "@/types/mkb";
+import { PrefKey } from "@/enums/pref-keys";
+import { setPref } from "./settings-storages/global-settings-storage";
 
 export class LocalDb {
     static #instance: LocalDb;

src/utils/monkey-patches.ts

@@ -1,9 +1,10 @@
 import { BxEvent } from "@utils/bx-event";
-import { getPref, PrefKey } from "@utils/preferences";
 import { STATES } from "@utils/global";
 import { BxLogger } from "@utils/bx-logger";
-import { patchSdpBitrate } from "./sdp";
+import { patchSdpBitrate, setCodecPreferences } from "./sdp";
 import { StreamPlayer, type StreamPlayerOptions } from "@/modules/stream-player";
+import { PrefKey } from "@/enums/pref-keys";
+import { getPref } from "./settings-storages/global-settings-storage";
 
 export function patchVideoApi() {
     const PREF_SKIP_SPLASH_VIDEO = getPref(PrefKey.SKIP_SPLASH_VIDEO);
@@ -11,8 +12,6 @@ export function patchVideoApi() {
     // Show video player when it's ready
     const showFunc = function(this: HTMLVideoElement) {
         this.style.visibility = 'visible';
-        this.removeEventListener('playing', showFunc);
-
         if (!this.videoWidth) {
             return;
         }
@@ -49,7 +48,7 @@ export function patchVideoApi() {
         const $parent = this.parentElement!!;
         // Video tag is stream player
         if (!this.src && $parent.dataset.testid === 'media-container') {
-            this.addEventListener('playing', showFunc);
+            this.addEventListener('loadedmetadata', showFunc, {once: true});
         }
 
         return nativePlay.apply(this);
@@ -66,33 +65,6 @@ export function patchRtcCodecs() {
     if (typeof RTCRtpTransceiver === 'undefined' || !('setCodecPreferences' in RTCRtpTransceiver.prototype)) {
         return false;
     }
-
-    const profilePrefix = codecProfile === 'high' ? '4d' : (codecProfile === 'low' ? '420' : '42e');
-    const profileLevelId = `profile-level-id=${profilePrefix}`;
-
-    const nativeSetCodecPreferences = RTCRtpTransceiver.prototype.setCodecPreferences;
-    RTCRtpTransceiver.prototype.setCodecPreferences = function(codecs) {
-        // Use the same codecs as desktop
-        const newCodecs = codecs.slice();
-        let pos = 0;
-        newCodecs.forEach((codec, i) => {
-            // Find high-quality codecs
-            if (codec.sdpFmtpLine && codec.sdpFmtpLine.includes(profileLevelId)) {
-                // Move it to the top of the array
-                newCodecs.splice(i, 1);
-                newCodecs.splice(pos, 0, codec);
-                ++pos;
-            }
-        });
-
-        try {
-            nativeSetCodecPreferences.apply(this, [newCodecs]);
-        } catch (e) {
-            // Didn't work -> use default codecs
-            BxLogger.error('setCodecPreferences', e);
-            nativeSetCodecPreferences.apply(this, [codecs]);
-        }
-    }
 }
 
 export function patchRtcPeerConnection() {
@@ -109,12 +81,19 @@ export function patchRtcPeerConnection() {
     }
 
     const maxVideoBitrate = getPref(PrefKey.BITRATE_VIDEO_MAX);
-    if (maxVideoBitrate > 0) {
+    const codec = getPref(PrefKey.STREAM_CODEC_PROFILE);
+
+    if (codec !== 'default' || maxVideoBitrate > 0) {
         const nativeSetLocalDescription = RTCPeerConnection.prototype.setLocalDescription;
         RTCPeerConnection.prototype.setLocalDescription = function(description?: RTCLocalSessionDescriptionInit): Promise<void> {
+            // Set preferred codec profile
+            if (codec !== 'default') {
+                arguments[0].sdp = setCodecPreferences(arguments[0].sdp, codec);
+            }
+
             // set maximum bitrate
             try {
-                if (description) {
+                if (maxVideoBitrate > 0 && description) {
                     arguments[0].sdp = patchSdpBitrate(arguments[0].sdp, Math.round(maxVideoBitrate / 1000));
                 }
             } catch (e) {
@@ -181,6 +160,8 @@ export function patchMeControl() {
             API: {
                 setDisplayMode: () => {},
                 setMobileState: () => {},
+                addEventListener: () => {},
+                removeEventListener: () => {},
             },
         },
     };
@@ -220,6 +201,14 @@ export function patchMeControl() {
     (window as any).MeControl = new Proxy(MeControl, MeControlHandler);
 }
 
+
+/**
+ * Disable Adobe Audience Manager (AAM)
+ */
+export function disableAdobeAudienceManager() {
+    (window as any).adobe = Object.freeze({});
+}
+
 /**
  * Use power-saving flags for touch control
  */
@@ -265,6 +254,7 @@ export function patchPointerLockApi() {
     });
 
     // const nativeRequestPointerLock = HTMLElement.prototype.requestPointerLock;
+    // @ts-ignore
     HTMLElement.prototype.requestPointerLock = function() {
         pointerLockElement = document.documentElement;
         window.dispatchEvent(new Event(BxEvent.POINTER_LOCK_REQUESTED));

src/utils/navigation-utils.ts

@@ -0,0 +1,14 @@
+import type { NavigationElement, NavigationNearbyElements } from "@/modules/ui/dialog/navigation-dialog";
+
+export class NavigationUtils {
+    static setNearby($elm: NavigationElement, nearby: NavigationNearbyElements) {
+        $elm.nearby = $elm.nearby || {};
+
+        let key: keyof typeof nearby;
+        for (key in nearby) {
+            $elm.nearby[key] = nearby[key] as any;
+        }
+    }
+}
+
+export const setNearby = NavigationUtils.setNearby;