@lingxia/bridge 0.15.0 → 0.17.0

package/dist/es5/bridge.js

@@ -45,6 +45,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __values = (this && this.__values) || function(o) {
     var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
     if (m) return m.call(o);
@@ -84,7 +95,8 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 import { BRIDGE_ERROR } from "./types";
 import { toBridgeError, toNativeError } from "./invocation";
 import { installNativeComponentCoverageMonitor } from "./nativecomponents/coverage-monitor";
-import { BRIDGE_CONFIG, getCommunicationMethod, getPlatformOS, isAndroid, isHarmony, isIOS, isMacOS, isWindows, isDesktop, isMobile, isApple, isDevSession, isRunner, } from "./runtime-env";
+import { consumeV3Bootstrap, } from "./protocol-v3";
+import { BRIDGE_CONFIG, getCommunicationMethod, getDisplayLanguage, getPlatformOS, subscribeDisplayLanguage, isAndroid, isHarmony, isIOS, isMacOS, isWindows, isDesktop, isMobile, isApple, isDevSession, isRunner, } from "./runtime-env";
 var NATIVE_HANDLER_NAME = "LingXia";
 var GLOBAL_RECEIVER_NAME = "__LingXiaRecvMessage";
 var DEFAULT_TIMEOUT_MS = 5000;
@@ -98,8 +110,28 @@ var OUTBOX_LIMIT = 256;
 var APPLE_DOWNSTREAM_URL = BRIDGE_CONFIG.appleDownstreamURL;
 var APPLE_RECONNECT_BASE_MS = 200;
 var APPLE_RECONNECT_MAX_MS = 2000;
+var BOUND_CONSOLE_MESSAGE_CHARS = 12 * 1024;
+// Native drops a larger frame before it reaches the bridge, so a request that
+// exceeds this would otherwise only surface as a timeout. Mirrors
+// MAX_WEB_MESSAGE_BYTES in the webview crate.
+var MAX_NATIVE_MESSAGE_BYTES = 64 * 1024;
+// Keep framework diagnostics and console forwarding on the original methods.
+// RequiredV3 installs a page-facing wrapper later; using it here would recurse
+// and could accidentally serialize the bound envelope into another log.
+var nativeConsole = {
+    log: console.log.bind(console),
+    warn: console.warn.bind(console),
+    error: console.error.bind(console),
+    info: (console.info || console.log).bind(console),
+    debug: (console.debug || console.log).bind(console),
+    group: (console.group || console.log).bind(console),
+    groupEnd: (console.groupEnd || (function () { })).bind(console),
+};
 var debugFlags = { data: false, proto: false, all: false };
 var earlyNativeMessages = [];
+// Fixed once, during init. The V3 secret remains captured only by the codec.
+var protocolMode = { kind: "v2" };
+var protocolInitialized = false;
 // Plain-object equivalent of `new Proxy(debugFlags, ...)`. Avoids referencing
 // the `Proxy` global so the module loads on older WebViews (Android 5.x stock
 // WebView is Chromium 37–39, which predates Chromium 49's Proxy support).
@@ -114,32 +146,79 @@ function createDebugObject(flags) {
             },
             set: function (value) {
                 flags[key] = !!value;
-                console.log("[LX] ".concat(key, ": ").concat(value));
+                nativeConsole.log("[LX] ".concat(key, ": ").concat(value));
             },
         });
     });
     return target;
 }
+function drainHostEarlyNativeMessages() {
+    var e_1, _a;
+    if (typeof window === "undefined")
+        return;
+    var hostQueue = window.__LingXiaEarlyNativeMessages;
+    if (!Array.isArray(hostQueue) || hostQueue.length === 0)
+        return;
+    window.__LingXiaEarlyNativeMessages = [];
+    try {
+        for (var hostQueue_1 = __values(hostQueue), hostQueue_1_1 = hostQueue_1.next(); !hostQueue_1_1.done; hostQueue_1_1 = hostQueue_1.next()) {
+            var message = hostQueue_1_1.value;
+            if (typeof message === "string") {
+                earlyNativeMessages.push(message);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (hostQueue_1_1 && !hostQueue_1_1.done && (_a = hostQueue_1.return)) _a.call(hostQueue_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
 function installEarlyReceiver() {
+    var e_2, _a;
     if (typeof window === "undefined")
         return;
-    if (typeof window[GLOBAL_RECEIVER_NAME] === "function")
+    drainHostEarlyNativeMessages();
+    var existing = window[GLOBAL_RECEIVER_NAME];
+    if (typeof existing === "function") {
+        if (earlyNativeMessages.length === 0)
+            return;
+        var queued = earlyNativeMessages.splice(0, earlyNativeMessages.length);
+        try {
+            for (var queued_1 = __values(queued), queued_1_1 = queued_1.next(); !queued_1_1.done; queued_1_1 = queued_1.next()) {
+                var message = queued_1_1.value;
+                try {
+                    existing(message);
+                }
+                catch (err) {
+                    warn("Failed to replay queued native message:", err);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (queued_1_1 && !queued_1_1.done && (_a = queued_1.return)) _a.call(queued_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
         return;
+    }
     window[GLOBAL_RECEIVER_NAME] = function (message) {
         earlyNativeMessages.push(message);
     };
 }
-function activateReceiver(receiver) {
-    var e_1, _a;
-    if (typeof window === "undefined")
-        return;
-    window[GLOBAL_RECEIVER_NAME] = receiver;
+function flushEarlyNativeMessages(receiver) {
+    var e_3, _a;
+    drainHostEarlyNativeMessages();
     if (earlyNativeMessages.length === 0)
         return;
     var queued = earlyNativeMessages.splice(0, earlyNativeMessages.length);
     try {
-        for (var queued_1 = __values(queued), queued_1_1 = queued_1.next(); !queued_1_1.done; queued_1_1 = queued_1.next()) {
-            var message = queued_1_1.value;
+        for (var queued_2 = __values(queued), queued_2_1 = queued_2.next(); !queued_2_1.done; queued_2_1 = queued_2.next()) {
+            var message = queued_2_1.value;
             try {
                 receiver(message);
             }
@@ -148,14 +227,25 @@ function activateReceiver(receiver) {
             }
         }
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
     finally {
         try {
-            if (queued_1_1 && !queued_1_1.done && (_a = queued_1.return)) _a.call(queued_1);
+            if (queued_2_1 && !queued_2_1.done && (_a = queued_2.return)) _a.call(queued_2);
         }
-        finally { if (e_1) throw e_1.error; }
+        finally { if (e_3) throw e_3.error; }
     }
 }
+function activateReceiver(receiver) {
+    if (typeof window === "undefined")
+        return;
+    // Drain the inject-script queue on every inbound call so late
+    // `__LingXiaEarlyNativeMessages` items flush without rebinding.
+    window[GLOBAL_RECEIVER_NAME] = function (message) {
+        flushEarlyNativeMessages(receiver);
+        receiver(message);
+    };
+    flushEarlyNativeMessages(receiver);
+}
 function isDebugEnabled(flag) {
     return debugFlags.all || debugFlags[flag];
 }
@@ -175,21 +265,21 @@ function log() {
         !debugFlags.data) {
         return;
     }
-    console.log.apply(console, __spreadArray([LOG_PREFIX], __read(args), false));
+    nativeConsole.log.apply(nativeConsole, __spreadArray([LOG_PREFIX], __read(args), false));
 }
 function warn() {
     var args = [];
     for (var _i = 0; _i < arguments.length; _i++) {
         args[_i] = arguments[_i];
     }
-    console.warn.apply(console, __spreadArray([LOG_PREFIX], __read(args), false));
+    nativeConsole.warn.apply(nativeConsole, __spreadArray([LOG_PREFIX], __read(args), false));
 }
 function error() {
     var args = [];
     for (var _i = 0; _i < arguments.length; _i++) {
         args[_i] = arguments[_i];
     }
-    console.error.apply(console, __spreadArray([LOG_PREFIX], __read(args), false));
+    nativeConsole.error.apply(nativeConsole, __spreadArray([LOG_PREFIX], __read(args), false));
 }
 function safeStringify(obj, space) {
     var seen = new WeakSet();
@@ -238,7 +328,15 @@ var appleLastFrameSeq = 0;
 // than a couple of heartbeats means the connection is silently dead and we
 // reconnect proactively instead of waiting for a read error that may never come.
 var APPLE_DOWNSTREAM_STALE_MS = 35000;
+// A downstream that has never delivered a frame gets this long to connect.
+var APPLE_DOWNSTREAM_CONNECT_TIMEOUT_MS = 10000;
 var appleLastFrameAt = 0;
+var appleDownstreamAttemptAt = 0;
+// Names this page load to the host transport, so a reloaded document never
+// resumes the sequence of the one it replaced.
+var APPLE_DOWNSTREAM_DOCUMENT = "".concat(Date.now().toString(36)).concat(Math.random()
+    .toString(36)
+    .slice(2, 10));
 var appleWatchdogTimer = null;
 var portInitState = {
     listenerInstalled: false,
@@ -302,7 +400,7 @@ function disposeAppleDownstream(reason) {
     resetHandshakeState(reason, true);
 }
 function closeActiveChannelsFromTransport(reason) {
-    var e_2, _a;
+    var e_4, _a;
     try {
         for (var _b = __values(Array.from(activeChannels.entries())), _c = _b.next(); !_c.done; _c = _b.next()) {
             var _d = __read(_c.value, 2), id = _d[0], channel_1 = _d[1];
@@ -310,16 +408,16 @@ function closeActiveChannelsFromTransport(reason) {
             channel_1._emitClose(BRIDGE_ERROR.STREAM_CLOSED, reason);
         }
     }
-    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
     finally {
         try {
             if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
         }
-        finally { if (e_2) throw e_2.error; }
+        finally { if (e_4) throw e_4.error; }
     }
 }
 function rejectAllPendingForTransport(reason) {
-    var e_3, _a, e_4, _b;
+    var e_5, _a, e_6, _b;
     try {
         for (var _c = __values(Array.from(pendingReq.keys())), _d = _c.next(); !_d.done; _d = _c.next()) {
             var id = _d.value;
@@ -329,12 +427,12 @@ function rejectAllPendingForTransport(reason) {
             });
         }
     }
-    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
     finally {
         try {
             if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
         }
-        finally { if (e_3) throw e_3.error; }
+        finally { if (e_5) throw e_5.error; }
     }
     try {
         for (var _e = __values(Array.from(pendingChannels.keys())), _f = _e.next(); !_f.done; _f = _e.next()) {
@@ -345,18 +443,20 @@ function rejectAllPendingForTransport(reason) {
             });
         }
     }
-    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
     finally {
         try {
             if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
         }
-        finally { if (e_4) throw e_4.error; }
+        finally { if (e_6) throw e_6.error; }
     }
     closeActiveChannelsFromTransport(reason);
 }
 function resetHandshakeState(reason, rejectPending) {
     clearHandshakeTimer();
-    handshakeSessionId = null;
+    if (protocolMode.kind !== "required-v3")
+        handshakeSessionId = null;
+    helloAcknowledged = false;
     handshakeDone = false;
     helloSent = false;
     handshakeRetryCount = 0;
@@ -417,7 +517,7 @@ function handleAppleDownstreamFrame(frame) {
 }
 function runAppleDownstream() {
     return __awaiter(this, void 0, void 0, function () {
-        var controller, separator, url, response, reader, decoder, buffered, _a, value, done, tail, e_5;
+        var controller, separator, url, response, reader, decoder, buffered, _a, value, done, tail, e_7;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
@@ -427,7 +527,8 @@ function runAppleDownstream() {
                     controller = new AbortController();
                     appleDownstreamAbortController = controller;
                     separator = APPLE_DOWNSTREAM_URL.includes("?") ? "&" : "?";
-                    url = "".concat(APPLE_DOWNSTREAM_URL).concat(separator, "from=").concat(appleLastFrameSeq);
+                    url = "".concat(APPLE_DOWNSTREAM_URL).concat(separator, "from=").concat(appleLastFrameSeq, "&doc=").concat(APPLE_DOWNSTREAM_DOCUMENT);
+                    appleDownstreamAttemptAt = Date.now();
                     return [4 /*yield*/, fetch(url, {
                             method: "GET",
                             cache: "no-store",
@@ -482,10 +583,10 @@ function runAppleDownstream() {
                     }
                     return [3 /*break*/, 8];
                 case 6:
-                    e_5 = _b.sent();
+                    e_7 = _b.sent();
                     if (controller.signal.aborted)
                         return [2 /*return*/];
-                    throw e_5;
+                    throw e_7;
                 case 7:
                     try {
                         reader.releaseLock();
@@ -588,8 +689,18 @@ function startAppleWatchdog() {
     appleWatchdogTimer = setInterval(function () {
         // No `connected` guard: a reconnect that hung before delivering a frame
         // also goes stale, and forcing a reconnect aborts and retries it.
-        if (appleLastFrameAt === 0)
+        if (appleLastFrameAt === 0) {
+            // The first downstream has produced nothing yet. A fetch whose response
+            // never arrives raises no error, and a page that stays in-window (under
+            // a splash, say) never sees the visibility handler either.
+            if (appleDownstreamTask &&
+                appleDownstreamAttemptAt !== 0 &&
+                Date.now() - appleDownstreamAttemptAt > APPLE_DOWNSTREAM_CONNECT_TIMEOUT_MS) {
+                warn("Apple downstream did not connect, forcing reconnect");
+                forceDownstreamReconnect();
+            }
             return;
+        }
         if (Date.now() - appleLastFrameAt > APPLE_DOWNSTREAM_STALE_MS) {
             warn("Apple downstream stale (no heartbeat), forcing reconnect");
             forceDownstreamReconnect();
@@ -637,44 +748,133 @@ function getMessagePort() {
     }
     return portInitState.promise;
 }
+function encodeForNative(message) {
+    if (protocolMode.kind === "blocked")
+        return null;
+    if (protocolMode.kind === "v2")
+        return message;
+    if (!message || typeof message !== "object")
+        return null;
+    var _a = message, _v = _a.v, kind = _a.kind, payload = __rest(_a, ["v", "kind"]);
+    if (typeof kind !== "string")
+        return null;
+    var encoded = protocolMode.codec.encode(kind, payload);
+    return encoded.ok ? encoded.value : null;
+}
 function postToNative(message) {
     var _a, _b, _c;
+    var encodedMessage = encodeForNative(message);
+    if (!encodedMessage)
+        return null;
     var kind = message.kind;
     if (kind === "req" || kind === "notify")
         log("postToNative: ".concat(kind, " ").concat(message.method));
     if (isDebugEnabled("proto"))
-        console.log("→", JSON.stringify(message, null, 2));
+        // Log the payload before RequiredV3 adds its document secret. The bound
+        // console wrapper posts what it prints, which would re-enter this function.
+        nativeConsole.log("→", JSON.stringify(message, null, 2));
     try {
+        var messageString = stringifyForNative(encodedMessage);
+        var bytes = utf8ByteLength(messageString);
+        if (bytes > MAX_NATIVE_MESSAGE_BYTES) {
+            return {
+                code: BRIDGE_ERROR.MESSAGE_TOO_LARGE,
+                message: "Bridge message of ".concat(bytes, " bytes exceeds the ").concat(MAX_NATIVE_MESSAGE_BYTES, "-byte native limit"),
+            };
+        }
         if (communicationMethod === "webkit") {
-            (_b = (_a = window.webkit) === null || _a === void 0 ? void 0 : _a.messageHandlers[NATIVE_HANDLER_NAME]) === null || _b === void 0 ? void 0 : _b.postMessage(message);
-            return;
+            (_b = (_a = window.webkit) === null || _a === void 0 ? void 0 : _a.messageHandlers[NATIVE_HANDLER_NAME]) === null || _b === void 0 ? void 0 : _b.postMessage(messageString);
+            return null;
         }
-        var messageString = stringifyForNative(message);
         if (communicationMethod === MESSAGE_PORT_TYPE && messagePort) {
             messagePort.postMessage(messageString);
-            return;
+            return null;
         }
         if ((communicationMethod === JS_INTERFACE_TYPE ||
             communicationMethod === WEB_MESSAGE_TYPE) &&
             ((_c = window.LingXiaProxy) === null || _c === void 0 ? void 0 : _c.postMessage)) {
             window.LingXiaProxy.postMessage(messageString);
-            return;
+            return null;
         }
         warn("Transport not ready");
     }
     catch (e) {
-        error("Send error:", e);
+        if (protocolMode.kind === "required-v3")
+            error("Send error");
+        else
+            error("Send error:", e);
+    }
+    return null;
+}
+function formatBoundConsoleMessage(args) {
+    var message = args
+        .map(function (arg) {
+        if (typeof arg === "string")
+            return arg;
+        try {
+            var encoded = stringifyForNative(arg);
+            return typeof encoded === "string" ? encoded : String(arg);
+        }
+        catch (_a) {
+            return "[Unserializable]";
+        }
+    })
+        .join(" ");
+    return message.length <= BOUND_CONSOLE_MESSAGE_CHARS
+        ? message
+        : "".concat(message.slice(0, BOUND_CONSOLE_MESSAGE_CHARS), "\u2026");
+}
+/**
+ * BrowserControl console is an authenticated auxiliary V3 frame. Platform
+ * console hooks are disabled for BrowserRelaxed WebViews, so this is the only
+ * path that can reach the native log delegate for a control document.
+ */
+function installBoundV3Console() {
+    var e_8, _a;
+    if (protocolMode.kind !== "required-v3")
+        return;
+    var methods = ["log", "error", "warn", "info", "debug"];
+    var _loop_1 = function (level) {
+        var original = nativeConsole[level];
+        console[level] = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            original.apply(void 0, __spreadArray([], __read(args), false));
+            // Native repeats Active session, WebMessageContext, generation and rate
+            // checks. Avoid sending pre-handshake output that can never be admitted.
+            if (!handshakeDone)
+                return;
+            postToNative({
+                kind: "console",
+                __lingxia_console__: true,
+                level: level,
+                message: formatBoundConsoleMessage(args),
+            });
+        };
+    };
+    try {
+        for (var methods_1 = __values(methods), methods_1_1 = methods_1.next(); !methods_1_1.done; methods_1_1 = methods_1.next()) {
+            var level = methods_1_1.value;
+            _loop_1(level);
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (methods_1_1 && !methods_1_1.done && (_a = methods_1.return)) _a.call(methods_1);
+        }
+        finally { if (e_8) throw e_8.error; }
     }
 }
 // Handshake state
 var handshakeSessionId = null;
+var helloAcknowledged = false;
 var handshakeDone = false;
 var helloSent = false;
 var handshakeRetryCount = 0;
 var handshakeTimer = null;
-// Host method schema — populated from handshake `Ready` message.
-// Maps "namespace.method" → "call" | "stream".
-var hostMethodKinds = {};
 // Request tracking
 var requestCounter = 0;
 function createListenerBuckets() {
@@ -738,7 +938,7 @@ function createStreamHandle(id, cancelFn) {
             cancelFn();
         },
         _a._emitData = function (payload) {
-            var e_6, _a;
+            var e_9, _a;
             if (done)
                 return;
             if (pendingReads.length > 0) {
@@ -758,16 +958,16 @@ function createStreamHandle(id, cancelFn) {
                     }
                 }
             }
-            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_6) throw e_6.error; }
+                finally { if (e_9) throw e_9.error; }
             }
         },
         _a._resolve = function (resultValue) {
-            var e_7, _a;
+            var e_10, _a;
             if (done)
                 return;
             done = true;
@@ -786,16 +986,16 @@ function createStreamHandle(id, cancelFn) {
                     }
                 }
             }
-            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            catch (e_10_1) { e_10 = { error: e_10_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_7) throw e_7.error; }
+                finally { if (e_10) throw e_10.error; }
             }
         },
         _a._reject = function (err) {
-            var e_8, _a;
+            var e_11, _a;
             if (done)
                 return;
             done = true;
@@ -814,12 +1014,12 @@ function createStreamHandle(id, cancelFn) {
                     }
                 }
             }
-            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            catch (e_11_1) { e_11 = { error: e_11_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_8) throw e_8.error; }
+                finally { if (e_11) throw e_11.error; }
             }
         },
         _a);
@@ -849,7 +1049,7 @@ function createChannel(id, sendFn, closeFn) {
                 sendFn(payload, outboundSeq++);
             },
             on: function (event, listener) {
-                var e_9, _a;
+                var e_12, _a;
                 if (event === "data") {
                     listeners.data.add(listener);
                     // Flush data buffered before this listener attached. The host can send
@@ -869,12 +1069,12 @@ function createChannel(id, sendFn, closeFn) {
                                 }
                             }
                         }
-                        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                        catch (e_12_1) { e_12 = { error: e_12_1 }; }
                         finally {
                             try {
                                 if (buffered_1_1 && !buffered_1_1.done && (_a = buffered_1.return)) _a.call(buffered_1);
                             }
-                            finally { if (e_9) throw e_9.error; }
+                            finally { if (e_12) throw e_12.error; }
                         }
                     }
                 }
@@ -913,7 +1113,7 @@ function createChannel(id, sendFn, closeFn) {
             channel._emitClose(code, reason);
         },
         _a._emitData = function (payload) {
-            var e_10, _a;
+            var e_13, _a;
             if (!open)
                 return;
             if (pendingReads.length > 0) {
@@ -933,16 +1133,16 @@ function createChannel(id, sendFn, closeFn) {
                     }
                 }
             }
-            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            catch (e_13_1) { e_13 = { error: e_13_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_10) throw e_10.error; }
+                finally { if (e_13) throw e_13.error; }
             }
         },
         _a._emitClose = function (code, reason) {
-            var e_11, _a;
+            var e_14, _a;
             closed = true;
             while (pendingReads.length > 0) {
                 pendingReads.shift().resolve({ done: true, value: undefined });
@@ -958,16 +1158,16 @@ function createChannel(id, sendFn, closeFn) {
                     }
                 }
             }
-            catch (e_11_1) { e_11 = { error: e_11_1 }; }
+            catch (e_14_1) { e_14 = { error: e_14_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_11) throw e_11.error; }
+                finally { if (e_14) throw e_14.error; }
             }
         },
         _a._reject = function (err) {
-            var e_12, _a;
+            var e_15, _a;
             closed = true;
             while (pendingReads.length > 0) {
                 pendingReads.shift().reject(err);
@@ -983,12 +1183,12 @@ function createChannel(id, sendFn, closeFn) {
                     }
                 }
             }
-            catch (e_12_1) { e_12 = { error: e_12_1 }; }
+            catch (e_15_1) { e_15 = { error: e_15_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_12) throw e_12.error; }
+                finally { if (e_15) throw e_15.error; }
             }
         },
         _a._markOpen = function () {
@@ -1138,6 +1338,26 @@ function removeOutboxByReqId(reqId) {
     }
     return false;
 }
+// UTF-8 byte length without allocating a copy of the string.
+function utf8ByteLength(value) {
+    if (typeof TextEncoder === "function")
+        return new TextEncoder().encode(value).length;
+    var bytes = 0;
+    for (var i = 0; i < value.length; i += 1) {
+        var code = value.charCodeAt(i);
+        if (code < 0x80)
+            bytes += 1;
+        else if (code < 0x800)
+            bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff) {
+            bytes += 4;
+            i += 1;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}
 function send(msg, reqId) {
     var kind = msg.kind;
     var isHandshake = kind === "hello" || kind === "helloAck" || kind === "ready";
@@ -1157,7 +1377,16 @@ function send(msg, reqId) {
     }
     if (reqId)
         armPendingOperationTimer(reqId);
-    postToNative(msg);
+    reportPostFailure(postToNative(msg), reqId);
+}
+// An oversized frame is dropped by native without a reply, so the caller would
+// otherwise learn about it only when its request timed out.
+function reportPostFailure(failure, reqId) {
+    if (!failure)
+        return;
+    error(failure.message);
+    if (reqId)
+        rejectPendingOperation(reqId, failure);
 }
 function flushOutbox() {
     if (!canSendAppMessages())
@@ -1168,7 +1397,7 @@ function flushOutbox() {
             continue;
         if (item.reqId)
             armPendingOperationTimer(item.reqId);
-        postToNative(item.msg);
+        reportPostFailure(postToNative(item.msg), item.reqId);
     }
 }
 function clearHandshakeTimer() {
@@ -1180,6 +1409,10 @@ function clearHandshakeTimer() {
 function startHandshake() {
     if (handshakeDone)
         return;
+    if (!protocolInitialized)
+        return;
+    if (protocolMode.kind === "blocked")
+        return;
     if (!isTransportReady())
         return;
     clearHandshakeTimer();
@@ -1188,12 +1421,12 @@ function startHandshake() {
         kind: "hello",
         nonce: BRIDGE_CONFIG.nonce || "",
         role: "view",
-        protocolsSupported: [2],
+        protocolsSupported: protocolMode.kind === "required-v3" ? [3] : [2],
     };
     helloSent = true;
     postToNative(hello);
     handshakeTimer = setTimeout(function () {
-        var e_13, _a;
+        var e_16, _a;
         if (handshakeDone)
             return;
         handshakeRetryCount++;
@@ -1225,17 +1458,34 @@ function startHandshake() {
                     });
                 }
             }
-            catch (e_13_1) { e_13 = { error: e_13_1 }; }
+            catch (e_16_1) { e_16 = { error: e_16_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_13) throw e_13.error; }
+                finally { if (e_16) throw e_16.error; }
             }
         }
     }, HANDSHAKE_TIMEOUT_MS);
 }
 function parseIncoming(msg) {
+    if (protocolMode.kind === "blocked")
+        return null;
+    if (protocolMode.kind === "required-v3") {
+        var frame = typeof msg === "string" ? msg : stringifyForNative(msg);
+        var parsed = protocolMode.codec.parse(frame);
+        if (!parsed.ok)
+            return null;
+        return __assign({ v: 3, kind: parsed.value.kind }, parsed.value.payload);
+    }
+    if (typeof msg === "string") {
+        try {
+            msg = JSON.parse(msg);
+        }
+        catch (_a) {
+            return null;
+        }
+    }
     if (!msg || typeof msg !== "object")
         return null;
     var v = msg.v;
@@ -1281,7 +1531,7 @@ function getContainerAndKey(root, pointer, autoCreate) {
     return { container: current, key: segments[segments.length - 1] };
 }
 function applyJsonPatch(target, ops) {
-    var e_14, _a, e_15, _b;
+    var e_17, _a, e_18, _b;
     try {
         for (var ops_1 = __values(ops), ops_1_1 = ops_1.next(); !ops_1_1.done; ops_1_1 = ops_1.next()) {
             var op = ops_1_1.value;
@@ -1289,17 +1539,17 @@ function applyJsonPatch(target, ops) {
             var _c = getContainerAndKey(target, op.path, autoCreate), container = _c.container, key = _c.key;
             if (key === "$root") {
                 try {
-                    for (var _d = (e_15 = void 0, __values(Object.keys(target))), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    for (var _d = (e_18 = void 0, __values(Object.keys(target))), _e = _d.next(); !_e.done; _e = _d.next()) {
                         var k = _e.value;
                         delete target[k];
                     }
                 }
-                catch (e_15_1) { e_15 = { error: e_15_1 }; }
+                catch (e_18_1) { e_18 = { error: e_18_1 }; }
                 finally {
                     try {
                         if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
                     }
-                    finally { if (e_15) throw e_15.error; }
+                    finally { if (e_18) throw e_18.error; }
                 }
                 if (op.op !== "remove") {
                     var v = op.value;
@@ -1329,12 +1579,12 @@ function applyJsonPatch(target, ops) {
                 obj[key] = op.value;
         }
     }
-    catch (e_14_1) { e_14 = { error: e_14_1 }; }
+    catch (e_17_1) { e_17 = { error: e_17_1 }; }
     finally {
         try {
             if (ops_1_1 && !ops_1_1.done && (_a = ops_1.return)) _a.call(ops_1);
         }
-        finally { if (e_14) throw e_14.error; }
+        finally { if (e_17) throw e_17.error; }
     }
 }
 function notifyStateSubscribers(initial) {
@@ -1384,19 +1634,27 @@ function applySnapshotFromResult(result) {
     pageData = obj.state;
     stateRev = obj.rev;
     if (isDebugEnabled("data")) {
-        console.group("[LX] snapshot(res)");
-        console.log("rev:", stateRev, "state:", deepCopy(pageData));
-        console.groupEnd();
+        nativeConsole.group("[LX] snapshot(res)");
+        nativeConsole.log("rev:", stateRev, "state:", deepCopy(pageData));
+        nativeConsole.groupEnd();
     }
     notifyStateSubscribers(true);
     return true;
 }
 function handleIncomingMessage(msg) {
-    var e_16, _a;
-    var _b, _c, _d, _e;
+    var _a, _b, _c, _d;
+    var candidate = msg;
+    if (protocolMode.kind === "v2" && typeof candidate === "string") {
+        try {
+            candidate = JSON.parse(candidate);
+        }
+        catch (_e) {
+            candidate = null;
+        }
+    }
     // Handle native component events (from Android NativeBridge.sendEventToView)
-    if (msg && typeof msg === "object") {
-        var obj = msg;
+    if (protocolMode.kind === "v2" && candidate && typeof candidate === "object") {
+        var obj = candidate;
         if (obj.type === "event" && obj.name === "nativecomponent" && obj.payload) {
             var payload = obj.payload;
             var componentId = payload.id ||
@@ -1415,40 +1673,46 @@ function handleIncomingMessage(msg) {
             return;
         }
     }
-    var message = parseIncoming(msg);
+    var message = parseIncoming(candidate);
     if (!message) {
-        warn("Invalid V2 message:", msg);
+        warn("Invalid bridge message");
         return;
     }
     switch (message.kind) {
         case "helloAck":
-            handshakeSessionId = message.sessionId;
+            if (message.protocol !== (protocolMode.kind === "required-v3" ? 3 : 2) ||
+                message.nonce !== (BRIDGE_CONFIG.nonce || "")) {
+                warn("Invalid helloAck");
+                return;
+            }
+            if (protocolMode.kind === "required-v3") {
+                helloAcknowledged = true;
+                return;
+            }
+            if (handshakeSessionId && message.sessionId !== handshakeSessionId) {
+                warn("sessionId mismatch");
+                return;
+            }
+            if (!handshakeSessionId)
+                handshakeSessionId = message.sessionId;
+            helloAcknowledged = true;
             return;
         case "ready":
-            if (handshakeSessionId && message.sessionId !== handshakeSessionId) {
+            if (!helloAcknowledged)
+                return;
+            if (protocolMode.kind === "v2" &&
+                handshakeSessionId &&
+                message.sessionId !== handshakeSessionId) {
                 warn("sessionId mismatch");
                 return;
             }
             clearHandshakeTimer();
             handshakeDone = true;
             handshakeRetryCount = 0;
-            if (message.hostMethods) {
-                try {
-                    for (var _f = __values(Object.entries(message.hostMethods)), _g = _f.next(); !_g.done; _g = _f.next()) {
-                        var _h = __read(_g.value, 2), k = _h[0], v = _h[1];
-                        hostMethodKinds[k] = v;
-                    }
-                }
-                catch (e_16_1) { e_16 = { error: e_16_1 }; }
-                finally {
-                    try {
-                        if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
-                    }
-                    finally { if (e_16) throw e_16.error; }
-                }
+            if (isDebugEnabled("proto")) {
+                log("Handshake complete, host routes:", Object.keys(message.hostMethods || {}).length +
+                    (message.hostChannels || []).length);
             }
-            if (isDebugEnabled("proto"))
-                log("Handshake complete, hostMethods:", Object.keys(hostMethodKinds).length);
             flushOutbox();
             return;
         case "res": {
@@ -1468,7 +1732,7 @@ function handleIncomingMessage(msg) {
                     info.stream._resolve(message.result);
                     return;
                 }
-                (_b = info.resolve) === null || _b === void 0 ? void 0 : _b.call(info, message.result);
+                (_a = info.resolve) === null || _a === void 0 ? void 0 : _a.call(info, message.result);
             }
             else {
                 var err = toBridgeError(message.error);
@@ -1476,7 +1740,7 @@ function handleIncomingMessage(msg) {
                     info.stream._reject(err);
                     return;
                 }
-                (_c = info.reject) === null || _c === void 0 ? void 0 : _c.call(info, err);
+                (_b = info.reject) === null || _b === void 0 ? void 0 : _b.call(info, err);
             }
             return;
         }
@@ -1506,9 +1770,9 @@ function handleIncomingMessage(msg) {
             pageData = message.state || {};
             stateRev = message.rev;
             if (isDebugEnabled("data")) {
-                console.group("[LX] snapshot");
-                console.log("rev:", stateRev, "state:", deepCopy(pageData));
-                console.groupEnd();
+                nativeConsole.group("[LX] snapshot");
+                nativeConsole.log("rev:", stateRev, "state:", deepCopy(pageData));
+                nativeConsole.groupEnd();
             }
             notifyStateSubscribers(true);
             return;
@@ -1528,9 +1792,9 @@ function handleIncomingMessage(msg) {
                 return;
             }
             if (isDebugEnabled("data")) {
-                console.group("[LX] patch");
-                console.log("rev:", stateRev, "ops:", message.ops);
-                console.groupEnd();
+                nativeConsole.group("[LX] patch");
+                nativeConsole.log("rev:", stateRev, "ops:", message.ops);
+                nativeConsole.groupEnd();
             }
             notifyStateSubscribers(false);
             if (message.ack)
@@ -1571,8 +1835,8 @@ function handleIncomingMessage(msg) {
             var pendingChannel = pendingChannels.get(message.id);
             if (pendingChannel) {
                 rejectPendingChannel(message.id, {
-                    code: (_d = message.code) !== null && _d !== void 0 ? _d : BRIDGE_ERROR.STREAM_CLOSED,
-                    message: (_e = message.reason) !== null && _e !== void 0 ? _e : "Channel closed before opening",
+                    code: (_c = message.code) !== null && _c !== void 0 ? _c : BRIDGE_ERROR.STREAM_CLOSED,
+                    message: (_d = message.reason) !== null && _d !== void 0 ? _d : "Channel closed before opening",
                 });
                 return;
             }
@@ -1636,14 +1900,15 @@ var nativeComponentHandlers = new Map();
 var nativeComponentQueue = [];
 var nativeComponentReady = false;
 function hasNativeComponentHandler() {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     if (typeof window === "undefined")
         return false;
     return !!(((_b = (_a = window.webkit) === null || _a === void 0 ? void 0 : _a.messageHandlers) === null || _b === void 0 ? void 0 : _b.NativeComponent) ||
-        ((_c = window.NativeComponentBridge) === null || _c === void 0 ? void 0 : _c.postMessage));
+        ((_c = window.NativeComponentBridge) === null || _c === void 0 ? void 0 : _c.postMessage) ||
+        ((_d = window.LingXiaProxy) === null || _d === void 0 ? void 0 : _d.nativeComponentUpdate));
 }
 function postNativeComponentMessage(message) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     try {
         if ((_b = (_a = window.webkit) === null || _a === void 0 ? void 0 : _a.messageHandlers) === null || _b === void 0 ? void 0 : _b.NativeComponent) {
             window.webkit.messageHandlers.NativeComponent.postMessage(message);
@@ -1653,6 +1918,18 @@ function postNativeComponentMessage(message) {
             window.NativeComponentBridge.postMessage(stringifyForNative(message));
             return;
         }
+        var update = (_d = window.LingXiaProxy) === null || _d === void 0 ? void 0 : _d.nativeComponentUpdate;
+        if (typeof update === "function") {
+            var componentId = message.id || "island";
+            var payload = stringifyForNative(__assign(__assign({}, message), { componentId: componentId }));
+            try {
+                update.call(window.LingXiaProxy, payload);
+            }
+            catch (_e) {
+                update.call(window.LingXiaProxy, componentId, payload);
+            }
+            return;
+        }
     }
     catch (e) {
         error("NativeComponent send error:", e);
@@ -1888,16 +2165,7 @@ export var LingXiaBridge = {
         }
         messagePort = port;
         port.onmessage = function (event) {
-            var data = event.data;
-            if (typeof data === "string") {
-                try {
-                    data = JSON.parse(data);
-                }
-                catch (_a) {
-                    return;
-                }
-            }
-            handleIncomingMessage(data);
+            handleIncomingMessage(event.data);
         };
         // Some WebView MessagePort implementations (notably Android WebMessagePort)
         // require an explicit start() to begin dispatching onmessage events.
@@ -1909,15 +2177,16 @@ export var LingXiaBridge = {
         startHandshake();
     },
     _receiveEvaluateMessage: function (messageString) {
-        try {
-            if (messageString)
-                handleIncomingMessage(JSON.parse(messageString));
-        }
-        catch (e) {
-            error("Parse error:", e);
-        }
+        if (messageString)
+            handleIncomingMessage(messageString);
     },
     debug: createDebugObject(debugFlags),
+    // The host language, for documents that cannot bundle `@lingxia/bridge` —
+    // browser internal pages and plain-HTML lxapps load this runtime as a script.
+    displayLanguage: {
+        get: getDisplayLanguage,
+        subscribe: subscribeDisplayLanguage,
+    },
     platform: {
         isHarmony: isHarmony,
         isIOS: isIOS,
@@ -1985,23 +2254,23 @@ function wrapNativeStream(handle) {
     var eventListeners = new Set();
     var errorListeners = new Set();
     handle.on("data", function (event) {
-        var e_17, _a;
+        var e_19, _a;
         try {
             for (var eventListeners_1 = __values(eventListeners), eventListeners_1_1 = eventListeners_1.next(); !eventListeners_1_1.done; eventListeners_1_1 = eventListeners_1.next()) {
                 var listener = eventListeners_1_1.value;
                 listener(event);
             }
         }
-        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        catch (e_19_1) { e_19 = { error: e_19_1 }; }
         finally {
             try {
                 if (eventListeners_1_1 && !eventListeners_1_1.done && (_a = eventListeners_1.return)) _a.call(eventListeners_1);
             }
-            finally { if (e_17) throw e_17.error; }
+            finally { if (e_19) throw e_19.error; }
         }
     });
     handle.on("error", function (error) {
-        var e_18, _a;
+        var e_20, _a;
         var nativeError = toNativeError(error);
         try {
             for (var errorListeners_1 = __values(errorListeners), errorListeners_1_1 = errorListeners_1.next(); !errorListeners_1_1.done; errorListeners_1_1 = errorListeners_1.next()) {
@@ -2009,12 +2278,12 @@ function wrapNativeStream(handle) {
                 listener(nativeError);
             }
         }
-        catch (e_18_1) { e_18 = { error: e_18_1 }; }
+        catch (e_20_1) { e_20 = { error: e_20_1 }; }
         finally {
             try {
                 if (errorListeners_1_1 && !errorListeners_1_1.done && (_a = errorListeners_1.return)) _a.call(errorListeners_1);
             }
-            finally { if (e_18) throw e_18.error; }
+            finally { if (e_20) throw e_20.error; }
         }
     });
     return {
@@ -2040,23 +2309,23 @@ function wrapNativeChannel(channel) {
     var messageListeners = new Set();
     var closeListeners = new Set();
     channel.on("data", function (message) {
-        var e_19, _a;
+        var e_21, _a;
         try {
             for (var messageListeners_1 = __values(messageListeners), messageListeners_1_1 = messageListeners_1.next(); !messageListeners_1_1.done; messageListeners_1_1 = messageListeners_1.next()) {
                 var listener = messageListeners_1_1.value;
                 listener(message);
             }
         }
-        catch (e_19_1) { e_19 = { error: e_19_1 }; }
+        catch (e_21_1) { e_21 = { error: e_21_1 }; }
         finally {
             try {
                 if (messageListeners_1_1 && !messageListeners_1_1.done && (_a = messageListeners_1.return)) _a.call(messageListeners_1);
             }
-            finally { if (e_19) throw e_19.error; }
+            finally { if (e_21) throw e_21.error; }
         }
     });
     channel.on("close", function (code, reason) {
-        var e_20, _a;
+        var e_22, _a;
         var event = { code: code, reason: reason };
         try {
             for (var closeListeners_1 = __values(closeListeners), closeListeners_1_1 = closeListeners_1.next(); !closeListeners_1_1.done; closeListeners_1_1 = closeListeners_1.next()) {
@@ -2064,12 +2333,12 @@ function wrapNativeChannel(channel) {
                 listener(event);
             }
         }
-        catch (e_20_1) { e_20 = { error: e_20_1 }; }
+        catch (e_22_1) { e_22 = { error: e_22_1 }; }
         finally {
             try {
                 if (closeListeners_1_1 && !closeListeners_1_1.done && (_a = closeListeners_1.return)) _a.call(closeListeners_1);
             }
-            finally { if (e_20) throw e_20.error; }
+            finally { if (e_22) throw e_22.error; }
         }
     });
     return {
@@ -2112,6 +2381,15 @@ export function initBridge() {
     }
     window.__LX_BRIDGE_INIT_STATE = "initializing";
     try {
+        if (!protocolInitialized) {
+            var activation = consumeV3Bootstrap();
+            protocolMode =
+                activation.kind === "required"
+                    ? { kind: "required-v3", codec: activation.codec }
+                    : { kind: activation.kind === "absent" ? "v2" : "blocked" };
+            protocolInitialized = true;
+        }
+        installBoundV3Console();
         log("Method: ".concat(communicationMethod));
         activateReceiver(LingXiaBridge._receiveEvaluateMessage);
         if (useAppleDownstreamTransport()) {
@@ -2121,7 +2399,15 @@ export function initBridge() {
         }
         else if (communicationMethod === MESSAGE_PORT_TYPE) {
             installMessagePortInitListener();
-            getMessagePort().catch(function (e) { return warn("Port init failed:", e); });
+            var tryPort_1 = function (attempt) {
+                getMessagePort().catch(function (e) {
+                    warn("Port init failed:", e);
+                    if (attempt < 3) {
+                        window.setTimeout(function () { return tryPort_1(attempt + 1); }, 500 * attempt);
+                    }
+                });
+            };
+            tryPort_1(1);
         }
         else if (communicationMethod === "webkit" ||
             communicationMethod === JS_INTERFACE_TYPE ||