diff --git a/game-bridge/voice-room-game-bridge.v1.js b/game-bridge/voice-room-game-bridge.v1.js
index 00fd2dd..49cdd79 100644
--- a/game-bridge/voice-room-game-bridge.v1.js
+++ b/game-bridge/voice-room-game-bridge.v1.js
@@ -1,5 +1,5 @@
 (function () {
-    var remoteBridgeVersion = '20260610.2';
+    var remoteBridgeVersion = '20260629.1';
 
     function safeCall(fn, args) {
         try {
@@ -132,6 +132,9 @@
         if (values.indexOf('reyou') >= 0 || values.indexOf('hotgame') >= 0) {
             return 'reyou_v1';
         }
+        if (values.indexOf('zgame') >= 0) {
+            return 'zgame_v1';
+        }
         if (values.indexOf('yomi') >= 0) {
             return 'yomi_v4';
         }
@@ -243,6 +246,254 @@
         return true;
     }
 
+    function invokeNamedCallbackText(callbackName, payload) {
+        var text = readString(callbackName);
+        if (
+            !/^[A-Za-z_$][0-9A-Za-z_$]*(\.[A-Za-z_$][0-9A-Za-z_$]*)*$/.test(
+                text
+            )
+        ) {
+            return false;
+        }
+        var parts = text.split('.');
+        var target = window;
+        for (var i = 0; i < parts.length; i += 1) {
+            target = target[parts[i]];
+            if (target === null || target === undefined) {
+                return false;
+            }
+        }
+        if (typeof target !== 'function') {
+            return false;
+        }
+        safeCall(target, [stringifyParams(payload || {})]);
+        return true;
+    }
+
+    function firstNonEmpty() {
+        for (var i = 0; i < arguments.length; i += 1) {
+            var value = readString(arguments[i]);
+            if (value) {
+                return value;
+            }
+        }
+        return '';
+    }
+
+    function readNumber(value, fallback) {
+        if (typeof value === 'number' && isFinite(value)) {
+            return value;
+        }
+        var text = readString(value);
+        if (!text) {
+            return fallback || 0;
+        }
+        var parsed = Number(text);
+        return isFinite(parsed) ? parsed : fallback || 0;
+    }
+
+    function zgameLaunchInfo() {
+        var config = launchConfig();
+        var payload = launchPayload();
+        var entry = launchEntry();
+        var openId = firstNonEmpty(
+            config.openId,
+            config.open_id,
+            config.userId,
+            config.user_id,
+            config.uid,
+            payload.openId,
+            payload.open_id,
+            payload.userId,
+            payload.user_id,
+            payload.uid
+        );
+        var jsCode = firstNonEmpty(
+            config.js_code,
+            config.jsCode,
+            config.code,
+            config.session,
+            config.token,
+            payload.js_code,
+            payload.jsCode,
+            payload.code,
+            payload.session,
+            payload.token
+        );
+        var userName = firstNonEmpty(
+            config.userName,
+            config.user_name,
+            config.nickname,
+            config.nickName,
+            payload.userName,
+            payload.user_name,
+            payload.nickname,
+            payload.nickName
+        );
+        var avatar = firstNonEmpty(
+            config.avatar,
+            config.avatarUrl,
+            config.avatar_url,
+            payload.avatar,
+            payload.avatarUrl,
+            payload.avatar_url
+        );
+        return {
+            openId: openId,
+            jsCode: jsCode,
+            userName: userName,
+            avatar: avatar,
+            balance: readNumber(
+                firstNonEmpty(
+                    config.balance,
+                    config.coin,
+                    config.cash,
+                    payload.balance,
+                    payload.coin,
+                    payload.cash
+                ),
+                0
+            ),
+            gameId: firstNonEmpty(
+                config.gameId,
+                config.game_id,
+                payload.gameId,
+                payload.game_id
+            ),
+            roomId: firstNonEmpty(
+                config.roomId,
+                config.room_id,
+                payload.roomId,
+                payload.room_id
+            ),
+            callbackBase: firstNonEmpty(
+                config.callbackBase,
+                config.callback_base,
+                payload.callbackBase,
+                payload.callback_base
+            ),
+            merchantPayload: firstNonEmpty(
+                config.merchantPayload,
+                config.merchant_payload,
+                payload.merchantPayload,
+                payload.merchant_payload
+            ),
+            launchUrl: firstNonEmpty(
+                entry.entryUrl,
+                entry.entry_url,
+                payload.launchUrl,
+                payload.launch_url
+            ),
+        };
+    }
+
+    function zgameBridgePayload(resp, code, message) {
+        return {
+            error: {
+                code: readString(code || '0') || '0',
+                message: readString(message || 'success') || 'success',
+            },
+            resp: resp || {},
+        };
+    }
+
+    function zgameBridgeError(code, message) {
+        return zgameBridgePayload(
+            null,
+            code || '500',
+            message || 'bridge error'
+        );
+    }
+
+    function invokeZGameBridge(api, paramsJson, callbackName) {
+        var apiName = readString(api);
+        var normalized = apiName.toLowerCase();
+        var params = parseBridgePayload(paramsJson);
+        var info = zgameLaunchInfo();
+        var response;
+        try {
+            if (normalized === 'getuserinfo' || normalized === 'get_user_info') {
+                response = zgameBridgePayload({
+                    openId: info.openId,
+                    userName: info.userName,
+                    nickname: info.userName,
+                    avatar: info.avatar,
+                    balance: info.balance,
+                    gameId: info.gameId,
+                    roomId: info.roomId,
+                    callbackBase: info.callbackBase,
+                    merchantPayload: info.merchantPayload,
+                });
+            } else if (normalized === 'login') {
+                if (!info.openId || !info.jsCode) {
+                    response = zgameBridgeError(
+                        '403',
+                        'missing openId or js_code'
+                    );
+                } else {
+                    response = zgameBridgePayload({
+                        js_code: info.jsCode,
+                        openId: info.openId,
+                    });
+                }
+            } else if (
+                normalized === 'closewebview' ||
+                normalized === 'closeweb_view' ||
+                normalized === 'close' ||
+                normalized === 'destroy'
+            ) {
+                callNativeBridge('closeGame', params || {});
+                response = zgameBridgePayload({});
+            } else if (normalized === 'recharge' || normalized === 'pay') {
+                callNativeBridge('gameRecharge', params || {});
+                response = zgameBridgePayload({});
+            } else {
+                callNativeBridge(apiName || 'NativeBridge', params || {});
+                response = zgameBridgePayload({});
+            }
+        } catch (error) {
+            response = zgameBridgeError(
+                '500',
+                String((error && error.message) || error)
+            );
+        }
+        invokeNamedCallbackText(callbackName, response);
+        return response;
+    }
+
+    function installZGameBridgeAliases(nativeBridge) {
+        var previousBridge = window.ThirdPlatformBridge || {};
+        var zgameBridge = {};
+        Object.keys(previousBridge).forEach(function (key) {
+            zgameBridge[key] = previousBridge[key];
+        });
+        zgameBridge.__hyappZGameBridge = true;
+        zgameBridge.invoke = function (api, paramsJson, callbackName) {
+            return invokeZGameBridge(api, paramsJson, callbackName);
+        };
+        zgameBridge.getLaunchInfo = function () {
+            return zgameLaunchInfo();
+        };
+        window.ThirdPlatformBridge = zgameBridge;
+        if (
+            !window.WebViewJavascriptBridge ||
+            typeof window.WebViewJavascriptBridge.invoke !== 'function'
+        ) {
+            window.WebViewJavascriptBridge = zgameBridge;
+        }
+        nativeBridge.thirdPlatformInvoke = zgameBridge.invoke;
+    }
+
+    function shouldInstallZGameBridge(adapter) {
+        if (adapter === 'zgame_v1') {
+            return true;
+        }
+        return (
+            zgameLaunchInfo().callbackBase.toLowerCase().indexOf('/zgame/') >=
+            0
+        );
+    }
+
     function yomiActionResult(action, payload) {
         var normalized = readString(action).toLowerCase();
         if (normalized === 'insufficient') {
@@ -584,6 +835,9 @@
         };
         installReyouBridgeAliases(nativeBridge);
         installYomiBridgeAliases(nativeBridge);
+        if (shouldInstallZGameBridge(adapter)) {
+            installZGameBridgeAliases(nativeBridge);
+        }
         window.NativeBridge = nativeBridge;
 
         [
@@ -613,13 +867,20 @@
     }
 
     function signalReady(config, payload) {
-        [
+        var readyEvents = [
             ['hyappGameBridgeReady', payload],
             ['hyappRemoteGameBridgeReady', window.__hyappRemoteGameBridge],
             ['baishunBridgeReady', config],
             ['leaderLaunchConfig', payload],
             ['launchConfig', config],
-        ].forEach(function (item) {
+        ];
+        if (
+            window.ThirdPlatformBridge &&
+            window.ThirdPlatformBridge.__hyappZGameBridge
+        ) {
+            readyEvents.push(['zgameBridgeReady', window.ThirdPlatformBridge]);
+        }
+        readyEvents.forEach(function (item) {
             try {
                 window.dispatchEvent(
                     new CustomEvent(item[0], { detail: item[1] })