@lingxia/bridge 0.5.0 → 0.6.0

package/dist/es2020/bridge.js

@@ -0,0 +1,1597 @@
+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";
+const NATIVE_HANDLER_NAME = "LingXia";
+const GLOBAL_RECEIVER_NAME = "__LingXiaRecvMessage";
+const DEFAULT_TIMEOUT_MS = 5000;
+const HANDSHAKE_TIMEOUT_MS = 10000;
+const HANDSHAKE_MAX_RETRIES = 3;
+const LOG_PREFIX = "[LX.Bridge]";
+const MESSAGE_PORT_TYPE = "messageport";
+const JS_INTERFACE_TYPE = "jsinterface";
+const OUTBOX_LIMIT = 256;
+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 };
+const earlyNativeMessages = [];
+function installEarlyReceiver() {
+    if (typeof window === "undefined")
+        return;
+    if (typeof window[GLOBAL_RECEIVER_NAME] === "function")
+        return;
+    window[GLOBAL_RECEIVER_NAME] = (message) => {
+        earlyNativeMessages.push(message);
+    };
+}
+function activateReceiver(receiver) {
+    if (typeof window === "undefined")
+        return;
+    window[GLOBAL_RECEIVER_NAME] = receiver;
+    if (earlyNativeMessages.length === 0)
+        return;
+    const queued = earlyNativeMessages.splice(0, earlyNativeMessages.length);
+    for (const message of queued) {
+        try {
+            receiver(message);
+        }
+        catch (err) {
+            warn("Failed to replay queued native message:", err);
+        }
+    }
+}
+function isDebugEnabled(flag) {
+    return debugFlags.all || debugFlags[flag];
+}
+function log(...args) {
+    console.log(LOG_PREFIX, ...args);
+}
+function warn(...args) {
+    console.warn(LOG_PREFIX, ...args);
+}
+function error(...args) {
+    console.error(LOG_PREFIX, ...args);
+}
+function safeStringify(obj, space) {
+    const seen = new WeakSet();
+    return JSON.stringify(obj, (_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 {
+        return safeStringify(obj);
+    }
+}
+function deepCopy(data) {
+    try {
+        if (typeof structuredClone === "function")
+            return structuredClone(data);
+        return JSON.parse(JSON.stringify(data));
+    }
+    catch {
+        return {};
+    }
+}
+const communicationMethod = getCommunicationMethod();
+installEarlyReceiver();
+// Transport
+let messagePort = null;
+let appleDownstreamConnected = false;
+let appleDownstreamTask = null;
+let appleDownstreamAbortController = null;
+let appleReconnectTimer = null;
+let appleReconnectDelayMs = APPLE_RECONNECT_BASE_MS;
+const portInitState = {
+    listenerInstalled: false,
+    promise: null,
+    resolve: null,
+    reject: null,
+    timer: null,
+};
+const portInitMessageListener = {
+    handleEvent: (event) => {
+        const messageEvent = event;
+        if (messageEvent.data !== "LingXia-port-init")
+            return;
+        const port = messageEvent.ports?.[0];
+        if (!port)
+            return;
+        LingXiaBridge._connectWebMessagePort(port);
+        portInitState.resolve?.(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) {
+    for (const [id, channel] of Array.from(activeChannels.entries())) {
+        activeChannels.delete(id);
+        channel._emitClose(BRIDGE_ERROR.STREAM_CLOSED, reason);
+    }
+}
+function rejectAllPendingForTransport(reason) {
+    for (const id of Array.from(pendingReq.keys())) {
+        rejectPendingRequest(id, {
+            code: BRIDGE_ERROR.STREAM_CLOSED,
+            message: reason,
+        });
+    }
+    for (const id of Array.from(pendingChannels.keys())) {
+        rejectPendingChannel(id, {
+            code: BRIDGE_ERROR.STREAM_CLOSED,
+            message: reason,
+        });
+    }
+    closeActiveChannelsFromTransport(reason);
+}
+function resetHandshakeState(reason, rejectPending) {
+    clearHandshakeTimer();
+    handshakeSessionId = null;
+    handshakeDone = false;
+    helloSent = false;
+    handshakeRetryCount = 0;
+    if (rejectPending)
+        rejectAllPendingForTransport(reason);
+}
+function processAppleDownstreamBuffer(buffer) {
+    let remaining = buffer;
+    while (true) {
+        const newlineIndex = remaining.indexOf("\n");
+        if (newlineIndex < 0)
+            break;
+        const 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;
+}
+async function runAppleDownstream() {
+    const controller = new AbortController();
+    appleDownstreamAbortController = controller;
+    let response;
+    try {
+        response = await fetch(APPLE_DOWNSTREAM_URL, {
+            method: "GET",
+            cache: "no-store",
+            headers: { Accept: "application/x-ndjson" },
+            signal: controller.signal,
+        });
+    }
+    catch (e) {
+        if (controller.signal.aborted)
+            return;
+        throw e;
+    }
+    if (!response.ok) {
+        throw new Error(`Apple downstream HTTP ${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();
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffered = "";
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buffered += decoder.decode(value, { stream: true });
+            buffered = processAppleDownstreamBuffer(buffered);
+        }
+        buffered += decoder.decode();
+        const tail = buffered.trim();
+        if (tail) {
+            try {
+                handleIncomingMessage(JSON.parse(tail));
+            }
+            catch (e) {
+                warn("Apple downstream trailing parse error:", e, tail);
+            }
+        }
+    }
+    finally {
+        try {
+            reader.releaseLock();
+        }
+        catch { }
+    }
+}
+function scheduleAppleDownstreamReconnect(reason) {
+    if (!useAppleDownstreamTransport())
+        return;
+    clearAppleReconnectTimer();
+    const delay = appleReconnectDelayMs;
+    appleReconnectDelayMs = Math.min(appleReconnectDelayMs * 2, APPLE_RECONNECT_MAX_MS);
+    const message = `Apple downstream disconnected, retrying in ${delay}ms: ${reason}`;
+    if (delay <= APPLE_RECONNECT_BASE_MS) {
+        log(message);
+    }
+    else {
+        warn(message);
+    }
+    appleReconnectTimer = setTimeout(() => {
+        appleReconnectTimer = null;
+        ensureAppleDownstream();
+    }, delay);
+}
+function ensureAppleDownstream() {
+    if (!useAppleDownstreamTransport())
+        return;
+    if (appleDownstreamTask)
+        return;
+    clearAppleReconnectTimer();
+    appleDownstreamTask = runAppleDownstream()
+        .catch((e) => {
+        if (appleDownstreamAbortController?.signal.aborted)
+            return;
+        warn("Apple downstream failed:", e);
+    })
+        .finally(() => {
+        const aborted = appleDownstreamAbortController?.signal.aborted ?? false;
+        appleDownstreamTask = null;
+        appleDownstreamAbortController = null;
+        const wasConnected = appleDownstreamConnected;
+        appleDownstreamConnected = false;
+        resetHandshakeState("Apple downstream closed", wasConnected);
+        if (!aborted)
+            scheduleAppleDownstreamReconnect("stream closed");
+    });
+}
+function getMessagePort() {
+    if (messagePort)
+        return Promise.resolve(messagePort);
+    if (portInitState.promise)
+        return portInitState.promise;
+    const timeoutMs = 5000;
+    installMessagePortInitListener();
+    portInitState.promise = new Promise((resolve, reject) => {
+        portInitState.resolve = (port) => {
+            cleanupPortInit();
+            resolve(port);
+        };
+        portInitState.reject = (err) => {
+            cleanupPortInit();
+            reject(err);
+        };
+        portInitState.timer = window.setTimeout(() => {
+            portInitState.reject?.(new Error(`MessagePort init timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+    });
+    try {
+        window.LingXiaProxy?.getPort("LingXiaPort");
+    }
+    catch (e) {
+        portInitState.reject?.(e);
+    }
+    return portInitState.promise;
+}
+function postToNative(message) {
+    const kind = message.kind;
+    if (kind === "req" || kind === "notify")
+        log(`postToNative: ${kind} ${message.method}`);
+    if (isDebugEnabled("proto"))
+        console.log("→", JSON.stringify(message, null, 2));
+    try {
+        if (communicationMethod === "webkit") {
+            window.webkit?.messageHandlers[NATIVE_HANDLER_NAME]?.postMessage(message);
+            return;
+        }
+        const messageString = stringifyForNative(message);
+        if (communicationMethod === MESSAGE_PORT_TYPE && messagePort) {
+            messagePort.postMessage(messageString);
+            return;
+        }
+        if (communicationMethod === JS_INTERFACE_TYPE &&
+            window.LingXiaProxy?.postMessage) {
+            window.LingXiaProxy.postMessage(messageString);
+            return;
+        }
+        warn("Transport not ready");
+    }
+    catch (e) {
+        error("Send error:", e);
+    }
+}
+// Handshake state
+let handshakeSessionId = null;
+let handshakeDone = false;
+let helloSent = false;
+let handshakeRetryCount = 0;
+let handshakeTimer = null;
+// Host method schema — populated from handshake `Ready` message.
+// Maps "namespace.method" → "call" | "stream".
+const hostMethodKinds = {};
+// Request tracking
+let requestCounter = 0;
+function createListenerBuckets() {
+    return {
+        data: new Set(),
+        end: new Set(),
+        error: new Set(),
+        close: new Set(),
+    };
+}
+function createStreamHandle(id, cancelFn) {
+    const listeners = createListenerBuckets();
+    let done = false;
+    let resolveResult = () => { };
+    let rejectResult = () => { };
+    const pendingData = [];
+    const pendingReads = [];
+    const result = new Promise((resolve, reject) => {
+        resolveResult = resolve;
+        rejectResult = reject;
+    });
+    const handle = {
+        id,
+        result,
+        on(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;
+        },
+        [Symbol.asyncIterator]() {
+            return {
+                next() {
+                    if (pendingData.length > 0) {
+                        return Promise.resolve({
+                            done: false,
+                            value: pendingData.shift(),
+                        });
+                    }
+                    if (done) {
+                        return result.then((finalValue) => ({ done: true, value: finalValue }), (err) => Promise.reject(err));
+                    }
+                    return new Promise((resolve, reject) => {
+                        pendingReads.push({ resolve, reject });
+                    });
+                },
+            };
+        },
+        cancel() {
+            if (done)
+                return;
+            cancelFn();
+        },
+        _emitData(payload) {
+            if (done)
+                return;
+            if (pendingReads.length > 0) {
+                pendingReads.shift().resolve({ done: false, value: payload });
+            }
+            else {
+                pendingData.push(payload);
+            }
+            for (const listener of listeners.data) {
+                try {
+                    listener(payload);
+                }
+                catch (e) {
+                    warn("Stream data listener failed:", e);
+                }
+            }
+        },
+        _resolve(resultValue) {
+            if (done)
+                return;
+            done = true;
+            resolveResult(resultValue);
+            while (pendingReads.length > 0) {
+                pendingReads.shift().resolve({ done: true, value: resultValue });
+            }
+            for (const listener of listeners.end) {
+                try {
+                    listener(resultValue);
+                }
+                catch (e) {
+                    warn("Stream end listener failed:", e);
+                }
+            }
+        },
+        _reject(err) {
+            if (done)
+                return;
+            done = true;
+            rejectResult(err);
+            while (pendingReads.length > 0) {
+                pendingReads.shift().reject(err);
+            }
+            for (const listener of listeners.error) {
+                try {
+                    listener(err);
+                }
+                catch (e) {
+                    warn("Stream error listener failed:", e);
+                }
+            }
+        },
+    };
+    return handle;
+}
+function createChannel(id, sendFn, closeFn) {
+    const listeners = createListenerBuckets();
+    let open = false;
+    let outboundSeq = 0;
+    let closed = false;
+    const pendingData = [];
+    const pendingReads = [];
+    const channel = {
+        id,
+        send(payload) {
+            if (!open) {
+                channel._reject({
+                    code: BRIDGE_ERROR.STREAM_CLOSED,
+                    message: `Channel '${id}' is closed`,
+                });
+                return;
+            }
+            sendFn(payload, outboundSeq++);
+        },
+        on(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;
+        },
+        [Symbol.asyncIterator]() {
+            return {
+                next() {
+                    if (pendingData.length > 0) {
+                        return Promise.resolve({
+                            done: false,
+                            value: pendingData.shift(),
+                        });
+                    }
+                    if (closed) {
+                        return Promise.resolve({ done: true, value: undefined });
+                    }
+                    return new Promise((resolve, reject) => {
+                        pendingReads.push({ resolve, reject });
+                    });
+                },
+            };
+        },
+        close(code, reason) {
+            if (!open)
+                return;
+            open = false;
+            closed = true;
+            closeFn(code, reason);
+            channel._emitClose(code, reason);
+        },
+        _emitData(payload) {
+            if (!open)
+                return;
+            if (pendingReads.length > 0) {
+                pendingReads.shift().resolve({ done: false, value: payload });
+            }
+            else {
+                pendingData.push(payload);
+            }
+            for (const listener of listeners.data) {
+                try {
+                    listener(payload);
+                }
+                catch (e) {
+                    warn("Channel listener failed:", e);
+                }
+            }
+        },
+        _emitClose(code, reason) {
+            closed = true;
+            while (pendingReads.length > 0) {
+                pendingReads.shift().resolve({ done: true, value: undefined });
+            }
+            for (const listener of listeners.close) {
+                try {
+                    listener(code, reason);
+                }
+                catch (e) {
+                    warn("Channel close listener failed:", e);
+                }
+            }
+        },
+        _reject(err) {
+            closed = true;
+            while (pendingReads.length > 0) {
+                pendingReads.shift().reject(err);
+            }
+            for (const listener of listeners.error) {
+                try {
+                    listener(err);
+                }
+                catch (e) {
+                    warn("Channel error listener failed:", e);
+                }
+            }
+        },
+        _markOpen() {
+            open = true;
+            closed = false;
+        },
+        _isOpen() {
+            return open;
+        },
+        _nextSeq() {
+            return outboundSeq++;
+        },
+    };
+    return channel;
+}
+const pendingReq = new Map();
+const pendingChannels = new Map();
+const activeChannels = new Map();
+const outbox = [];
+// State sync
+let stateRev = -1;
+let pageData = {};
+const dataSubscribers = new Set();
+const subscriberInitStatus = new WeakMap();
+// Logic→View method handlers (for incoming req from native side)
+const viewMethodHandlers = new Map();
+export function registerViewMethodHandler(method, handler) {
+    viewMethodHandlers.set(method, handler);
+}
+function inferCap(method) {
+    if (method.startsWith("host."))
+        return "host";
+    const 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) {
+    const info = pendingReq.get(reqId);
+    if (info) {
+        pendingReq.delete(reqId);
+        if (info.timerId !== null)
+            clearTimeout(info.timerId);
+        const normalized = toBridgeError(err);
+        if (info.mode === "stream" && info.stream) {
+            info.stream._reject(normalized);
+            return;
+        }
+        info.reject?.(normalized);
+    }
+}
+function rejectPendingChannel(id, err) {
+    const pending = pendingChannels.get(id);
+    if (!pending)
+        return;
+    pendingChannels.delete(id);
+    if (pending.timerId !== null)
+        clearTimeout(pending.timerId);
+    const 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) {
+    const 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(() => {
+        if (!pendingReq.has(reqId))
+            return;
+        rejectPendingRequest(reqId, {
+            code: BRIDGE_ERROR.TIMEOUT,
+            message: `'${info.method}' timed out`,
+        });
+    }, info.timeoutMs);
+}
+function armChannelTimer(id) {
+    const pending = pendingChannels.get(id);
+    if (!pending)
+        return;
+    if (pending.timerId !== null)
+        clearTimeout(pending.timerId);
+    pending.timerId = setTimeout(() => {
+        rejectPendingChannel(id, {
+            code: BRIDGE_ERROR.TIMEOUT,
+            message: `Channel '${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) {
+    for (let i = outbox.length - 1; i >= 0; i--) {
+        if (outbox[i]?.reqId === reqId) {
+            outbox.splice(i, 1);
+            return true;
+        }
+    }
+    return false;
+}
+function send(msg, reqId) {
+    const kind = msg.kind;
+    const 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, reqId });
+        return;
+    }
+    if (reqId)
+        armPendingOperationTimer(reqId);
+    postToNative(msg);
+}
+function flushOutbox() {
+    if (!canSendAppMessages())
+        return;
+    while (outbox.length) {
+        const 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();
+    const hello = {
+        v: 2,
+        kind: "hello",
+        nonce: BRIDGE_CONFIG.nonce || "",
+        role: "view",
+        protocolsSupported: [2],
+    };
+    helloSent = true;
+    postToNative(hello);
+    handshakeTimer = setTimeout(() => {
+        if (handshakeDone)
+            return;
+        handshakeRetryCount++;
+        if (handshakeRetryCount < HANDSHAKE_MAX_RETRIES) {
+            warn(`Handshake timeout (${handshakeRetryCount}/${HANDSHAKE_MAX_RETRIES}), retrying...`);
+            helloSent = false;
+            startHandshake();
+        }
+        else {
+            error("Handshake failed");
+            clearHandshakeTimer();
+            helloSent = false;
+            handshakeRetryCount = 0;
+            while (outbox.length) {
+                const item = outbox.shift();
+                if (item?.reqId) {
+                    rejectPendingOperation(item.reqId, {
+                        code: BRIDGE_ERROR.HANDSHAKE_FAILED,
+                        message: "Bridge handshake failed",
+                    });
+                }
+            }
+            for (const id of Array.from(pendingChannels.keys())) {
+                rejectPendingChannel(id, {
+                    code: BRIDGE_ERROR.HANDSHAKE_FAILED,
+                    message: "Bridge handshake failed",
+                });
+            }
+        }
+    }, HANDSHAKE_TIMEOUT_MS);
+}
+function parseIncoming(msg) {
+    if (!msg || typeof msg !== "object")
+        return null;
+    const v = msg.v;
+    const 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: ${path}`);
+    return path.split("/").slice(1).map(jsonPointerUnescape);
+}
+function getContainerAndKey(root, pointer, autoCreate = false) {
+    const segments = parseJsonPointer(pointer);
+    if (segments.length === 0)
+        return { container: { $root: root }, key: "$root" };
+    let current = root;
+    for (let i = 0; i < segments.length - 1; i++) {
+        const seg = segments[i];
+        if (Array.isArray(current)) {
+            current = current[Number(seg)];
+        }
+        else if (current && typeof current === "object") {
+            const obj = current;
+            if (autoCreate && obj[seg] === undefined) {
+                const nextSeg = segments[i + 1];
+                obj[seg] = nextSeg && /^\d+$/.test(nextSeg) ? [] : {};
+            }
+            current = obj[seg];
+        }
+        else {
+            throw new Error(`Invalid container at ${seg}`);
+        }
+    }
+    return { container: current, key: segments[segments.length - 1] };
+}
+function applyJsonPatch(target, ops) {
+    for (const op of ops) {
+        const autoCreate = op.op === "add" || op.op === "replace";
+        const { container, key } = getContainerAndKey(target, op.path, autoCreate);
+        if (key === "$root") {
+            for (const k of Object.keys(target))
+                delete target[k];
+            if (op.op !== "remove") {
+                const v = op.value;
+                if (v && typeof v === "object")
+                    Object.assign(target, v);
+            }
+            continue;
+        }
+        if (Array.isArray(container)) {
+            const 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`);
+        const obj = container;
+        if (op.op === "remove")
+            delete obj[key];
+        else
+            obj[key] = op.value;
+    }
+}
+function notifyStateSubscribers(initial) {
+    dataSubscribers.forEach((listener) => {
+        try {
+            if (!subscriberInitStatus.has(listener)) {
+                subscriberInitStatus.set(listener, true);
+                listener(deepCopy(pageData), { rev: stateRev, initial: true });
+                return;
+            }
+            listener(deepCopy(pageData), { rev: stateRev, initial });
+        }
+        catch (e) {
+            warn("Subscriber error:", e);
+        }
+    });
+}
+function subscribeState(callback) {
+    if (typeof callback !== "function")
+        return () => { };
+    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 () => {
+        dataSubscribers.delete(callback);
+        subscriberInitStatus.delete(callback);
+    };
+}
+function requestStateRecovery(scope) {
+    rawBridge.call("state.getSnapshot", { scope }).catch(() => { });
+}
+function applySnapshotFromResult(result) {
+    if (!result || typeof result !== "object")
+        return false;
+    const 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) {
+    // Handle native component events (from Android NativeBridge.sendEventToView)
+    if (msg && typeof msg === "object") {
+        const obj = msg;
+        if (obj.type === "event" && obj.name === "nativecomponent" && obj.payload) {
+            const payload = obj.payload;
+            const componentId = payload.id ||
+                payload.componentId;
+            if (typeof componentId === "string") {
+                const handler = nativeComponentHandlers.get(componentId);
+                if (handler) {
+                    try {
+                        handler(payload);
+                    }
+                    catch (e) {
+                        error("NC handler error:", e);
+                    }
+                }
+            }
+            return;
+        }
+    }
+    const 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) {
+                for (const [k, v] of Object.entries(message.hostMethods)) {
+                    hostMethodKinds[k] = v;
+                }
+            }
+            if (isDebugEnabled("proto"))
+                log("Handshake complete, hostMethods:", Object.keys(hostMethodKinds).length);
+            flushOutbox();
+            return;
+        case "res": {
+            const 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;
+                }
+                info.resolve?.(message.result);
+            }
+            else {
+                const err = toBridgeError(message.error);
+                if (info.mode === "stream" && info.stream) {
+                    info.stream._reject(err);
+                    return;
+                }
+                info.reject?.(err);
+            }
+            return;
+        }
+        case "event": {
+            if (pendingReq.has(message.id)) {
+                const req = pendingReq.get(message.id);
+                if (req?.mode === "stream" && req.stream) {
+                    armRequestTimer(message.id);
+                    req.stream._emitData(message.payload);
+                }
+                else {
+                    warn(`Received event for non-stream request '${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": {
+            const 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 {
+                const err = toBridgeError(message.error);
+                pendingChannel.channel._reject(err);
+                pendingChannel.reject(err);
+            }
+            return;
+        }
+        case "ch.data": {
+            const channel = activeChannels.get(message.id);
+            if (!channel)
+                return;
+            channel._emitData(message.payload);
+            return;
+        }
+        case "ch.close": {
+            const pendingChannel = pendingChannels.get(message.id);
+            if (pendingChannel) {
+                pendingChannels.delete(message.id);
+                pendingChannel.channel._emitClose(message.code, message.reason);
+                return;
+            }
+            const channel = activeChannels.get(message.id);
+            if (!channel)
+                return;
+            activeChannels.delete(message.id);
+            channel._emitClose(message.code, message.reason);
+            return;
+        }
+        case "req": {
+            const reqMsg = message;
+            const requiredCap = inferCap(reqMsg.method);
+            if (!reqMsg.cap || reqMsg.cap !== requiredCap) {
+                send({
+                    v: 2,
+                    kind: "res",
+                    id: reqMsg.id,
+                    ok: false,
+                    error: {
+                        code: BRIDGE_ERROR.CAPABILITY_DENIED,
+                        message: `Invalid cap for ${reqMsg.method}`,
+                    },
+                });
+                return;
+            }
+            const handler = viewMethodHandlers.get(reqMsg.method);
+            if (!handler) {
+                send({
+                    v: 2,
+                    kind: "res",
+                    id: reqMsg.id,
+                    ok: false,
+                    error: {
+                        code: BRIDGE_ERROR.METHOD_NOT_FOUND,
+                        message: `View handler not found: ${reqMsg.method}`,
+                    },
+                });
+                return;
+            }
+            Promise.resolve()
+                .then(() => handler(reqMsg.params))
+                .then((result) => {
+                send({ v: 2, kind: "res", id: reqMsg.id, ok: true, result });
+            })
+                .catch((err) => {
+                send({
+                    v: 2,
+                    kind: "res",
+                    id: reqMsg.id,
+                    ok: false,
+                    error: toBridgeError(err),
+                });
+            });
+            return;
+        }
+    }
+}
+// Native components
+const nativeComponentHandlers = new Map();
+const nativeComponentQueue = [];
+let nativeComponentReady = false;
+function hasNativeComponentHandler() {
+    if (typeof window === "undefined")
+        return false;
+    return !!(window.webkit?.messageHandlers?.NativeComponent ||
+        window.NativeComponentBridge?.postMessage);
+}
+function postNativeComponentMessage(message) {
+    try {
+        if (window.webkit?.messageHandlers?.NativeComponent) {
+            window.webkit.messageHandlers.NativeComponent.postMessage(message);
+            return;
+        }
+        if (window.NativeComponentBridge?.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) {
+        const msg = nativeComponentQueue.shift();
+        try {
+            postNativeComponentMessage(msg);
+        }
+        catch {
+            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 `${prefix}_${Date.now()}_${requestCounter++}`;
+}
+function attachAbortSignal(id, signal, onAbort) {
+    if (!signal)
+        return;
+    if (signal.aborted) {
+        onAbort();
+        return;
+    }
+    let abortListener;
+    abortListener = {
+        handleEvent: () => {
+            signal.removeEventListener("abort", abortListener);
+            onAbort();
+        },
+    };
+    signal.addEventListener("abort", abortListener);
+}
+// 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") {
+                reject({
+                    code: BRIDGE_ERROR.MALFORMED_MESSAGE,
+                    message: "Method name must be a non-empty string",
+                });
+                return;
+            }
+            if (!helloSent)
+                startHandshake();
+            const id = nextMessageId("c");
+            const cap = options?.cap || inferCap(method);
+            const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+            pendingReq.set(id, {
+                method,
+                mode: "call",
+                resolve,
+                reject: (e) => reject(e),
+                timeoutMs,
+                timerId: null,
+            });
+            const req = {
+                v: 2,
+                kind: "req",
+                id,
+                method,
+                params: normalizeParams(params),
+                cap,
+            };
+            send(req, id);
+            attachAbortSignal(id, options?.signal, () => {
+                const removed = removeOutboxByReqId(id);
+                rejectPendingRequest(id, {
+                    code: BRIDGE_ERROR.CANCELED,
+                    message: "Bridge request aborted",
+                });
+                if (!removed && handshakeDone)
+                    send({ v: 2, kind: "cancel", id });
+            });
+        });
+    },
+    stream(method, params, options) {
+        if (!method || typeof method !== "string") {
+            const invalid = createStreamHandle("invalid", () => { });
+            invalid._reject({
+                code: BRIDGE_ERROR.MALFORMED_MESSAGE,
+                message: "Method name must be a non-empty string",
+            });
+            return invalid;
+        }
+        if (!helloSent)
+            startHandshake();
+        const id = nextMessageId("c");
+        const handle = createStreamHandle(id, () => {
+            const removed = removeOutboxByReqId(id);
+            if (removed) {
+                rejectPendingRequest(id, {
+                    code: BRIDGE_ERROR.CANCELED,
+                    message: "Bridge request aborted",
+                });
+                return;
+            }
+            if (handshakeDone)
+                send({ v: 2, kind: "cancel", id });
+        });
+        const cap = options?.cap || inferCap(method);
+        const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        pendingReq.set(id, {
+            method,
+            mode: "stream",
+            stream: handle,
+            timeoutMs,
+            timerId: null,
+        });
+        send({
+            v: 2,
+            kind: "req",
+            id,
+            method,
+            params: normalizeParams(params),
+            cap,
+        }, id);
+        attachAbortSignal(id, options?.signal, () => handle.cancel());
+        return handle;
+    },
+    notify(method, params, options) {
+        if (!method || typeof method !== "string")
+            return;
+        if (!helloSent)
+            startHandshake();
+        send({
+            v: 2,
+            kind: "notify",
+            method,
+            params: normalizeParams(params),
+            cap: options?.cap || inferCap(method),
+        });
+    },
+    state: {
+        subscribe: subscribeState,
+    },
+    channel: {
+        open(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((resolve, reject) => {
+                const id = nextMessageId("ch");
+                const channel = createChannel(id, (payload, seq) => {
+                    send({ v: 2, kind: "ch.data", id, seq, payload });
+                }, (code, reason) => {
+                    const 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, code, reason });
+                });
+                pendingChannels.set(id, {
+                    topic,
+                    channel,
+                    resolve: resolve,
+                    reject,
+                    timerId: null,
+                });
+                send({
+                    v: 2,
+                    kind: "ch.open",
+                    id,
+                    topic,
+                    params: normalizeParams(params),
+                    cap: options?.cap || inferCap(topic),
+                }, id);
+            });
+        },
+    },
+};
+// 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;
+        if (messagePort && messagePort !== port) {
+            try {
+                messagePort.onmessage = null;
+                messagePort.close();
+            }
+            catch { }
+        }
+        messagePort = port;
+        port.onmessage = (event) => {
+            let data = event.data;
+            if (typeof data === "string") {
+                try {
+                    data = JSON.parse(data);
+                }
+                catch {
+                    return;
+                }
+            }
+            handleIncomingMessage(data);
+        };
+        // Some WebView MessagePort implementations (notably Android WebMessagePort)
+        // require an explicit start() to begin dispatching onmessage events.
+        try {
+            port.start();
+        }
+        catch { }
+        log("Port connected");
+        startHandshake();
+    },
+    _receiveEvaluateMessage(messageString) {
+        try {
+            if (messageString)
+                handleIncomingMessage(JSON.parse(messageString));
+        }
+        catch (e) {
+            error("Parse error:", e);
+        }
+    },
+    debug: new Proxy(debugFlags, {
+        get(target, prop) {
+            return target[prop];
+        },
+        set(target, prop, value) {
+            if (prop in target) {
+                target[prop] = !!value;
+                console.log(`[LX] ${prop}: ${value}`);
+                return true;
+            }
+            return false;
+        },
+    }),
+    platform: {
+        isHarmony,
+        isIOS,
+        isAndroid,
+        isMacOS,
+        isDesktop,
+        getOS: getPlatformOS,
+    },
+    dom: {
+        measureById(id) {
+            try {
+                if (!id)
+                    return null;
+                const el = document.getElementById(id);
+                if (!el)
+                    return null;
+                const r = el.getBoundingClientRect();
+                let radius = 0;
+                try {
+                    radius = parseFloat(getComputedStyle(el).borderRadius) || 0;
+                }
+                catch { }
+                return [
+                    r.left + window.scrollX,
+                    r.top + window.scrollY,
+                    r.width,
+                    r.height,
+                    radius,
+                ];
+            }
+            catch {
+                return null;
+            }
+        },
+    },
+    nativeComponents: {
+        send: sendNativeComponentMessage,
+        hasHandler: hasNativeComponentHandler,
+        flush: flushNativeComponentQueue,
+        register(id, handler) {
+            if (!id || typeof handler !== "function")
+                return () => { };
+            nativeComponentHandlers.set(id, handler);
+            return () => nativeComponentHandlers.delete(id);
+        },
+        unregister(id) {
+            nativeComponentHandlers.delete(id);
+        },
+    },
+    isReady() {
+        return handshakeDone;
+    },
+};
+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);
+            };
+        },
+        onError(listener) {
+            errorListeners.add(listener);
+            return () => {
+                errorListeners.delete(listener);
+            };
+        },
+        result: handle.result.catch((error) => Promise.reject(toNativeError(error))),
+        cancel() {
+            handle.cancel();
+        },
+    };
+}
+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);
+        },
+        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 function initBridge() {
+    if (window.__LX_BRIDGE_INIT_STATE) {
+        log(`Bridge already ${window.__LX_BRIDGE_INIT_STATE}, skipping duplicate init`);
+        return;
+    }
+    window.__LX_BRIDGE_INIT_STATE = "initializing";
+    try {
+        log(`Method: ${communicationMethod}`);
+        activateReceiver(LingXiaBridge._receiveEvaluateMessage);
+        if (useAppleDownstreamTransport()) {
+            ensureAppleDownstream();
+        }
+        else if (communicationMethod === MESSAGE_PORT_TYPE) {
+            installMessagePortInitListener();
+            getMessagePort().catch((e) => 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;
+    }
+}