@lingxia/bridge 0.5.1 → 0.6.0

package/dist/es2020/bridge.js

@@ -1,5 +1,5 @@
 import { BRIDGE_ERROR } from "./types";
-import { toBridgeError } from "./invocation";
+import { toBridgeError, toNativeError } from "./invocation";
 import { installNativeComponentCoverageMonitor } from "./nativecomponents/coverage-monitor";
 import { BRIDGE_CONFIG, getCommunicationMethod, getPlatformOS, isAndroid, isHarmony, isIOS, isMacOS, isDesktop, } from "./runtime-env";
 const NATIVE_HANDLER_NAME = "LingXia";
@@ -11,7 +11,7 @@ const LOG_PREFIX = "[LX.Bridge]";
 const MESSAGE_PORT_TYPE = "messageport";
 const JS_INTERFACE_TYPE = "jsinterface";
 const OUTBOX_LIMIT = 256;
-const APPLE_DOWNSTREAM_PATH = "/__lingxia/bridge/downstream";
+const APPLE_DOWNSTREAM_URL = "lx-apple://bridge/downstream";
 const APPLE_RECONNECT_BASE_MS = 200;
 const APPLE_RECONNECT_MAX_MS = 2000;
 const debugFlags = { data: false, proto: false, all: false };
@@ -188,7 +188,7 @@ async function runAppleDownstream() {
     appleDownstreamAbortController = controller;
     let response;
     try {
-        response = await fetch(APPLE_DOWNSTREAM_PATH, {
+        response = await fetch(APPLE_DOWNSTREAM_URL, {
             method: "GET",
             cache: "no-store",
             headers: { Accept: "application/x-ndjson" },
@@ -891,7 +891,7 @@ function subscribeState(callback) {
     };
 }
 function requestStateRecovery(scope) {
-    LingXiaBridge.call("state.getSnapshot", { scope }).catch(() => { });
+    rawBridge.call("state.getSnapshot", { scope }).catch(() => { });
 }
 function applySnapshotFromResult(result) {
     if (!result || typeof result !== "object")
@@ -1201,8 +1201,8 @@ function attachAbortSignal(id, signal, onAbort) {
     };
     signal.addEventListener("abort", abortListener);
 }
-// Public interface
-export const LingXiaBridge = {
+// Low-level protocol interface. Public consumers should use LingXiaBridge.invoke/stream/channel.
+const rawBridge = {
     call(method, params, options) {
         return new Promise((resolve, reject) => {
             if (!method || typeof method !== "string") {
@@ -1345,6 +1345,31 @@ export const LingXiaBridge = {
             });
         },
     },
+};
+// Public interface
+export const LingXiaBridge = {
+    invoke(route, input, options) {
+        return rawBridge
+            .call(nativeRoute(route), input, nativeOptions(options))
+            .then((value) => value)
+            .catch((error) => Promise.reject(toNativeError(error)));
+    },
+    notify(route, input, options) {
+        rawBridge.notify(nativeRoute(route), input, nativeOptions(options));
+    },
+    stream(route, input, options) {
+        return wrapNativeStream(rawBridge.stream(nativeRoute(route), input, nativeOptions(options)));
+    },
+    channel(route, input, options) {
+        return rawBridge.channel
+            .open(nativeRoute(route), input, nativeOptions(options))
+            .then((handle) => wrapNativeChannel(handle))
+            .catch((error) => Promise.reject(toNativeError(error)));
+    },
+    raw: rawBridge,
+    state: {
+        subscribe: subscribeState,
+    },
     _connectWebMessagePort(port) {
         if (communicationMethod !== MESSAGE_PORT_TYPE)
             return;
@@ -1452,89 +1477,88 @@ export const LingXiaBridge = {
         return handshakeDone;
     },
 };
-function createHostPathProxy(path) {
-    const callable = () => { };
-    return new Proxy(callable, {
-        apply(_target, _thisArg, args) {
-            const method = path.join(".");
-            const payload = args.length === 0 ? undefined : args.length === 1 ? args[0] : args;
-            // Always use stream — it works for both unary and stream host handlers.
-            // Unary handlers return a single `res`; stream handlers emit `event`s then `res`.
-            // The returned handle is also thenable so `await host.x.y()` just works.
-            const handle = LingXiaBridge.stream(`host.${method}`, payload, { cap: "host", timeoutMs: 0 });
-            // Make thenable: `await host.x.y()` resolves to the final result,
-            // while `host.x.y().on('data', ...)` works for streams.
-            const result = handle.result;
-            return new Proxy(handle, {
-                get(target, prop) {
-                    if (prop === "then")
-                        return result.then.bind(result);
-                    if (prop === "catch")
-                        return result.catch.bind(result);
-                    const val = target[prop];
-                    return typeof val === "function" ? val.bind(target) : val;
-                },
-            });
+function nativeRoute(route) {
+    return route.startsWith("host.") ? route : `host.${route}`;
+}
+function nativeOptions(options) {
+    return { ...(options || {}), cap: options?.cap || "host" };
+}
+function wrapNativeStream(handle) {
+    const eventListeners = new Set();
+    const errorListeners = new Set();
+    handle.on("data", (event) => {
+        for (const listener of eventListeners)
+            listener(event);
+    });
+    handle.on("error", (error) => {
+        const nativeError = toNativeError(error);
+        for (const listener of errorListeners)
+            listener(nativeError);
+    });
+    return {
+        onEvent(listener) {
+            eventListeners.add(listener);
+            return () => {
+                eventListeners.delete(listener);
+            };
         },
-        get(_target, prop) {
-            if (prop === "then")
-                return undefined;
-            if (prop === "__funcName")
-                return `host.${path.join(".")}`;
-            if (prop === "__bridgeMode")
-                return "stream";
-            if (typeof prop !== "string")
-                return undefined;
-            return createHostPathProxy([...path, prop]);
+        onError(listener) {
+            errorListeners.add(listener);
+            return () => {
+                errorListeners.delete(listener);
+            };
         },
-    });
+        result: handle.result.catch((error) => Promise.reject(toNativeError(error))),
+        cancel() {
+            handle.cancel();
+        },
+    };
 }
-function createHostChannelProxy(path) {
-    const callable = () => { };
-    return new Proxy(callable, {
-        apply(_target, _thisArg, args) {
-            const method = path.join(".");
-            const payload = args.length === 0 ? undefined : args.length === 1 ? args[0] : args;
-            return LingXiaBridge.channel.open(`host.${method}`, payload, { cap: "host" });
+function wrapNativeChannel(channel) {
+    const messageListeners = new Set();
+    const closeListeners = new Set();
+    channel.on("data", (message) => {
+        for (const listener of messageListeners)
+            listener(message);
+    });
+    channel.on("close", (code, reason) => {
+        const event = { code, reason };
+        for (const listener of closeListeners)
+            listener(event);
+    });
+    return {
+        send(message) {
+            channel.send(message);
         },
-        get(_target, prop) {
-            if (prop === "then")
-                return undefined;
-            if (prop === "__funcName")
-                return `host.${path.join(".")}`;
-            if (prop === "__bridgeMode")
-                return "channel";
-            if (prop === "open") {
-                return (...args) => {
-                    const method = path.join(".");
-                    const payload = args.length === 0 ? undefined : args.length === 1 ? args[0] : args;
-                    return LingXiaBridge.channel.open(`host.${method}`, payload, { cap: "host" });
-                };
-            }
-            if (typeof prop !== "string")
-                return undefined;
-            return createHostChannelProxy([...path, prop]);
+        onMessage(listener) {
+            messageListeners.add(listener);
+            return () => {
+                messageListeners.delete(listener);
+            };
         },
-    });
+        onClose(listener) {
+            closeListeners.add(listener);
+            return () => {
+                closeListeners.delete(listener);
+            };
+        },
+        close(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 const host = new Proxy({}, {
-    get(_target, prop) {
-        if (typeof prop !== "string") {
-            return undefined;
-        }
-        if (prop === "channel") {
-            return new Proxy({}, {
-                get(_target, channelProp) {
-                    if (typeof channelProp !== "string") {
-                        return undefined;
-                    }
-                    return createHostChannelProxy([channelProp]);
-                },
-            });
-        }
-        return createHostPathProxy([prop]);
-    },
-});
 export function initBridge() {
     if (window.__LX_BRIDGE_INIT_STATE) {
         log(`Bridge already ${window.__LX_BRIDGE_INIT_STATE}, skipping duplicate init`);
@@ -1559,7 +1583,6 @@ export function initBridge() {
             warn("Unknown method");
         }
         window.LingXiaBridge = LingXiaBridge;
-        window.host = host;
         installNativeComponentCoverageMonitor({
             os: getPlatformOS(),
             send: sendNativeComponentMessage,

package/dist/es2020/index.js

@@ -5,7 +5,8 @@
  * - Bridge initialization for native communication
  * - Error UI rendering when page cannot be loaded
  */
-export { LingXiaBridge, host, initBridge } from './bridge';
+export { LingXiaBridge, channel, initBridge, invoke, notify, stream, } from './bridge';
+export { isNativeError } from './invocation';
 export { renderErrorUI, hasError, getErrorInfo } from './error';
 export { boot, bootWhenReady } from './boot';
 import { bootWhenReady } from './boot';

package/dist/es2020/invocation.js

@@ -27,6 +27,26 @@ export function toBridgeError(err) {
     const message = err instanceof Error ? err.message : typeof err === "string" ? err : "Unknown error";
     return new BridgeInvocationError(BRIDGE_ERROR.INTERNAL_ERROR, message);
 }
+export function toNativeError(err) {
+    const bridgeError = toBridgeError(err);
+    return {
+        code: String(bridgeError.code || BRIDGE_ERROR.INTERNAL_ERROR),
+        message: typeof bridgeError.message === "string" && bridgeError.message.trim() !== ""
+            ? bridgeError.message
+            : "Unknown error",
+        ...(bridgeError.data === undefined ? {} : { data: bridgeError.data }),
+    };
+}
+export function isNativeError(error, code) {
+    if (!error || typeof error !== "object")
+        return false;
+    const candidate = error;
+    if (typeof candidate.code !== "string" || candidate.code.trim() === "")
+        return false;
+    if (typeof candidate.message !== "string")
+        return false;
+    return code === undefined || candidate.code === code;
+}
 export function resolveParams(source) {
     if (typeof source === "function") {
         return source();

package/dist/es5/bridge.js

@@ -1,3 +1,14 @@
+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) {
@@ -71,7 +82,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { BRIDGE_ERROR } from "./types";
-import { toBridgeError } from "./invocation";
+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";
@@ -83,7 +94,7 @@ var LOG_PREFIX = "[LX.Bridge]";
 var MESSAGE_PORT_TYPE = "messageport";
 var JS_INTERFACE_TYPE = "jsinterface";
 var OUTBOX_LIMIT = 256;
-var APPLE_DOWNSTREAM_PATH = "/__lingxia/bridge/downstream";
+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 };
@@ -234,9 +245,9 @@ 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 = _d[1];
+            var _d = __read(_c.value, 2), id = _d[0], channel_1 = _d[1];
             activeChannels.delete(id);
-            channel._emitClose(BRIDGE_ERROR.STREAM_CLOSED, reason);
+            channel_1._emitClose(BRIDGE_ERROR.STREAM_CLOSED, reason);
         }
     }
     catch (e_2_1) { e_2 = { error: e_2_1 }; }
@@ -322,7 +333,7 @@ function runAppleDownstream() {
                     _b.label = 1;
                 case 1:
                     _b.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, fetch(APPLE_DOWNSTREAM_PATH, {
+                    return [4 /*yield*/, fetch(APPLE_DOWNSTREAM_URL, {
                             method: "GET",
                             cache: "no-store",
                             headers: { Accept: "application/x-ndjson" },
@@ -1149,7 +1160,7 @@ function subscribeState(callback) {
     };
 }
 function requestStateRecovery(scope) {
-    LingXiaBridge.call("state.getSnapshot", { scope: scope }).catch(function () { });
+    rawBridge.call("state.getSnapshot", { scope: scope }).catch(function () { });
 }
 function applySnapshotFromResult(result) {
     if (!result || typeof result !== "object")
@@ -1331,10 +1342,10 @@ function handleIncomingMessage(msg) {
             return;
         }
         case "ch.data": {
-            var channel = activeChannels.get(message.id);
-            if (!channel)
+            var channel_2 = activeChannels.get(message.id);
+            if (!channel_2)
                 return;
-            channel._emitData(message.payload);
+            channel_2._emitData(message.payload);
             return;
         }
         case "ch.close": {
@@ -1344,11 +1355,11 @@ function handleIncomingMessage(msg) {
                 pendingChannel.channel._emitClose(message.code, message.reason);
                 return;
             }
-            var channel = activeChannels.get(message.id);
-            if (!channel)
+            var channel_3 = activeChannels.get(message.id);
+            if (!channel_3)
                 return;
             activeChannels.delete(message.id);
-            channel._emitClose(message.code, message.reason);
+            channel_3._emitClose(message.code, message.reason);
             return;
         }
         case "req": {
@@ -1473,8 +1484,8 @@ function attachAbortSignal(id, signal, onAbort) {
     };
     signal.addEventListener("abort", abortListener);
 }
-// Public interface
-export var LingXiaBridge = {
+// 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;
@@ -1619,6 +1630,31 @@ export var LingXiaBridge = {
             });
         },
     },
+};
+// 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;
@@ -1726,93 +1762,136 @@ export var LingXiaBridge = {
         return handshakeDone;
     },
 };
-function createHostPathProxy(path) {
-    var callable = function () { };
-    return new Proxy(callable, {
-        apply: function (_target, _thisArg, args) {
-            var method = path.join(".");
-            var payload = args.length === 0 ? undefined : args.length === 1 ? args[0] : args;
-            // Always use stream — it works for both unary and stream host handlers.
-            // Unary handlers return a single `res`; stream handlers emit `event`s then `res`.
-            // The returned handle is also thenable so `await host.x.y()` just works.
-            var handle = LingXiaBridge.stream("host.".concat(method), payload, { cap: "host", timeoutMs: 0 });
-            // Make thenable: `await host.x.y()` resolves to the final result,
-            // while `host.x.y().on('data', ...)` works for streams.
-            var result = handle.result;
-            return new Proxy(handle, {
-                get: function (target, prop) {
-                    if (prop === "then")
-                        return result.then.bind(result);
-                    if (prop === "catch")
-                        return result.catch.bind(result);
-                    var val = target[prop];
-                    return typeof val === "function" ? val.bind(target) : val;
-                },
-            });
-        },
-        get: function (_target, prop) {
-            if (prop === "then")
-                return undefined;
-            if (prop === "__funcName")
-                return "host.".concat(path.join("."));
-            if (prop === "__bridgeMode")
-                return "stream";
-            if (typeof prop !== "string")
-                return undefined;
-            return createHostPathProxy(__spreadArray(__spreadArray([], __read(path), false), [prop], false));
-        },
-    });
+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 createHostChannelProxy(path) {
-    var callable = function () { };
-    return new Proxy(callable, {
-        apply: function (_target, _thisArg, args) {
-            var method = path.join(".");
-            var payload = args.length === 0 ? undefined : args.length === 1 ? args[0] : args;
-            return LingXiaBridge.channel.open("host.".concat(method), payload, { 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);
+            };
         },
-        get: function (_target, prop) {
-            if (prop === "then")
-                return undefined;
-            if (prop === "__funcName")
-                return "host.".concat(path.join("."));
-            if (prop === "__bridgeMode")
-                return "channel";
-            if (prop === "open") {
-                return function () {
-                    var args = [];
-                    for (var _i = 0; _i < arguments.length; _i++) {
-                        args[_i] = arguments[_i];
-                    }
-                    var method = path.join(".");
-                    var payload = args.length === 0 ? undefined : args.length === 1 ? args[0] : args;
-                    return LingXiaBridge.channel.open("host.".concat(method), payload, { cap: "host" });
-                };
-            }
-            if (typeof prop !== "string")
-                return undefined;
-            return createHostChannelProxy(__spreadArray(__spreadArray([], __read(path), false), [prop], false));
+        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();
+        },
+    };
 }
-export var host = new Proxy({}, {
-    get: function (_target, prop) {
-        if (typeof prop !== "string") {
-            return undefined;
+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);
+            }
         }
-        if (prop === "channel") {
-            return new Proxy({}, {
-                get: function (_target, channelProp) {
-                    if (typeof channelProp !== "string") {
-                        return undefined;
-                    }
-                    return createHostChannelProxy([channelProp]);
-                },
-            });
+        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; }
         }
-        return createHostPathProxy([prop]);
-    },
-});
+    });
+    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"));
@@ -1837,7 +1916,6 @@ export function initBridge() {
             warn("Unknown method");
         }
         window.LingXiaBridge = LingXiaBridge;
-        window.host = host;
         installNativeComponentCoverageMonitor({
             os: getPlatformOS(),
             send: sendNativeComponentMessage,

package/dist/es5/index.js

@@ -5,7 +5,8 @@
  * - Bridge initialization for native communication
  * - Error UI rendering when page cannot be loaded
  */
-export { LingXiaBridge, host, initBridge } from './bridge';
+export { LingXiaBridge, channel, initBridge, invoke, notify, stream, } from './bridge';
+export { isNativeError } from './invocation';
 export { renderErrorUI, hasError, getErrorInfo } from './error';
 export { boot, bootWhenReady } from './boot';
 import { bootWhenReady } from './boot';