@lingxia/bridge 0.10.0 → 0.11.1

package/dist/es5/bridge.js

@@ -84,7 +84,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 import { BRIDGE_ERROR } from "./types";
 import { toBridgeError, toNativeError } from "./invocation";
 import { installNativeComponentCoverageMonitor } from "./nativecomponents/coverage-monitor";
-import { BRIDGE_CONFIG, getCommunicationMethod, getPlatformOS, isAndroid, isHarmony, isIOS, isMacOS, isWindows, isDesktop, } from "./runtime-env";
+import { BRIDGE_CONFIG, getCommunicationMethod, getPlatformOS, isAndroid, isHarmony, isIOS, isMacOS, isWindows, isDesktop, isApple, isDevSession, isRunner, } from "./runtime-env";
 var NATIVE_HANDLER_NAME = "LingXia";
 var GLOBAL_RECEIVER_NAME = "__LingXiaRecvMessage";
 var DEFAULT_TIMEOUT_MS = 5000;
@@ -159,11 +159,22 @@ function activateReceiver(receiver) {
 function isDebugEnabled(flag) {
     return debugFlags.all || debugFlags[flag];
 }
+// `log` is the bridge's own protocol/lifecycle trace. Native log capture
+// forwards whatever the page emits to `console`, so the bridge itself decides
+// whether to surface this framework chatter: only in a `lingxia dev` session
+// (or when a debug flag is set). Shipped apps stay quiet, leaving the captured
+// stream to the page's own output plus bridge warnings/errors.
 function log() {
     var args = [];
     for (var _i = 0; _i < arguments.length; _i++) {
         args[_i] = arguments[_i];
     }
+    if (!isDevSession() &&
+        !debugFlags.all &&
+        !debugFlags.proto &&
+        !debugFlags.data) {
+        return;
+    }
     console.log.apply(console, __spreadArray([LOG_PREFIX], __read(args), false));
 }
 function warn() {
@@ -218,6 +229,17 @@ var appleDownstreamTask = null;
 var appleDownstreamAbortController = null;
 var appleReconnectTimer = null;
 var appleReconnectDelayMs = APPLE_RECONNECT_BASE_MS;
+var appleDownstreamDisposed = false;
+// Highest transport frame seq processed. Sent as `?from=` on reconnect so the
+// host replays the gap; survives reconnects so a WebKit-replaced stream resumes
+// without losing frames or tearing down the bridge session.
+var appleLastFrameSeq = 0;
+// Liveness tracking: the host heartbeats an idle connection, so a gap longer
+// than a couple of heartbeats means the connection is silently dead and we
+// reconnect proactively instead of waiting for a read error that may never come.
+var APPLE_DOWNSTREAM_STALE_MS = 35000;
+var appleLastFrameAt = 0;
+var appleWatchdogTimer = null;
 var portInitState = {
     listenerInstalled: false,
     promise: null,
@@ -262,6 +284,23 @@ function clearAppleReconnectTimer() {
         appleReconnectTimer = null;
     }
 }
+function disposeAppleDownstream(reason) {
+    if (!useAppleDownstreamTransport() || appleDownstreamDisposed)
+        return;
+    appleDownstreamDisposed = true;
+    clearAppleReconnectTimer();
+    if (appleWatchdogTimer !== null) {
+        clearInterval(appleWatchdogTimer);
+        appleWatchdogTimer = null;
+    }
+    if (typeof document !== "undefined") {
+        document.removeEventListener("visibilitychange", handleAppleVisibilityChange);
+    }
+    appleForcedReconnectPending = false;
+    appleDownstreamAbortController === null || appleDownstreamAbortController === void 0 ? void 0 : appleDownstreamAbortController.abort();
+    appleDownstreamConnected = false;
+    resetHandshakeState(reason, true);
+}
 function closeActiveChannelsFromTransport(reason) {
     var e_2, _a;
     try {
@@ -335,7 +374,7 @@ function processAppleDownstreamBuffer(buffer) {
         if (!line)
             continue;
         try {
-            handleIncomingMessage(JSON.parse(line));
+            handleAppleDownstreamFrame(JSON.parse(line));
         }
         catch (e) {
             warn("Apple downstream parse error:", e, line);
@@ -343,9 +382,42 @@ function processAppleDownstreamBuffer(buffer) {
     }
     return remaining;
 }
+// Unwrap the transport envelope: {"lxff":seq,"m":<message>} carries a business
+// message with its frame seq; {"lxreset":true} means the host cannot replay our
+// resume point and we must re-handshake.
+function handleAppleDownstreamFrame(frame) {
+    if (!frame || typeof frame !== "object")
+        return;
+    // Any frame — data, heartbeat, or reset — proves the connection is alive.
+    appleLastFrameAt = Date.now();
+    var record = frame;
+    if (record.lxshutdown === true) {
+        disposeAppleDownstream("Apple downstream closed");
+        return;
+    }
+    if (record.lxhb !== undefined)
+        return; // heartbeat: liveness only, nothing to dispatch
+    if (record.lxreset === true) {
+        appleLastFrameSeq = 0;
+        resetHandshakeState("Apple downstream reset", true);
+        startHandshake();
+        return;
+    }
+    if (typeof record.lxff === "number") {
+        // Replayed frames after a reconnect can repeat the last-seen seq; ignore
+        // anything we have already processed so the session is not double-fed.
+        if (record.lxff <= appleLastFrameSeq)
+            return;
+        appleLastFrameSeq = record.lxff;
+        handleIncomingMessage(record.m);
+        return;
+    }
+    // Legacy/un-enveloped line (e.g. a bare keepalive); pass through.
+    handleIncomingMessage(frame);
+}
 function runAppleDownstream() {
     return __awaiter(this, void 0, void 0, function () {
-        var controller, response, reader, decoder, buffered, _a, value, done, tail, e_5;
+        var controller, separator, url, response, reader, decoder, buffered, _a, value, done, tail, e_5;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
@@ -354,7 +426,9 @@ function runAppleDownstream() {
                     }
                     controller = new AbortController();
                     appleDownstreamAbortController = controller;
-                    return [4 /*yield*/, fetch(APPLE_DOWNSTREAM_URL, {
+                    separator = APPLE_DOWNSTREAM_URL.includes("?") ? "&" : "?";
+                    url = "".concat(APPLE_DOWNSTREAM_URL).concat(separator, "from=").concat(appleLastFrameSeq);
+                    return [4 /*yield*/, fetch(url, {
                             method: "GET",
                             cache: "no-store",
                             headers: { Accept: "application/x-ndjson" },
@@ -365,11 +439,16 @@ function runAppleDownstream() {
                     if (!response.ok) {
                         throw new Error("Apple downstream HTTP ".concat(response.status));
                     }
+                    if (response.headers.get("X-LingXia-Bridge-Shutdown") === "1") {
+                        disposeAppleDownstream("Apple downstream closed");
+                        return [2 /*return*/];
+                    }
                     if (!response.body) {
                         throw new Error("Apple downstream response body unavailable");
                     }
                     appleDownstreamConnected = true;
                     appleReconnectDelayMs = APPLE_RECONNECT_BASE_MS;
+                    appleLastFrameAt = Date.now();
                     if (isDebugEnabled("proto"))
                         log("Apple downstream connected");
                     startHandshake();
@@ -395,7 +474,7 @@ function runAppleDownstream() {
                     tail = buffered.trim();
                     if (tail) {
                         try {
-                            handleIncomingMessage(JSON.parse(tail));
+                            handleAppleDownstreamFrame(JSON.parse(tail));
                         }
                         catch (e) {
                             warn("Apple downstream trailing parse error:", e, tail);
@@ -418,13 +497,18 @@ function runAppleDownstream() {
         });
     });
 }
-function scheduleAppleDownstreamReconnect(reason) {
-    if (!useAppleDownstreamTransport())
+function scheduleAppleDownstreamReconnect(reason, immediate) {
+    if (immediate === void 0) { immediate = false; }
+    if (!useAppleDownstreamTransport() || appleDownstreamDisposed)
         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);
+    var delay = immediate ? 0 : appleReconnectDelayMs;
+    if (!immediate) {
+        appleReconnectDelayMs = Math.min(appleReconnectDelayMs * 2, APPLE_RECONNECT_MAX_MS);
+    }
+    var message = immediate
+        ? "Apple downstream completed, reconnecting immediately: ".concat(reason)
+        : "Apple downstream disconnected, retrying in ".concat(delay, "ms: ").concat(reason);
     if (delay <= APPLE_RECONNECT_BASE_MS) {
         log(message);
     }
@@ -437,12 +521,16 @@ function scheduleAppleDownstreamReconnect(reason) {
     }, delay);
 }
 function ensureAppleDownstream() {
-    if (!useAppleDownstreamTransport())
+    if (!useAppleDownstreamTransport() || appleDownstreamDisposed)
         return;
     if (appleDownstreamTask)
         return;
     clearAppleReconnectTimer();
+    var completedCleanly = false;
     appleDownstreamTask = runAppleDownstream()
+        .then(function () {
+        completedCleanly = true;
+    })
         .catch(function (e) {
         if (appleDownstreamAbortController === null || appleDownstreamAbortController === void 0 ? void 0 : appleDownstreamAbortController.signal.aborted)
             return;
@@ -453,13 +541,72 @@ function ensureAppleDownstream() {
         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");
+        // A dropped transport is not a dead session: reconnect resumes from the
+        // last seq and the host replays the gap, so the handshake and in-flight
+        // streams stay intact. Only a host-sent reset (handled on the frame path)
+        // or a real abort tears things down.
+        if (!aborted && !appleDownstreamDisposed) {
+            // Native intentionally completes bootstrap/replay responses to flush
+            // WebKit. Reconnect without the failure backoff so a live stream can
+            // catch up and settle onto a long-lived downstream.
+            scheduleAppleDownstreamReconnect("stream closed", completedCleanly);
+        }
     });
 }
+// Drop the current downstream and reconnect, exactly as WebKit does when it
+// replaces the streaming fetch. The reconnect carries the real `from=<lastSeq>`,
+// so nothing is lost. Driven by the staleness watchdog and the foreground
+// handler, and exposed as a dev hook for repro harnesses. A no-op off Apple.
+var appleForcedReconnectPending = false;
+function forceDownstreamReconnect() {
+    if (!useAppleDownstreamTransport() || appleDownstreamDisposed)
+        return;
+    // Coalesce a burst of triggers (rapid foreground toggles, repeated calls)
+    // into a single reconnect so they cannot stack concurrent fetches.
+    if (appleForcedReconnectPending)
+        return;
+    appleForcedReconnectPending = true;
+    var task = appleDownstreamTask;
+    appleDownstreamAbortController === null || appleDownstreamAbortController === void 0 ? void 0 : appleDownstreamAbortController.abort();
+    var reconnect = function () {
+        appleForcedReconnectPending = false;
+        ensureAppleDownstream();
+    };
+    if (task)
+        task.finally(reconnect);
+    else
+        reconnect();
+}
+// A silently dead connection (half-open socket) never surfaces a read error, so
+// poll for heartbeat staleness and reconnect when the host has gone quiet.
+function startAppleWatchdog() {
+    if (!useAppleDownstreamTransport() ||
+        appleDownstreamDisposed ||
+        appleWatchdogTimer !== null)
+        return;
+    appleWatchdogTimer = setInterval(function () {
+        // No `connected` guard: a reconnect that hung before delivering a frame
+        // also goes stale, and forcing a reconnect aborts and retries it.
+        if (appleLastFrameAt === 0)
+            return;
+        if (Date.now() - appleLastFrameAt > APPLE_DOWNSTREAM_STALE_MS) {
+            warn("Apple downstream stale (no heartbeat), forcing reconnect");
+            forceDownstreamReconnect();
+        }
+    }, 5000);
+}
+// WebKit suspends/throttles a backgrounded webview and may tear the stream
+// down; reconnect the moment it returns so the UI is never left stale.
+function handleAppleVisibilityChange() {
+    if (document.visibilityState === "visible")
+        forceDownstreamReconnect();
+}
+function installAppleForegroundReconnect() {
+    if (!useAppleDownstreamTransport() || typeof document === "undefined")
+        return;
+    document.addEventListener("visibilitychange", handleAppleVisibilityChange);
+}
 function getMessagePort() {
     var _a, _b;
     if (messagePort)
@@ -542,6 +689,9 @@ function createStreamHandle(id, cancelFn) {
     var _a;
     var listeners = createListenerBuckets();
     var done = false;
+    // Only buffer for the async iterator; long-lived streams consumed via
+    // .on("data") would otherwise accumulate payloads forever.
+    var iteratorRequested = false;
     var resolveResult = function () { };
     var rejectResult = function () { };
     var pendingData = [];
@@ -564,6 +714,7 @@ function createStreamHandle(id, cancelFn) {
             }
         },
         _a[Symbol.asyncIterator] = function () {
+            iteratorRequested = true;
             return {
                 next: function () {
                     if (pendingData.length > 0) {
@@ -593,7 +744,7 @@ function createStreamHandle(id, cancelFn) {
             if (pendingReads.length > 0) {
                 pendingReads.shift().resolve({ done: false, value: payload });
             }
-            else {
+            else if (iteratorRequested) {
                 pendingData.push(payload);
             }
             try {
@@ -680,6 +831,9 @@ function createChannel(id, sendFn, closeFn) {
     var open = false;
     var outboundSeq = 0;
     var closed = false;
+    // Only buffer for the async iterator or pre-first-listener replay;
+    // otherwise a listener-driven channel would accumulate payloads forever.
+    var iteratorRequested = false;
     var pendingData = [];
     var pendingReads = [];
     var channel = (_a = {
@@ -732,6 +886,7 @@ function createChannel(id, sendFn, closeFn) {
             }
         },
         _a[Symbol.asyncIterator] = function () {
+            iteratorRequested = true;
             return {
                 next: function () {
                     if (pendingData.length > 0) {
@@ -764,7 +919,7 @@ function createChannel(id, sendFn, closeFn) {
             if (pendingReads.length > 0) {
                 pendingReads.shift().resolve({ done: false, value: payload });
             }
-            else {
+            else if (iteratorRequested || listeners.data.size === 0) {
                 pendingData.push(payload);
             }
             try {
@@ -884,7 +1039,15 @@ function isTransportReady() {
         communicationMethod === WEB_MESSAGE_TYPE);
 }
 function canSendAppMessages() {
-    return isTransportReady() && handshakeDone;
+    if (!handshakeDone)
+        return false;
+    // Apple upstream posts through WKScriptMessageHandler independently of the
+    // downstream fetch. During a replay reconnect, native retains responses by
+    // sequence, so treating that short gap as an unsendable session can strand
+    // requests in the outbox with no second `ready` event to flush them.
+    if (useAppleDownstreamTransport())
+        return true;
+    return isTransportReady();
 }
 function rejectPendingRequest(reqId, err) {
     var _a;
@@ -1230,7 +1393,7 @@ function applySnapshotFromResult(result) {
 }
 function handleIncomingMessage(msg) {
     var e_16, _a;
-    var _b, _c;
+    var _b, _c, _d, _e;
     // Handle native component events (from Android NativeBridge.sendEventToView)
     if (msg && typeof msg === "object") {
         var obj = msg;
@@ -1271,15 +1434,15 @@ function handleIncomingMessage(msg) {
             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];
+                    for (var _f = __values(Object.entries(message.hostMethods)), _g = _f.next(); !_g.done; _g = _f.next()) {
+                        var _h = __read(_g.value, 2), k = _h[0], v = _h[1];
                         hostMethodKinds[k] = v;
                     }
                 }
                 catch (e_16_1) { e_16 = { error: e_16_1 }; }
                 finally {
                     try {
-                        if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                        if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
                     }
                     finally { if (e_16) throw e_16.error; }
                 }
@@ -1321,7 +1484,15 @@ function handleIncomingMessage(msg) {
             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);
+                    // The first frame proves the handler is live. Long-lived streams
+                    // (bookmarks.watch, proxy.watch) are idle between pushes, so the
+                    // request timeout must not treat silence as death — disarm it for
+                    // good instead of re-arming per frame.
+                    if (req.timerId !== null) {
+                        clearTimeout(req.timerId);
+                        req.timerId = null;
+                    }
+                    req.timeoutMs = 0;
                     req.stream._emitData(message.payload);
                 }
                 else {
@@ -1399,8 +1570,10 @@ function handleIncomingMessage(msg) {
         case "ch.close": {
             var pendingChannel = pendingChannels.get(message.id);
             if (pendingChannel) {
-                pendingChannels.delete(message.id);
-                pendingChannel.channel._emitClose(message.code, message.reason);
+                rejectPendingChannel(message.id, {
+                    code: (_d = message.code) !== null && _d !== void 0 ? _d : BRIDGE_ERROR.STREAM_CLOSED,
+                    message: (_e = message.reason) !== null && _e !== void 0 ? _e : "Channel closed before opening",
+                });
                 return;
             }
             var channel_3 = activeChannels.get(message.id);
@@ -1752,6 +1925,8 @@ export var LingXiaBridge = {
         isMacOS: isMacOS,
         isWindows: isWindows,
         isDesktop: isDesktop,
+        isApple: isApple,
+        isRunner: isRunner,
         getOS: getPlatformOS,
     },
     dom: {
@@ -1940,6 +2115,8 @@ export function initBridge() {
         activateReceiver(LingXiaBridge._receiveEvaluateMessage);
         if (useAppleDownstreamTransport()) {
             ensureAppleDownstream();
+            startAppleWatchdog();
+            installAppleForegroundReconnect();
         }
         else if (communicationMethod === MESSAGE_PORT_TYPE) {
             installMessagePortInitListener();
@@ -1954,6 +2131,9 @@ export function initBridge() {
             warn("Unknown method");
         }
         window.LingXiaBridge = LingXiaBridge;
+        // Dev hook so repro/test pages can simulate a WebKit stream replacement.
+        window.__lxForceDownstreamReconnect =
+            forceDownstreamReconnect;
         installNativeComponentCoverageMonitor({
             os: getPlatformOS(),
             send: sendNativeComponentMessage,

package/dist/es5/index.js

@@ -7,6 +7,7 @@
  */
 export { LingXiaBridge, channel, initBridge, invoke, notify, stream, } from './bridge';
 export { isNativeError } from './invocation';
+export { getDisplayLanguage } from './runtime-env';
 export { renderErrorUI, hasError, getErrorInfo } from './error';
 export { boot, bootWhenReady } from './boot';
 import { bootWhenReady } from './boot';

package/dist/es5/runtime-env.js

@@ -1,4 +1,12 @@
+var _a;
 export var BRIDGE_CONFIG = (typeof window !== 'undefined' && window.__LX_BRIDGE_CFG) || {};
+var displayLanguage = ((_a = BRIDGE_CONFIG.displayLanguage) === null || _a === void 0 ? void 0 : _a.trim()) || 'en-US';
+if (typeof document !== 'undefined' && document.documentElement) {
+    document.documentElement.lang = displayLanguage;
+}
+export function getDisplayLanguage() {
+    return displayLanguage;
+}
 export function getPlatformOS() {
     return BRIDGE_CONFIG.os || 'unknown';
 }
@@ -20,6 +28,24 @@ export function isWindows() {
 export function isDesktop() {
     return isMacOS() || isWindows();
 }
+// iOS and macOS share the WKWebView transport, so features scoped to it (e.g.
+// the streaming downstream) key off this rather than the two OS checks.
+export function isApple() {
+    return isIOS() || isMacOS();
+}
+// True when attached to a `lingxia dev` session (the host sets `dev` in
+// `__LX_BRIDGE_CFG`). Used to surface the bridge's own protocol/lifecycle trace
+// only during development.
+export function isDevSession() {
+    return BRIDGE_CONFIG.dev === true;
+}
+// True when running inside the LingXia Runner (the `lingxia dev` device
+// simulator), which the host marks in `__LX_BRIDGE_CFG`. Unlike a real host
+// app in dev mode, the Runner lacks host-declared surfaces such as the
+// terminal — apps read this to hide those affordances.
+export function isRunner() {
+    return BRIDGE_CONFIG.runner === true;
+}
 export function getCommunicationMethod() {
     var _a, _b;
     if (BRIDGE_CONFIG.os === 'iOS' || BRIDGE_CONFIG.os === 'macOS')

package/dist/es5/ui/action-sheet.js

@@ -1,9 +1,9 @@
-import { getPlatformOS } from '../runtime-env';
+import { isDesktop } from '../runtime-env';
 var ANIMATION_MS = 300;
 var STYLE_ID = 'lx-action-sheet-style';
 var activeSheet = null;
 function isDesktopMode() {
-    return getPlatformOS() === 'macOS';
+    return isDesktop();
 }
 function ensureActionSheetStyle() {
     if (document.getElementById(STYLE_ID))

package/dist/index.d.ts

@@ -8,5 +8,6 @@
 export type { BridgeConfig, CallOptions, ChannelCloseEvent, ChannelOptions, ChannelOpenOptions, BridgeErrorCode, ChannelEventName, DataSubscriber, ErrorInfo, LingXiaBridgeInterface, LxChannel, LxBridgeError, LxMethod, LxMethodParams, LxMethodResult, LxMethodStreamData, LxStream, NativeComponentMessage, NativeChannel, NativeError, NativeStream, NotifyOptions, InvokeOptions, StateInfo, StreamCallOptions, StreamOptions, StreamEventName, } from './types';
 export { LingXiaBridge, channel, initBridge, invoke, notify, stream, } from './bridge';
 export { isNativeError } from './invocation';
+export { getDisplayLanguage } from './runtime-env';
 export { renderErrorUI, hasError, getErrorInfo } from './error';
 export { boot, bootWhenReady } from './boot';

package/dist/runtime-env.d.ts

@@ -2,6 +2,7 @@ import type { BridgeConfig } from './types';
 export type CommunicationMethod = 'messageport' | 'jsinterface' | 'webmessage' | 'webkit' | 'unknown';
 export type PlatformOS = NonNullable<BridgeConfig['os']> | 'unknown';
 export declare const BRIDGE_CONFIG: BridgeConfig;
+export declare function getDisplayLanguage(): string;
 export declare function getPlatformOS(): PlatformOS;
 export declare function isHarmony(): boolean;
 export declare function isIOS(): boolean;
@@ -9,4 +10,7 @@ export declare function isAndroid(): boolean;
 export declare function isMacOS(): boolean;
 export declare function isWindows(): boolean;
 export declare function isDesktop(): boolean;
+export declare function isApple(): boolean;
+export declare function isDevSession(): boolean;
+export declare function isRunner(): boolean;
 export declare function getCommunicationMethod(): CommunicationMethod;

package/dist/types.d.ts

@@ -1,7 +1,11 @@
 export interface BridgeConfig {
     os?: 'Harmony' | 'iOS' | 'Android' | 'macOS' | 'Windows';
+    /** Effective host display language; distinct from the raw system locale. */
+    displayLanguage?: string;
     nonce?: string;
     appleDownstreamURL?: string;
+    dev?: boolean;
+    runner?: boolean;
 }
 export interface RuntimeConfig {
     error?: ErrorInfo;
@@ -161,6 +165,8 @@ export interface LingXiaBridgeInterface {
         isMacOS(): boolean;
         isWindows(): boolean;
         isDesktop(): boolean;
+        isApple(): boolean;
+        isRunner(): boolean;
         getOS(): string;
     };
     dom: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lingxia/bridge",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "private": false,
   "description": "LingXia Web Runtime - Bridge, boot, and error handling for WebView",
   "repository": {