@lingxia/bridge 0.5.0 → 0.6.0

package/dist/es5/bridge.js

@@ -0,0 +1,1930 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+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, isDesktop, } from "./runtime-env";
+var NATIVE_HANDLER_NAME = "LingXia";
+var GLOBAL_RECEIVER_NAME = "__LingXiaRecvMessage";
+var DEFAULT_TIMEOUT_MS = 5000;
+var HANDSHAKE_TIMEOUT_MS = 10000;
+var HANDSHAKE_MAX_RETRIES = 3;
+var LOG_PREFIX = "[LX.Bridge]";
+var MESSAGE_PORT_TYPE = "messageport";
+var JS_INTERFACE_TYPE = "jsinterface";
+var OUTBOX_LIMIT = 256;
+var APPLE_DOWNSTREAM_URL = "lx-apple://bridge/downstream";
+var APPLE_RECONNECT_BASE_MS = 200;
+var APPLE_RECONNECT_MAX_MS = 2000;
+var debugFlags = { data: false, proto: false, all: false };
+var earlyNativeMessages = [];
+function installEarlyReceiver() {
+    if (typeof window === "undefined")
+        return;
+    if (typeof window[GLOBAL_RECEIVER_NAME] === "function")
+        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;
+    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 {
+                receiver(message);
+            }
+            catch (err) {
+                warn("Failed to replay queued native message:", err);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (queued_1_1 && !queued_1_1.done && (_a = queued_1.return)) _a.call(queued_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+function isDebugEnabled(flag) {
+    return debugFlags.all || debugFlags[flag];
+}
+function log() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    console.log.apply(console, __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));
+}
+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));
+}
+function safeStringify(obj, space) {
+    var seen = new WeakSet();
+    return JSON.stringify(obj, function (_key, value) {
+        if (typeof value === "object" && value !== null) {
+            if (seen.has(value))
+                return "[Circular]";
+            seen.add(value);
+        }
+        return value;
+    }, space);
+}
+function stringifyForNative(obj) {
+    try {
+        return JSON.stringify(obj);
+    }
+    catch (_a) {
+        return safeStringify(obj);
+    }
+}
+function deepCopy(data) {
+    try {
+        if (typeof structuredClone === "function")
+            return structuredClone(data);
+        return JSON.parse(JSON.stringify(data));
+    }
+    catch (_a) {
+        return {};
+    }
+}
+var communicationMethod = getCommunicationMethod();
+installEarlyReceiver();
+// Transport
+var messagePort = null;
+var appleDownstreamConnected = false;
+var appleDownstreamTask = null;
+var appleDownstreamAbortController = null;
+var appleReconnectTimer = null;
+var appleReconnectDelayMs = APPLE_RECONNECT_BASE_MS;
+var portInitState = {
+    listenerInstalled: false,
+    promise: null,
+    resolve: null,
+    reject: null,
+    timer: null,
+};
+var portInitMessageListener = {
+    handleEvent: function (event) {
+        var _a, _b;
+        var messageEvent = event;
+        if (messageEvent.data !== "LingXia-port-init")
+            return;
+        var port = (_a = messageEvent.ports) === null || _a === void 0 ? void 0 : _a[0];
+        if (!port)
+            return;
+        LingXiaBridge._connectWebMessagePort(port);
+        (_b = portInitState.resolve) === null || _b === void 0 ? void 0 : _b.call(portInitState, port);
+    },
+};
+function installMessagePortInitListener() {
+    if (portInitState.listenerInstalled)
+        return;
+    portInitState.listenerInstalled = true;
+    window.addEventListener("message", portInitMessageListener);
+}
+function cleanupPortInit() {
+    if (portInitState.timer !== null) {
+        window.clearTimeout(portInitState.timer);
+        portInitState.timer = null;
+    }
+    portInitState.resolve = null;
+    portInitState.reject = null;
+    portInitState.promise = null;
+}
+function useAppleDownstreamTransport() {
+    return communicationMethod === "webkit" && (isIOS() || isMacOS());
+}
+function clearAppleReconnectTimer() {
+    if (appleReconnectTimer !== null) {
+        clearTimeout(appleReconnectTimer);
+        appleReconnectTimer = null;
+    }
+}
+function closeActiveChannelsFromTransport(reason) {
+    var e_2, _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];
+            activeChannels.delete(id);
+            channel_1._emitClose(BRIDGE_ERROR.STREAM_CLOSED, reason);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+}
+function rejectAllPendingForTransport(reason) {
+    var e_3, _a, e_4, _b;
+    try {
+        for (var _c = __values(Array.from(pendingReq.keys())), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var id = _d.value;
+            rejectPendingRequest(id, {
+                code: BRIDGE_ERROR.STREAM_CLOSED,
+                message: reason,
+            });
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    try {
+        for (var _e = __values(Array.from(pendingChannels.keys())), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var id = _f.value;
+            rejectPendingChannel(id, {
+                code: BRIDGE_ERROR.STREAM_CLOSED,
+                message: reason,
+            });
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    closeActiveChannelsFromTransport(reason);
+}
+function resetHandshakeState(reason, rejectPending) {
+    clearHandshakeTimer();
+    handshakeSessionId = null;
+    handshakeDone = false;
+    helloSent = false;
+    handshakeRetryCount = 0;
+    if (rejectPending)
+        rejectAllPendingForTransport(reason);
+}
+function processAppleDownstreamBuffer(buffer) {
+    var remaining = buffer;
+    while (true) {
+        var newlineIndex = remaining.indexOf("\n");
+        if (newlineIndex < 0)
+            break;
+        var line = remaining.slice(0, newlineIndex).trim();
+        remaining = remaining.slice(newlineIndex + 1);
+        if (!line)
+            continue;
+        try {
+            handleIncomingMessage(JSON.parse(line));
+        }
+        catch (e) {
+            warn("Apple downstream parse error:", e, line);
+        }
+    }
+    return remaining;
+}
+function runAppleDownstream() {
+    return __awaiter(this, void 0, void 0, function () {
+        var controller, response, e_5, reader, decoder, buffered, _a, value, done, tail;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = new AbortController();
+                    appleDownstreamAbortController = controller;
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, fetch(APPLE_DOWNSTREAM_URL, {
+                            method: "GET",
+                            cache: "no-store",
+                            headers: { Accept: "application/x-ndjson" },
+                            signal: controller.signal,
+                        })];
+                case 2:
+                    response = _b.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    e_5 = _b.sent();
+                    if (controller.signal.aborted)
+                        return [2 /*return*/];
+                    throw e_5;
+                case 4:
+                    if (!response.ok) {
+                        throw new Error("Apple downstream HTTP ".concat(response.status));
+                    }
+                    if (!response.body) {
+                        throw new Error("Apple downstream response body unavailable");
+                    }
+                    appleDownstreamConnected = true;
+                    appleReconnectDelayMs = APPLE_RECONNECT_BASE_MS;
+                    if (isDebugEnabled("proto"))
+                        log("Apple downstream connected");
+                    startHandshake();
+                    reader = response.body.getReader();
+                    decoder = new TextDecoder();
+                    buffered = "";
+                    _b.label = 5;
+                case 5:
+                    _b.trys.push([5, , 9, 10]);
+                    _b.label = 6;
+                case 6:
+                    if (!true) return [3 /*break*/, 8];
+                    return [4 /*yield*/, reader.read()];
+                case 7:
+                    _a = _b.sent(), value = _a.value, done = _a.done;
+                    if (done)
+                        return [3 /*break*/, 8];
+                    buffered += decoder.decode(value, { stream: true });
+                    buffered = processAppleDownstreamBuffer(buffered);
+                    return [3 /*break*/, 6];
+                case 8:
+                    buffered += decoder.decode();
+                    tail = buffered.trim();
+                    if (tail) {
+                        try {
+                            handleIncomingMessage(JSON.parse(tail));
+                        }
+                        catch (e) {
+                            warn("Apple downstream trailing parse error:", e, tail);
+                        }
+                    }
+                    return [3 /*break*/, 10];
+                case 9:
+                    try {
+                        reader.releaseLock();
+                    }
+                    catch (_c) { }
+                    return [7 /*endfinally*/];
+                case 10: return [2 /*return*/];
+            }
+        });
+    });
+}
+function scheduleAppleDownstreamReconnect(reason) {
+    if (!useAppleDownstreamTransport())
+        return;
+    clearAppleReconnectTimer();
+    var delay = appleReconnectDelayMs;
+    appleReconnectDelayMs = Math.min(appleReconnectDelayMs * 2, APPLE_RECONNECT_MAX_MS);
+    var message = "Apple downstream disconnected, retrying in ".concat(delay, "ms: ").concat(reason);
+    if (delay <= APPLE_RECONNECT_BASE_MS) {
+        log(message);
+    }
+    else {
+        warn(message);
+    }
+    appleReconnectTimer = setTimeout(function () {
+        appleReconnectTimer = null;
+        ensureAppleDownstream();
+    }, delay);
+}
+function ensureAppleDownstream() {
+    if (!useAppleDownstreamTransport())
+        return;
+    if (appleDownstreamTask)
+        return;
+    clearAppleReconnectTimer();
+    appleDownstreamTask = runAppleDownstream()
+        .catch(function (e) {
+        if (appleDownstreamAbortController === null || appleDownstreamAbortController === void 0 ? void 0 : appleDownstreamAbortController.signal.aborted)
+            return;
+        warn("Apple downstream failed:", e);
+    })
+        .finally(function () {
+        var _a;
+        var aborted = (_a = appleDownstreamAbortController === null || appleDownstreamAbortController === void 0 ? void 0 : appleDownstreamAbortController.signal.aborted) !== null && _a !== void 0 ? _a : false;
+        appleDownstreamTask = null;
+        appleDownstreamAbortController = null;
+        var wasConnected = appleDownstreamConnected;
+        appleDownstreamConnected = false;
+        resetHandshakeState("Apple downstream closed", wasConnected);
+        if (!aborted)
+            scheduleAppleDownstreamReconnect("stream closed");
+    });
+}
+function getMessagePort() {
+    var _a, _b;
+    if (messagePort)
+        return Promise.resolve(messagePort);
+    if (portInitState.promise)
+        return portInitState.promise;
+    var timeoutMs = 5000;
+    installMessagePortInitListener();
+    portInitState.promise = new Promise(function (resolve, reject) {
+        portInitState.resolve = function (port) {
+            cleanupPortInit();
+            resolve(port);
+        };
+        portInitState.reject = function (err) {
+            cleanupPortInit();
+            reject(err);
+        };
+        portInitState.timer = window.setTimeout(function () {
+            var _a;
+            (_a = portInitState.reject) === null || _a === void 0 ? void 0 : _a.call(portInitState, new Error("MessagePort init timed out after ".concat(timeoutMs, "ms")));
+        }, timeoutMs);
+    });
+    try {
+        (_a = window.LingXiaProxy) === null || _a === void 0 ? void 0 : _a.getPort("LingXiaPort");
+    }
+    catch (e) {
+        (_b = portInitState.reject) === null || _b === void 0 ? void 0 : _b.call(portInitState, e);
+    }
+    return portInitState.promise;
+}
+function postToNative(message) {
+    var _a, _b, _c;
+    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));
+    try {
+        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;
+        }
+        var messageString = stringifyForNative(message);
+        if (communicationMethod === MESSAGE_PORT_TYPE && messagePort) {
+            messagePort.postMessage(messageString);
+            return;
+        }
+        if (communicationMethod === JS_INTERFACE_TYPE &&
+            ((_c = window.LingXiaProxy) === null || _c === void 0 ? void 0 : _c.postMessage)) {
+            window.LingXiaProxy.postMessage(messageString);
+            return;
+        }
+        warn("Transport not ready");
+    }
+    catch (e) {
+        error("Send error:", e);
+    }
+}
+// Handshake state
+var handshakeSessionId = null;
+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() {
+    return {
+        data: new Set(),
+        end: new Set(),
+        error: new Set(),
+        close: new Set(),
+    };
+}
+function createStreamHandle(id, cancelFn) {
+    var _a;
+    var listeners = createListenerBuckets();
+    var done = false;
+    var resolveResult = function () { };
+    var rejectResult = function () { };
+    var pendingData = [];
+    var pendingReads = [];
+    var result = new Promise(function (resolve, reject) {
+        resolveResult = resolve;
+        rejectResult = reject;
+    });
+    var handle = (_a = {
+            id: id,
+            result: result,
+            on: function (event, listener) {
+                if (event === "data")
+                    listeners.data.add(listener);
+                if (event === "end")
+                    listeners.end.add(listener);
+                if (event === "error")
+                    listeners.error.add(listener);
+                return this;
+            }
+        },
+        _a[Symbol.asyncIterator] = function () {
+            return {
+                next: function () {
+                    if (pendingData.length > 0) {
+                        return Promise.resolve({
+                            done: false,
+                            value: pendingData.shift(),
+                        });
+                    }
+                    if (done) {
+                        return result.then(function (finalValue) { return ({ done: true, value: finalValue }); }, function (err) { return Promise.reject(err); });
+                    }
+                    return new Promise(function (resolve, reject) {
+                        pendingReads.push({ resolve: resolve, reject: reject });
+                    });
+                },
+            };
+        },
+        _a.cancel = function () {
+            if (done)
+                return;
+            cancelFn();
+        },
+        _a._emitData = function (payload) {
+            var e_6, _a;
+            if (done)
+                return;
+            if (pendingReads.length > 0) {
+                pendingReads.shift().resolve({ done: false, value: payload });
+            }
+            else {
+                pendingData.push(payload);
+            }
+            try {
+                for (var _b = __values(listeners.data), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var listener = _c.value;
+                    try {
+                        listener(payload);
+                    }
+                    catch (e) {
+                        warn("Stream data listener failed:", e);
+                    }
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+        },
+        _a._resolve = function (resultValue) {
+            var e_7, _a;
+            if (done)
+                return;
+            done = true;
+            resolveResult(resultValue);
+            while (pendingReads.length > 0) {
+                pendingReads.shift().resolve({ done: true, value: resultValue });
+            }
+            try {
+                for (var _b = __values(listeners.end), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var listener = _c.value;
+                    try {
+                        listener(resultValue);
+                    }
+                    catch (e) {
+                        warn("Stream end listener failed:", e);
+                    }
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+        },
+        _a._reject = function (err) {
+            var e_8, _a;
+            if (done)
+                return;
+            done = true;
+            rejectResult(err);
+            while (pendingReads.length > 0) {
+                pendingReads.shift().reject(err);
+            }
+            try {
+                for (var _b = __values(listeners.error), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var listener = _c.value;
+                    try {
+                        listener(err);
+                    }
+                    catch (e) {
+                        warn("Stream error listener failed:", e);
+                    }
+                }
+            }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
+        },
+        _a);
+    return handle;
+}
+function createChannel(id, sendFn, closeFn) {
+    var _a;
+    var listeners = createListenerBuckets();
+    var open = false;
+    var outboundSeq = 0;
+    var closed = false;
+    var pendingData = [];
+    var pendingReads = [];
+    var channel = (_a = {
+            id: id,
+            send: function (payload) {
+                if (!open) {
+                    channel._reject({
+                        code: BRIDGE_ERROR.STREAM_CLOSED,
+                        message: "Channel '".concat(id, "' is closed"),
+                    });
+                    return;
+                }
+                sendFn(payload, outboundSeq++);
+            },
+            on: function (event, listener) {
+                if (event === "data")
+                    listeners.data.add(listener);
+                if (event === "close")
+                    listeners.close.add(listener);
+                if (event === "error")
+                    listeners.error.add(listener);
+                return this;
+            }
+        },
+        _a[Symbol.asyncIterator] = function () {
+            return {
+                next: function () {
+                    if (pendingData.length > 0) {
+                        return Promise.resolve({
+                            done: false,
+                            value: pendingData.shift(),
+                        });
+                    }
+                    if (closed) {
+                        return Promise.resolve({ done: true, value: undefined });
+                    }
+                    return new Promise(function (resolve, reject) {
+                        pendingReads.push({ resolve: resolve, reject: reject });
+                    });
+                },
+            };
+        },
+        _a.close = function (code, reason) {
+            if (!open)
+                return;
+            open = false;
+            closed = true;
+            closeFn(code, reason);
+            channel._emitClose(code, reason);
+        },
+        _a._emitData = function (payload) {
+            var e_9, _a;
+            if (!open)
+                return;
+            if (pendingReads.length > 0) {
+                pendingReads.shift().resolve({ done: false, value: payload });
+            }
+            else {
+                pendingData.push(payload);
+            }
+            try {
+                for (var _b = __values(listeners.data), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var listener = _c.value;
+                    try {
+                        listener(payload);
+                    }
+                    catch (e) {
+                        warn("Channel listener failed:", e);
+                    }
+                }
+            }
+            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_9) throw e_9.error; }
+            }
+        },
+        _a._emitClose = function (code, reason) {
+            var e_10, _a;
+            closed = true;
+            while (pendingReads.length > 0) {
+                pendingReads.shift().resolve({ done: true, value: undefined });
+            }
+            try {
+                for (var _b = __values(listeners.close), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var listener = _c.value;
+                    try {
+                        listener(code, reason);
+                    }
+                    catch (e) {
+                        warn("Channel close listener failed:", e);
+                    }
+                }
+            }
+            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_10) throw e_10.error; }
+            }
+        },
+        _a._reject = function (err) {
+            var e_11, _a;
+            closed = true;
+            while (pendingReads.length > 0) {
+                pendingReads.shift().reject(err);
+            }
+            try {
+                for (var _b = __values(listeners.error), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var listener = _c.value;
+                    try {
+                        listener(err);
+                    }
+                    catch (e) {
+                        warn("Channel error listener failed:", e);
+                    }
+                }
+            }
+            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_11) throw e_11.error; }
+            }
+        },
+        _a._markOpen = function () {
+            open = true;
+            closed = false;
+        },
+        _a._isOpen = function () {
+            return open;
+        },
+        _a._nextSeq = function () {
+            return outboundSeq++;
+        },
+        _a);
+    return channel;
+}
+var pendingReq = new Map();
+var pendingChannels = new Map();
+var activeChannels = new Map();
+var outbox = [];
+// State sync
+var stateRev = -1;
+var pageData = {};
+var dataSubscribers = new Set();
+var subscriberInitStatus = new WeakMap();
+// Logic→View method handlers (for incoming req from native side)
+var viewMethodHandlers = new Map();
+export function registerViewMethodHandler(method, handler) {
+    viewMethodHandlers.set(method, handler);
+}
+function inferCap(method) {
+    if (method.startsWith("host."))
+        return "host";
+    var i = method.indexOf(".");
+    return i > 0 ? method.slice(0, i) : "page";
+}
+function normalizeParams(params) {
+    if (params === null || params === undefined)
+        return undefined;
+    return params;
+}
+function isTransportReady() {
+    if (communicationMethod === MESSAGE_PORT_TYPE)
+        return !!messagePort;
+    if (useAppleDownstreamTransport())
+        return appleDownstreamConnected;
+    return (communicationMethod === "webkit" ||
+        communicationMethod === JS_INTERFACE_TYPE);
+}
+function canSendAppMessages() {
+    return isTransportReady() && handshakeDone;
+}
+function rejectPendingRequest(reqId, err) {
+    var _a;
+    var info = pendingReq.get(reqId);
+    if (info) {
+        pendingReq.delete(reqId);
+        if (info.timerId !== null)
+            clearTimeout(info.timerId);
+        var normalized = toBridgeError(err);
+        if (info.mode === "stream" && info.stream) {
+            info.stream._reject(normalized);
+            return;
+        }
+        (_a = info.reject) === null || _a === void 0 ? void 0 : _a.call(info, normalized);
+    }
+}
+function rejectPendingChannel(id, err) {
+    var pending = pendingChannels.get(id);
+    if (!pending)
+        return;
+    pendingChannels.delete(id);
+    if (pending.timerId !== null)
+        clearTimeout(pending.timerId);
+    var normalized = toBridgeError(err);
+    pending.channel._reject(normalized);
+    pending.reject(normalized);
+}
+function rejectPendingOperation(id, err) {
+    if (pendingReq.has(id)) {
+        rejectPendingRequest(id, err);
+        return;
+    }
+    if (pendingChannels.has(id)) {
+        rejectPendingChannel(id, err);
+    }
+}
+function armRequestTimer(reqId) {
+    var info = pendingReq.get(reqId);
+    if (!info)
+        return;
+    if (!Number.isFinite(info.timeoutMs) || info.timeoutMs <= 0) {
+        if (info.timerId !== null) {
+            clearTimeout(info.timerId);
+            info.timerId = null;
+        }
+        return;
+    }
+    if (info.timerId !== null)
+        clearTimeout(info.timerId);
+    info.timerId = setTimeout(function () {
+        if (!pendingReq.has(reqId))
+            return;
+        rejectPendingRequest(reqId, {
+            code: BRIDGE_ERROR.TIMEOUT,
+            message: "'".concat(info.method, "' timed out"),
+        });
+    }, info.timeoutMs);
+}
+function armChannelTimer(id) {
+    var pending = pendingChannels.get(id);
+    if (!pending)
+        return;
+    if (pending.timerId !== null)
+        clearTimeout(pending.timerId);
+    pending.timerId = setTimeout(function () {
+        rejectPendingChannel(id, {
+            code: BRIDGE_ERROR.TIMEOUT,
+            message: "Channel '".concat(pending.topic, "' timed out"),
+        });
+    }, DEFAULT_TIMEOUT_MS);
+}
+function armPendingOperationTimer(id) {
+    if (pendingReq.has(id)) {
+        armRequestTimer(id);
+        return;
+    }
+    if (pendingChannels.has(id)) {
+        armChannelTimer(id);
+    }
+}
+function removeOutboxByReqId(reqId) {
+    var _a;
+    for (var i = outbox.length - 1; i >= 0; i--) {
+        if (((_a = outbox[i]) === null || _a === void 0 ? void 0 : _a.reqId) === reqId) {
+            outbox.splice(i, 1);
+            return true;
+        }
+    }
+    return false;
+}
+function send(msg, reqId) {
+    var kind = msg.kind;
+    var isHandshake = kind === "hello" || kind === "helloAck" || kind === "ready";
+    if (!canSendAppMessages() && !isHandshake) {
+        if (outbox.length >= OUTBOX_LIMIT) {
+            error("Outbox full");
+            if (reqId) {
+                rejectPendingOperation(reqId, {
+                    code: BRIDGE_ERROR.OUTBOX_FULL,
+                    message: "Bridge outbox is full",
+                });
+            }
+            return;
+        }
+        outbox.push({ msg: msg, reqId: reqId });
+        return;
+    }
+    if (reqId)
+        armPendingOperationTimer(reqId);
+    postToNative(msg);
+}
+function flushOutbox() {
+    if (!canSendAppMessages())
+        return;
+    while (outbox.length) {
+        var item = outbox.shift();
+        if (!item)
+            continue;
+        if (item.reqId)
+            armPendingOperationTimer(item.reqId);
+        postToNative(item.msg);
+    }
+}
+function clearHandshakeTimer() {
+    if (handshakeTimer !== null) {
+        clearTimeout(handshakeTimer);
+        handshakeTimer = null;
+    }
+}
+function startHandshake() {
+    if (handshakeDone)
+        return;
+    if (!isTransportReady())
+        return;
+    clearHandshakeTimer();
+    var hello = {
+        v: 2,
+        kind: "hello",
+        nonce: BRIDGE_CONFIG.nonce || "",
+        role: "view",
+        protocolsSupported: [2],
+    };
+    helloSent = true;
+    postToNative(hello);
+    handshakeTimer = setTimeout(function () {
+        var e_12, _a;
+        if (handshakeDone)
+            return;
+        handshakeRetryCount++;
+        if (handshakeRetryCount < HANDSHAKE_MAX_RETRIES) {
+            warn("Handshake timeout (".concat(handshakeRetryCount, "/").concat(HANDSHAKE_MAX_RETRIES, "), retrying..."));
+            helloSent = false;
+            startHandshake();
+        }
+        else {
+            error("Handshake failed");
+            clearHandshakeTimer();
+            helloSent = false;
+            handshakeRetryCount = 0;
+            while (outbox.length) {
+                var item = outbox.shift();
+                if (item === null || item === void 0 ? void 0 : item.reqId) {
+                    rejectPendingOperation(item.reqId, {
+                        code: BRIDGE_ERROR.HANDSHAKE_FAILED,
+                        message: "Bridge handshake failed",
+                    });
+                }
+            }
+            try {
+                for (var _b = __values(Array.from(pendingChannels.keys())), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var id = _c.value;
+                    rejectPendingChannel(id, {
+                        code: BRIDGE_ERROR.HANDSHAKE_FAILED,
+                        message: "Bridge handshake failed",
+                    });
+                }
+            }
+            catch (e_12_1) { e_12 = { error: e_12_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_12) throw e_12.error; }
+            }
+        }
+    }, HANDSHAKE_TIMEOUT_MS);
+}
+function parseIncoming(msg) {
+    if (!msg || typeof msg !== "object")
+        return null;
+    var v = msg.v;
+    var kind = msg.kind;
+    if (v !== 2 || typeof kind !== "string")
+        return null;
+    return msg;
+}
+// JSON Patch
+function jsonPointerUnescape(seg) {
+    return seg.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function parseJsonPointer(path) {
+    if (path === "")
+        return [];
+    if (!path.startsWith("/"))
+        throw new Error("Invalid JSON pointer: ".concat(path));
+    return path.split("/").slice(1).map(jsonPointerUnescape);
+}
+function getContainerAndKey(root, pointer, autoCreate) {
+    if (autoCreate === void 0) { autoCreate = false; }
+    var segments = parseJsonPointer(pointer);
+    if (segments.length === 0)
+        return { container: { $root: root }, key: "$root" };
+    var current = root;
+    for (var i = 0; i < segments.length - 1; i++) {
+        var seg = segments[i];
+        if (Array.isArray(current)) {
+            current = current[Number(seg)];
+        }
+        else if (current && typeof current === "object") {
+            var obj = current;
+            if (autoCreate && obj[seg] === undefined) {
+                var nextSeg = segments[i + 1];
+                obj[seg] = nextSeg && /^\d+$/.test(nextSeg) ? [] : {};
+            }
+            current = obj[seg];
+        }
+        else {
+            throw new Error("Invalid container at ".concat(seg));
+        }
+    }
+    return { container: current, key: segments[segments.length - 1] };
+}
+function applyJsonPatch(target, ops) {
+    var e_13, _a, e_14, _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;
+            var autoCreate = op.op === "add" || op.op === "replace";
+            var _c = getContainerAndKey(target, op.path, autoCreate), container = _c.container, key = _c.key;
+            if (key === "$root") {
+                try {
+                    for (var _d = (e_14 = void 0, __values(Object.keys(target))), _e = _d.next(); !_e.done; _e = _d.next()) {
+                        var k = _e.value;
+                        delete target[k];
+                    }
+                }
+                catch (e_14_1) { e_14 = { error: e_14_1 }; }
+                finally {
+                    try {
+                        if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
+                    }
+                    finally { if (e_14) throw e_14.error; }
+                }
+                if (op.op !== "remove") {
+                    var v = op.value;
+                    if (v && typeof v === "object")
+                        Object.assign(target, v);
+                }
+                continue;
+            }
+            if (Array.isArray(container)) {
+                var idx = key === "-" ? container.length : Number(key);
+                if (!Number.isFinite(idx) || idx < 0)
+                    throw new Error("Invalid index");
+                if (op.op === "remove")
+                    container.splice(idx, 1);
+                else if (op.op === "add")
+                    container.splice(idx, 0, op.value);
+                else if (op.op === "replace")
+                    container[idx] = op.value;
+                continue;
+            }
+            if (!container || typeof container !== "object")
+                throw new Error("Invalid container");
+            var obj = container;
+            if (op.op === "remove")
+                delete obj[key];
+            else
+                obj[key] = op.value;
+        }
+    }
+    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+    finally {
+        try {
+            if (ops_1_1 && !ops_1_1.done && (_a = ops_1.return)) _a.call(ops_1);
+        }
+        finally { if (e_13) throw e_13.error; }
+    }
+}
+function notifyStateSubscribers(initial) {
+    dataSubscribers.forEach(function (listener) {
+        try {
+            if (!subscriberInitStatus.has(listener)) {
+                subscriberInitStatus.set(listener, true);
+                listener(deepCopy(pageData), { rev: stateRev, initial: true });
+                return;
+            }
+            listener(deepCopy(pageData), { rev: stateRev, initial: initial });
+        }
+        catch (e) {
+            warn("Subscriber error:", e);
+        }
+    });
+}
+function subscribeState(callback) {
+    if (typeof callback !== "function")
+        return function () { };
+    dataSubscribers.add(callback);
+    if (stateRev >= 0) {
+        subscriberInitStatus.set(callback, true);
+        try {
+            callback(deepCopy(pageData), { rev: stateRev, initial: true });
+        }
+        catch (e) {
+            error("Callback error:", e);
+        }
+    }
+    return function () {
+        dataSubscribers.delete(callback);
+        subscriberInitStatus.delete(callback);
+    };
+}
+function requestStateRecovery(scope) {
+    rawBridge.call("state.getSnapshot", { scope: scope }).catch(function () { });
+}
+function applySnapshotFromResult(result) {
+    if (!result || typeof result !== "object")
+        return false;
+    var obj = result;
+    if (typeof obj.rev !== "number" || !Number.isFinite(obj.rev))
+        return false;
+    if (!obj.state || typeof obj.state !== "object")
+        return false;
+    pageData = obj.state;
+    stateRev = obj.rev;
+    if (isDebugEnabled("data")) {
+        console.group("[LX] snapshot(res)");
+        console.log("rev:", stateRev, "state:", deepCopy(pageData));
+        console.groupEnd();
+    }
+    notifyStateSubscribers(true);
+    return true;
+}
+function handleIncomingMessage(msg) {
+    var e_15, _a;
+    var _b, _c;
+    // Handle native component events (from Android NativeBridge.sendEventToView)
+    if (msg && typeof msg === "object") {
+        var obj = msg;
+        if (obj.type === "event" && obj.name === "nativecomponent" && obj.payload) {
+            var payload = obj.payload;
+            var componentId = payload.id ||
+                payload.componentId;
+            if (typeof componentId === "string") {
+                var handler = nativeComponentHandlers.get(componentId);
+                if (handler) {
+                    try {
+                        handler(payload);
+                    }
+                    catch (e) {
+                        error("NC handler error:", e);
+                    }
+                }
+            }
+            return;
+        }
+    }
+    var message = parseIncoming(msg);
+    if (!message) {
+        warn("Invalid V2 message:", msg);
+        return;
+    }
+    switch (message.kind) {
+        case "helloAck":
+            handshakeSessionId = message.sessionId;
+            return;
+        case "ready":
+            if (handshakeSessionId && message.sessionId !== handshakeSessionId) {
+                warn("sessionId mismatch");
+                return;
+            }
+            clearHandshakeTimer();
+            handshakeDone = true;
+            handshakeRetryCount = 0;
+            if (message.hostMethods) {
+                try {
+                    for (var _d = __values(Object.entries(message.hostMethods)), _e = _d.next(); !_e.done; _e = _d.next()) {
+                        var _f = __read(_e.value, 2), k = _f[0], v = _f[1];
+                        hostMethodKinds[k] = v;
+                    }
+                }
+                catch (e_15_1) { e_15 = { error: e_15_1 }; }
+                finally {
+                    try {
+                        if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                    }
+                    finally { if (e_15) throw e_15.error; }
+                }
+            }
+            if (isDebugEnabled("proto"))
+                log("Handshake complete, hostMethods:", Object.keys(hostMethodKinds).length);
+            flushOutbox();
+            return;
+        case "res": {
+            var info = pendingReq.get(message.id);
+            if (!info)
+                return;
+            pendingReq.delete(message.id);
+            if (info.timerId !== null)
+                clearTimeout(info.timerId);
+            if (message.ok) {
+                if (info.method === "state.getSnapshot") {
+                    if (!applySnapshotFromResult(message.result)) {
+                        warn("Invalid state.getSnapshot result");
+                    }
+                }
+                if (info.mode === "stream" && info.stream) {
+                    info.stream._resolve(message.result);
+                    return;
+                }
+                (_b = info.resolve) === null || _b === void 0 ? void 0 : _b.call(info, message.result);
+            }
+            else {
+                var err = toBridgeError(message.error);
+                if (info.mode === "stream" && info.stream) {
+                    info.stream._reject(err);
+                    return;
+                }
+                (_c = info.reject) === null || _c === void 0 ? void 0 : _c.call(info, err);
+            }
+            return;
+        }
+        case "event": {
+            if (pendingReq.has(message.id)) {
+                var req = pendingReq.get(message.id);
+                if ((req === null || req === void 0 ? void 0 : req.mode) === "stream" && req.stream) {
+                    armRequestTimer(message.id);
+                    req.stream._emitData(message.payload);
+                }
+                else {
+                    warn("Received event for non-stream request '".concat(message.id, "'"));
+                }
+                return;
+            }
+            return;
+        }
+        case "state.snapshot":
+            pageData = message.state || {};
+            stateRev = message.rev;
+            if (isDebugEnabled("data")) {
+                console.group("[LX] snapshot");
+                console.log("rev:", stateRev, "state:", deepCopy(pageData));
+                console.groupEnd();
+            }
+            notifyStateSubscribers(true);
+            return;
+        case "state.patch":
+            if (message.baseRev !== stateRev) {
+                warn("baseRev mismatch", { have: stateRev, want: message.baseRev });
+                requestStateRecovery(message.scope);
+                return;
+            }
+            try {
+                applyJsonPatch(pageData, message.ops || []);
+                stateRev = message.rev;
+            }
+            catch (e) {
+                error("Patch failed:", e);
+                requestStateRecovery(message.scope);
+                return;
+            }
+            if (isDebugEnabled("data")) {
+                console.group("[LX] patch");
+                console.log("rev:", stateRev, "ops:", message.ops);
+                console.groupEnd();
+            }
+            notifyStateSubscribers(false);
+            if (message.ack)
+                send({
+                    v: 2,
+                    kind: "state.ack",
+                    scope: message.scope,
+                    rev: message.rev,
+                });
+            return;
+        case "ch.ack": {
+            var pendingChannel = pendingChannels.get(message.id);
+            if (!pendingChannel)
+                return;
+            pendingChannels.delete(message.id);
+            if (pendingChannel.timerId !== null)
+                clearTimeout(pendingChannel.timerId);
+            if (message.ok) {
+                pendingChannel.channel._markOpen();
+                activeChannels.set(message.id, pendingChannel.channel);
+                pendingChannel.resolve(pendingChannel.channel);
+            }
+            else {
+                var err = toBridgeError(message.error);
+                pendingChannel.channel._reject(err);
+                pendingChannel.reject(err);
+            }
+            return;
+        }
+        case "ch.data": {
+            var channel_2 = activeChannels.get(message.id);
+            if (!channel_2)
+                return;
+            channel_2._emitData(message.payload);
+            return;
+        }
+        case "ch.close": {
+            var pendingChannel = pendingChannels.get(message.id);
+            if (pendingChannel) {
+                pendingChannels.delete(message.id);
+                pendingChannel.channel._emitClose(message.code, message.reason);
+                return;
+            }
+            var channel_3 = activeChannels.get(message.id);
+            if (!channel_3)
+                return;
+            activeChannels.delete(message.id);
+            channel_3._emitClose(message.code, message.reason);
+            return;
+        }
+        case "req": {
+            var reqMsg_1 = message;
+            var requiredCap = inferCap(reqMsg_1.method);
+            if (!reqMsg_1.cap || reqMsg_1.cap !== requiredCap) {
+                send({
+                    v: 2,
+                    kind: "res",
+                    id: reqMsg_1.id,
+                    ok: false,
+                    error: {
+                        code: BRIDGE_ERROR.CAPABILITY_DENIED,
+                        message: "Invalid cap for ".concat(reqMsg_1.method),
+                    },
+                });
+                return;
+            }
+            var handler_1 = viewMethodHandlers.get(reqMsg_1.method);
+            if (!handler_1) {
+                send({
+                    v: 2,
+                    kind: "res",
+                    id: reqMsg_1.id,
+                    ok: false,
+                    error: {
+                        code: BRIDGE_ERROR.METHOD_NOT_FOUND,
+                        message: "View handler not found: ".concat(reqMsg_1.method),
+                    },
+                });
+                return;
+            }
+            Promise.resolve()
+                .then(function () { return handler_1(reqMsg_1.params); })
+                .then(function (result) {
+                send({ v: 2, kind: "res", id: reqMsg_1.id, ok: true, result: result });
+            })
+                .catch(function (err) {
+                send({
+                    v: 2,
+                    kind: "res",
+                    id: reqMsg_1.id,
+                    ok: false,
+                    error: toBridgeError(err),
+                });
+            });
+            return;
+        }
+    }
+}
+// Native components
+var nativeComponentHandlers = new Map();
+var nativeComponentQueue = [];
+var nativeComponentReady = false;
+function hasNativeComponentHandler() {
+    var _a, _b, _c;
+    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));
+}
+function postNativeComponentMessage(message) {
+    var _a, _b, _c;
+    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);
+            return;
+        }
+        if ((_c = window.NativeComponentBridge) === null || _c === void 0 ? void 0 : _c.postMessage) {
+            window.NativeComponentBridge.postMessage(stringifyForNative(message));
+            return;
+        }
+    }
+    catch (e) {
+        error("NativeComponent send error:", e);
+    }
+}
+function flushNativeComponentQueue() {
+    if (!hasNativeComponentHandler() || nativeComponentQueue.length === 0)
+        return;
+    nativeComponentReady = true;
+    while (nativeComponentQueue.length) {
+        var msg = nativeComponentQueue.shift();
+        try {
+            postNativeComponentMessage(msg);
+        }
+        catch (_a) {
+            break;
+        }
+    }
+}
+function sendNativeComponentMessage(message) {
+    try {
+        if (!hasNativeComponentHandler()) {
+            nativeComponentQueue.push(message);
+            return;
+        }
+        if (!nativeComponentReady)
+            flushNativeComponentQueue();
+        postNativeComponentMessage(message);
+    }
+    catch (e) {
+        error("NC send failed:", e);
+    }
+}
+function nextMessageId(prefix) {
+    return "".concat(prefix, "_").concat(Date.now(), "_").concat(requestCounter++);
+}
+function attachAbortSignal(id, signal, onAbort) {
+    if (!signal)
+        return;
+    if (signal.aborted) {
+        onAbort();
+        return;
+    }
+    var abortListener;
+    abortListener = {
+        handleEvent: function () {
+            signal.removeEventListener("abort", abortListener);
+            onAbort();
+        },
+    };
+    signal.addEventListener("abort", abortListener);
+}
+// Low-level protocol interface. Public consumers should use LingXiaBridge.invoke/stream/channel.
+var rawBridge = {
+    call: function (method, params, options) {
+        return new Promise(function (resolve, reject) {
+            var _a;
+            if (!method || typeof method !== "string") {
+                reject({
+                    code: BRIDGE_ERROR.MALFORMED_MESSAGE,
+                    message: "Method name must be a non-empty string",
+                });
+                return;
+            }
+            if (!helloSent)
+                startHandshake();
+            var id = nextMessageId("c");
+            var cap = (options === null || options === void 0 ? void 0 : options.cap) || inferCap(method);
+            var timeoutMs = (_a = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _a !== void 0 ? _a : DEFAULT_TIMEOUT_MS;
+            pendingReq.set(id, {
+                method: method,
+                mode: "call",
+                resolve: resolve,
+                reject: function (e) { return reject(e); },
+                timeoutMs: timeoutMs,
+                timerId: null,
+            });
+            var req = {
+                v: 2,
+                kind: "req",
+                id: id,
+                method: method,
+                params: normalizeParams(params),
+                cap: cap,
+            };
+            send(req, id);
+            attachAbortSignal(id, options === null || options === void 0 ? void 0 : options.signal, function () {
+                var removed = removeOutboxByReqId(id);
+                rejectPendingRequest(id, {
+                    code: BRIDGE_ERROR.CANCELED,
+                    message: "Bridge request aborted",
+                });
+                if (!removed && handshakeDone)
+                    send({ v: 2, kind: "cancel", id: id });
+            });
+        });
+    },
+    stream: function (method, params, options) {
+        var _a;
+        if (!method || typeof method !== "string") {
+            var invalid = createStreamHandle("invalid", function () { });
+            invalid._reject({
+                code: BRIDGE_ERROR.MALFORMED_MESSAGE,
+                message: "Method name must be a non-empty string",
+            });
+            return invalid;
+        }
+        if (!helloSent)
+            startHandshake();
+        var id = nextMessageId("c");
+        var handle = createStreamHandle(id, function () {
+            var removed = removeOutboxByReqId(id);
+            if (removed) {
+                rejectPendingRequest(id, {
+                    code: BRIDGE_ERROR.CANCELED,
+                    message: "Bridge request aborted",
+                });
+                return;
+            }
+            if (handshakeDone)
+                send({ v: 2, kind: "cancel", id: id });
+        });
+        var cap = (options === null || options === void 0 ? void 0 : options.cap) || inferCap(method);
+        var timeoutMs = (_a = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _a !== void 0 ? _a : DEFAULT_TIMEOUT_MS;
+        pendingReq.set(id, {
+            method: method,
+            mode: "stream",
+            stream: handle,
+            timeoutMs: timeoutMs,
+            timerId: null,
+        });
+        send({
+            v: 2,
+            kind: "req",
+            id: id,
+            method: method,
+            params: normalizeParams(params),
+            cap: cap,
+        }, id);
+        attachAbortSignal(id, options === null || options === void 0 ? void 0 : options.signal, function () { return handle.cancel(); });
+        return handle;
+    },
+    notify: function (method, params, options) {
+        if (!method || typeof method !== "string")
+            return;
+        if (!helloSent)
+            startHandshake();
+        send({
+            v: 2,
+            kind: "notify",
+            method: method,
+            params: normalizeParams(params),
+            cap: (options === null || options === void 0 ? void 0 : options.cap) || inferCap(method),
+        });
+    },
+    state: {
+        subscribe: subscribeState,
+    },
+    channel: {
+        open: function (topic, params, options) {
+            if (!topic || typeof topic !== "string") {
+                return Promise.reject({
+                    code: BRIDGE_ERROR.MALFORMED_MESSAGE,
+                    message: "Topic name must be a non-empty string",
+                });
+            }
+            if (!helloSent)
+                startHandshake();
+            return new Promise(function (resolve, reject) {
+                var id = nextMessageId("ch");
+                var channel = createChannel(id, function (payload, seq) {
+                    send({ v: 2, kind: "ch.data", id: id, seq: seq, payload: payload });
+                }, function (code, reason) {
+                    var pending = pendingChannels.get(id);
+                    if (pending && pending.timerId !== null)
+                        clearTimeout(pending.timerId);
+                    pendingChannels.delete(id);
+                    activeChannels.delete(id);
+                    send({ v: 2, kind: "ch.close", id: id, code: code, reason: reason });
+                });
+                pendingChannels.set(id, {
+                    topic: topic,
+                    channel: channel,
+                    resolve: resolve,
+                    reject: reject,
+                    timerId: null,
+                });
+                send({
+                    v: 2,
+                    kind: "ch.open",
+                    id: id,
+                    topic: topic,
+                    params: normalizeParams(params),
+                    cap: (options === null || options === void 0 ? void 0 : options.cap) || inferCap(topic),
+                }, id);
+            });
+        },
+    },
+};
+// Public interface
+export var LingXiaBridge = {
+    invoke: function (route, input, options) {
+        return rawBridge
+            .call(nativeRoute(route), input, nativeOptions(options))
+            .then(function (value) { return value; })
+            .catch(function (error) { return Promise.reject(toNativeError(error)); });
+    },
+    notify: function (route, input, options) {
+        rawBridge.notify(nativeRoute(route), input, nativeOptions(options));
+    },
+    stream: function (route, input, options) {
+        return wrapNativeStream(rawBridge.stream(nativeRoute(route), input, nativeOptions(options)));
+    },
+    channel: function (route, input, options) {
+        return rawBridge.channel
+            .open(nativeRoute(route), input, nativeOptions(options))
+            .then(function (handle) { return wrapNativeChannel(handle); })
+            .catch(function (error) { return Promise.reject(toNativeError(error)); });
+    },
+    raw: rawBridge,
+    state: {
+        subscribe: subscribeState,
+    },
+    _connectWebMessagePort: function (port) {
+        if (communicationMethod !== MESSAGE_PORT_TYPE)
+            return;
+        if (messagePort && messagePort !== port) {
+            try {
+                messagePort.onmessage = null;
+                messagePort.close();
+            }
+            catch (_a) { }
+        }
+        messagePort = port;
+        port.onmessage = function (event) {
+            var data = event.data;
+            if (typeof data === "string") {
+                try {
+                    data = JSON.parse(data);
+                }
+                catch (_a) {
+                    return;
+                }
+            }
+            handleIncomingMessage(data);
+        };
+        // Some WebView MessagePort implementations (notably Android WebMessagePort)
+        // require an explicit start() to begin dispatching onmessage events.
+        try {
+            port.start();
+        }
+        catch (_b) { }
+        log("Port connected");
+        startHandshake();
+    },
+    _receiveEvaluateMessage: function (messageString) {
+        try {
+            if (messageString)
+                handleIncomingMessage(JSON.parse(messageString));
+        }
+        catch (e) {
+            error("Parse error:", e);
+        }
+    },
+    debug: new Proxy(debugFlags, {
+        get: function (target, prop) {
+            return target[prop];
+        },
+        set: function (target, prop, value) {
+            if (prop in target) {
+                target[prop] = !!value;
+                console.log("[LX] ".concat(prop, ": ").concat(value));
+                return true;
+            }
+            return false;
+        },
+    }),
+    platform: {
+        isHarmony: isHarmony,
+        isIOS: isIOS,
+        isAndroid: isAndroid,
+        isMacOS: isMacOS,
+        isDesktop: isDesktop,
+        getOS: getPlatformOS,
+    },
+    dom: {
+        measureById: function (id) {
+            try {
+                if (!id)
+                    return null;
+                var el = document.getElementById(id);
+                if (!el)
+                    return null;
+                var r = el.getBoundingClientRect();
+                var radius = 0;
+                try {
+                    radius = parseFloat(getComputedStyle(el).borderRadius) || 0;
+                }
+                catch (_a) { }
+                return [
+                    r.left + window.scrollX,
+                    r.top + window.scrollY,
+                    r.width,
+                    r.height,
+                    radius,
+                ];
+            }
+            catch (_b) {
+                return null;
+            }
+        },
+    },
+    nativeComponents: {
+        send: sendNativeComponentMessage,
+        hasHandler: hasNativeComponentHandler,
+        flush: flushNativeComponentQueue,
+        register: function (id, handler) {
+            if (!id || typeof handler !== "function")
+                return function () { };
+            nativeComponentHandlers.set(id, handler);
+            return function () { return nativeComponentHandlers.delete(id); };
+        },
+        unregister: function (id) {
+            nativeComponentHandlers.delete(id);
+        },
+    },
+    isReady: function () {
+        return handshakeDone;
+    },
+};
+function nativeRoute(route) {
+    return route.startsWith("host.") ? route : "host.".concat(route);
+}
+function nativeOptions(options) {
+    return __assign(__assign({}, (options || {})), { cap: (options === null || options === void 0 ? void 0 : options.cap) || "host" });
+}
+function wrapNativeStream(handle) {
+    var eventListeners = new Set();
+    var errorListeners = new Set();
+    handle.on("data", function (event) {
+        var e_16, _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_16_1) { e_16 = { error: e_16_1 }; }
+        finally {
+            try {
+                if (eventListeners_1_1 && !eventListeners_1_1.done && (_a = eventListeners_1.return)) _a.call(eventListeners_1);
+            }
+            finally { if (e_16) throw e_16.error; }
+        }
+    });
+    handle.on("error", function (error) {
+        var e_17, _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()) {
+                var listener = errorListeners_1_1.value;
+                listener(nativeError);
+            }
+        }
+        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        finally {
+            try {
+                if (errorListeners_1_1 && !errorListeners_1_1.done && (_a = errorListeners_1.return)) _a.call(errorListeners_1);
+            }
+            finally { if (e_17) throw e_17.error; }
+        }
+    });
+    return {
+        onEvent: function (listener) {
+            eventListeners.add(listener);
+            return function () {
+                eventListeners.delete(listener);
+            };
+        },
+        onError: function (listener) {
+            errorListeners.add(listener);
+            return function () {
+                errorListeners.delete(listener);
+            };
+        },
+        result: handle.result.catch(function (error) { return Promise.reject(toNativeError(error)); }),
+        cancel: function () {
+            handle.cancel();
+        },
+    };
+}
+function wrapNativeChannel(channel) {
+    var messageListeners = new Set();
+    var closeListeners = new Set();
+    channel.on("data", function (message) {
+        var e_18, _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_18_1) { e_18 = { error: e_18_1 }; }
+        finally {
+            try {
+                if (messageListeners_1_1 && !messageListeners_1_1.done && (_a = messageListeners_1.return)) _a.call(messageListeners_1);
+            }
+            finally { if (e_18) throw e_18.error; }
+        }
+    });
+    channel.on("close", function (code, reason) {
+        var e_19, _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()) {
+                var listener = closeListeners_1_1.value;
+                listener(event);
+            }
+        }
+        catch (e_19_1) { e_19 = { error: e_19_1 }; }
+        finally {
+            try {
+                if (closeListeners_1_1 && !closeListeners_1_1.done && (_a = closeListeners_1.return)) _a.call(closeListeners_1);
+            }
+            finally { if (e_19) throw e_19.error; }
+        }
+    });
+    return {
+        send: function (message) {
+            channel.send(message);
+        },
+        onMessage: function (listener) {
+            messageListeners.add(listener);
+            return function () {
+                messageListeners.delete(listener);
+            };
+        },
+        onClose: function (listener) {
+            closeListeners.add(listener);
+            return function () {
+                closeListeners.delete(listener);
+            };
+        },
+        close: function (code, reason) {
+            channel.close(code, reason);
+        },
+    };
+}
+export function invoke(route, input, options) {
+    return LingXiaBridge.invoke(route, input, options);
+}
+export function notify(route, input, options) {
+    rawBridge.notify(nativeRoute(route), input, nativeOptions(options));
+}
+export function stream(route, input, options) {
+    return wrapNativeStream(rawBridge.stream(nativeRoute(route), input, nativeOptions(options)));
+}
+export function channel(route, input, options) {
+    return LingXiaBridge.channel(route, input, options);
+}
+export function initBridge() {
+    if (window.__LX_BRIDGE_INIT_STATE) {
+        log("Bridge already ".concat(window.__LX_BRIDGE_INIT_STATE, ", skipping duplicate init"));
+        return;
+    }
+    window.__LX_BRIDGE_INIT_STATE = "initializing";
+    try {
+        log("Method: ".concat(communicationMethod));
+        activateReceiver(LingXiaBridge._receiveEvaluateMessage);
+        if (useAppleDownstreamTransport()) {
+            ensureAppleDownstream();
+        }
+        else if (communicationMethod === MESSAGE_PORT_TYPE) {
+            installMessagePortInitListener();
+            getMessagePort().catch(function (e) { return warn("Port init failed:", e); });
+        }
+        else if (communicationMethod === "webkit" ||
+            communicationMethod === JS_INTERFACE_TYPE) {
+            startHandshake();
+        }
+        else {
+            warn("Unknown method");
+        }
+        window.LingXiaBridge = LingXiaBridge;
+        installNativeComponentCoverageMonitor({
+            os: getPlatformOS(),
+            send: sendNativeComponentMessage,
+        });
+        window.__LX_BRIDGE_INIT_STATE = "initialized";
+        log("Init complete");
+    }
+    catch (e) {
+        delete window.__LX_BRIDGE_INIT_STATE;
+        throw e;
+    }
+}