@lingxia/bridge 0.9.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, 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;
@@ -93,6 +93,7 @@ var HANDSHAKE_MAX_RETRIES = 3;
 var LOG_PREFIX = "[LX.Bridge]";
 var MESSAGE_PORT_TYPE = "messageport";
 var JS_INTERFACE_TYPE = "jsinterface";
+var WEB_MESSAGE_TYPE = "webmessage";
 var OUTBOX_LIMIT = 256;
 var APPLE_DOWNSTREAM_URL = BRIDGE_CONFIG.appleDownstreamURL;
 var APPLE_RECONNECT_BASE_MS = 200;
@@ -158,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() {
@@ -217,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,
@@ -261,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 {
@@ -334,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);
@@ -342,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:
@@ -353,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" },
@@ -364,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();
@@ -394,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);
@@ -417,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);
     }
@@ -436,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;
@@ -452,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)
@@ -506,7 +654,8 @@ function postToNative(message) {
             messagePort.postMessage(messageString);
             return;
         }
-        if (communicationMethod === JS_INTERFACE_TYPE &&
+        if ((communicationMethod === JS_INTERFACE_TYPE ||
+            communicationMethod === WEB_MESSAGE_TYPE) &&
             ((_c = window.LingXiaProxy) === null || _c === void 0 ? void 0 : _c.postMessage)) {
             window.LingXiaProxy.postMessage(messageString);
             return;
@@ -540,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 = [];
@@ -562,6 +714,7 @@ function createStreamHandle(id, cancelFn) {
             }
         },
         _a[Symbol.asyncIterator] = function () {
+            iteratorRequested = true;
             return {
                 next: function () {
                     if (pendingData.length > 0) {
@@ -591,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 {
@@ -678,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 = {
@@ -693,8 +849,35 @@ function createChannel(id, sendFn, closeFn) {
                 sendFn(payload, outboundSeq++);
             },
             on: function (event, listener) {
-                if (event === "data")
+                var e_9, _a;
+                if (event === "data") {
                     listeners.data.add(listener);
+                    // Flush data buffered before this listener attached. The host can send
+                    // ch.data immediately after the open ack, before the consumer (e.g. a
+                    // wrapped channel's onMessage) attaches its listener; without this those
+                    // early events would sit in pendingData and never reach the listener.
+                    if (pendingData.length > 0) {
+                        var buffered = pendingData.splice(0);
+                        try {
+                            for (var buffered_1 = __values(buffered), buffered_1_1 = buffered_1.next(); !buffered_1_1.done; buffered_1_1 = buffered_1.next()) {
+                                var payload = buffered_1_1.value;
+                                try {
+                                    listener(payload);
+                                }
+                                catch (e) {
+                                    warn("Channel listener failed:", e);
+                                }
+                            }
+                        }
+                        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                        finally {
+                            try {
+                                if (buffered_1_1 && !buffered_1_1.done && (_a = buffered_1.return)) _a.call(buffered_1);
+                            }
+                            finally { if (e_9) throw e_9.error; }
+                        }
+                    }
+                }
                 if (event === "close")
                     listeners.close.add(listener);
                 if (event === "error")
@@ -703,6 +886,7 @@ function createChannel(id, sendFn, closeFn) {
             }
         },
         _a[Symbol.asyncIterator] = function () {
+            iteratorRequested = true;
             return {
                 next: function () {
                     if (pendingData.length > 0) {
@@ -729,13 +913,13 @@ function createChannel(id, sendFn, closeFn) {
             channel._emitClose(code, reason);
         },
         _a._emitData = function (payload) {
-            var e_9, _a;
+            var e_10, _a;
             if (!open)
                 return;
             if (pendingReads.length > 0) {
                 pendingReads.shift().resolve({ done: false, value: payload });
             }
-            else {
+            else if (iteratorRequested || listeners.data.size === 0) {
                 pendingData.push(payload);
             }
             try {
@@ -749,16 +933,16 @@ function createChannel(id, sendFn, closeFn) {
                     }
                 }
             }
-            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            catch (e_10_1) { e_10 = { error: e_10_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_9) throw e_9.error; }
+                finally { if (e_10) throw e_10.error; }
             }
         },
         _a._emitClose = function (code, reason) {
-            var e_10, _a;
+            var e_11, _a;
             closed = true;
             while (pendingReads.length > 0) {
                 pendingReads.shift().resolve({ done: true, value: undefined });
@@ -774,16 +958,16 @@ function createChannel(id, sendFn, closeFn) {
                     }
                 }
             }
-            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            catch (e_11_1) { e_11 = { error: e_11_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_10) throw e_10.error; }
+                finally { if (e_11) throw e_11.error; }
             }
         },
         _a._reject = function (err) {
-            var e_11, _a;
+            var e_12, _a;
             closed = true;
             while (pendingReads.length > 0) {
                 pendingReads.shift().reject(err);
@@ -799,12 +983,12 @@ function createChannel(id, sendFn, closeFn) {
                     }
                 }
             }
-            catch (e_11_1) { e_11 = { error: e_11_1 }; }
+            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_11) throw e_11.error; }
+                finally { if (e_12) throw e_12.error; }
             }
         },
         _a._markOpen = function () {
@@ -851,10 +1035,19 @@ function isTransportReady() {
     if (useAppleDownstreamTransport())
         return appleDownstreamConnected;
     return (communicationMethod === "webkit" ||
-        communicationMethod === JS_INTERFACE_TYPE);
+        communicationMethod === JS_INTERFACE_TYPE ||
+        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;
@@ -1000,7 +1193,7 @@ function startHandshake() {
     helloSent = true;
     postToNative(hello);
     handshakeTimer = setTimeout(function () {
-        var e_12, _a;
+        var e_13, _a;
         if (handshakeDone)
             return;
         handshakeRetryCount++;
@@ -1032,12 +1225,12 @@ function startHandshake() {
                     });
                 }
             }
-            catch (e_12_1) { e_12 = { error: e_12_1 }; }
+            catch (e_13_1) { e_13 = { error: e_13_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_12) throw e_12.error; }
+                finally { if (e_13) throw e_13.error; }
             }
         }
     }, HANDSHAKE_TIMEOUT_MS);
@@ -1088,7 +1281,7 @@ function getContainerAndKey(root, pointer, autoCreate) {
     return { container: current, key: segments[segments.length - 1] };
 }
 function applyJsonPatch(target, ops) {
-    var e_13, _a, e_14, _b;
+    var e_14, _a, e_15, _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;
@@ -1096,17 +1289,17 @@ function applyJsonPatch(target, ops) {
             var _c = getContainerAndKey(target, op.path, autoCreate), container = _c.container, key = _c.key;
             if (key === "$root") {
                 try {
-                    for (var _d = (e_14 = void 0, __values(Object.keys(target))), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    for (var _d = (e_15 = 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 }; }
+                catch (e_15_1) { e_15 = { error: e_15_1 }; }
                 finally {
                     try {
                         if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
                     }
-                    finally { if (e_14) throw e_14.error; }
+                    finally { if (e_15) throw e_15.error; }
                 }
                 if (op.op !== "remove") {
                     var v = op.value;
@@ -1136,12 +1329,12 @@ function applyJsonPatch(target, ops) {
                 obj[key] = op.value;
         }
     }
-    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+    catch (e_14_1) { e_14 = { error: e_14_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; }
+        finally { if (e_14) throw e_14.error; }
     }
 }
 function notifyStateSubscribers(initial) {
@@ -1199,8 +1392,8 @@ function applySnapshotFromResult(result) {
     return true;
 }
 function handleIncomingMessage(msg) {
-    var e_15, _a;
-    var _b, _c;
+    var e_16, _a;
+    var _b, _c, _d, _e;
     // Handle native component events (from Android NativeBridge.sendEventToView)
     if (msg && typeof msg === "object") {
         var obj = msg;
@@ -1241,17 +1434,17 @@ 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_15_1) { e_15 = { error: e_15_1 }; }
+                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_15) throw e_15.error; }
+                    finally { if (e_16) throw e_16.error; }
                 }
             }
             if (isDebugEnabled("proto"))
@@ -1291,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 {
@@ -1369,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);
@@ -1720,7 +1923,10 @@ export var LingXiaBridge = {
         isIOS: isIOS,
         isAndroid: isAndroid,
         isMacOS: isMacOS,
+        isWindows: isWindows,
         isDesktop: isDesktop,
+        isApple: isApple,
+        isRunner: isRunner,
         getOS: getPlatformOS,
     },
     dom: {
@@ -1778,23 +1984,23 @@ function wrapNativeStream(handle) {
     var eventListeners = new Set();
     var errorListeners = new Set();
     handle.on("data", function (event) {
-        var e_16, _a;
+        var e_17, _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 }; }
+        catch (e_17_1) { e_17 = { error: e_17_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; }
+            finally { if (e_17) throw e_17.error; }
         }
     });
     handle.on("error", function (error) {
-        var e_17, _a;
+        var e_18, _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()) {
@@ -1802,12 +2008,12 @@ function wrapNativeStream(handle) {
                 listener(nativeError);
             }
         }
-        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        catch (e_18_1) { e_18 = { error: e_18_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; }
+            finally { if (e_18) throw e_18.error; }
         }
     });
     return {
@@ -1833,23 +2039,23 @@ function wrapNativeChannel(channel) {
     var messageListeners = new Set();
     var closeListeners = new Set();
     channel.on("data", function (message) {
-        var e_18, _a;
+        var e_19, _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 }; }
+        catch (e_19_1) { e_19 = { error: e_19_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; }
+            finally { if (e_19) throw e_19.error; }
         }
     });
     channel.on("close", function (code, reason) {
-        var e_19, _a;
+        var e_20, _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()) {
@@ -1857,12 +2063,12 @@ function wrapNativeChannel(channel) {
                 listener(event);
             }
         }
-        catch (e_19_1) { e_19 = { error: e_19_1 }; }
+        catch (e_20_1) { e_20 = { error: e_20_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; }
+            finally { if (e_20) throw e_20.error; }
         }
     });
     return {
@@ -1909,19 +2115,25 @@ export function initBridge() {
         activateReceiver(LingXiaBridge._receiveEvaluateMessage);
         if (useAppleDownstreamTransport()) {
             ensureAppleDownstream();
+            startAppleWatchdog();
+            installAppleForegroundReconnect();
         }
         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) {
+            communicationMethod === JS_INTERFACE_TYPE ||
+            communicationMethod === WEB_MESSAGE_TYPE) {
             startHandshake();
         }
         else {
             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,