@condorinst/mobile-bridge 0.19.2 → 0.21.0

package/dist/dev-harness.global.js

@@ -0,0 +1,2110 @@
+"use strict";
+var CondorDevHarness = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/dev/index.ts
+  var dev_exports = {};
+  __export(dev_exports, {
+    CANVAS_CSP: () => CANVAS_CSP,
+    CANVAS_POLICY: () => CANVAS_POLICY,
+    DEFAULT_LOG_PERIOD_S: () => DEFAULT_LOG_PERIOD_S,
+    DEV_HARNESS_MARKER: () => DEV_HARNESS_MARKER,
+    HARNESS_NATIVE_VERSION: () => HARNESS_NATIVE_VERSION,
+    SCENARIOS: () => SCENARIOS,
+    createDevHarness: () => createDevHarness,
+    createSimulatedNative: () => createSimulatedNative,
+    formatLocalTimestamp: () => formatLocalTimestamp,
+    parseLocalTimestamp: () => parseLocalTimestamp,
+    resolveScenario: () => resolveScenario,
+    sensorLogPage: () => sensorLogPage,
+    sharedSerial: () => sharedSerial,
+    systemStatus: () => systemStatus,
+    twoDevices: () => twoDevices
+  });
+
+  // src/dev/fixtures.ts
+  var DEFAULT_LOG_PERIOD_S = 60;
+  var pad = (n) => String(n).padStart(2, "0");
+  function formatLocalTimestamp(date) {
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+  }
+  function parseLocalTimestamp(value) {
+    const m = /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/.exec(value);
+    if (!m) return Number.NaN;
+    const [, y, mo, d, h, mi, s] = m.map(Number);
+    return new Date(y ?? 0, (mo ?? 1) - 1, d ?? 1, h ?? 0, mi ?? 0, s ?? 0).getTime();
+  }
+  function config(spec) {
+    const item = {
+      deviceId: spec.deviceId,
+      serialNo: spec.serialNo,
+      deviceBodyPart: spec.bodyPart,
+      bleConnectionPeriod: 5,
+      autosync: true,
+      eraseDeviceMemory: false,
+      autoEraseDeviceMemory: false,
+      autoEraseDeviceMemoryThreshold: 80,
+      readSensorsMemory: false,
+      startDevice: false,
+      readFullMemory: false,
+      allowFirmwareUpdate: true
+    };
+    if (spec.modelId) item.modelId = spec.modelId;
+    return item;
+  }
+  function telemetry(spec, now) {
+    return {
+      serialNo: spec.serialNo,
+      deviceId: spec.deviceId,
+      updataDateTime: now - spec.syncedMinutesAgo * 6e4,
+      deviceName: spec.name,
+      deviceVersion: spec.modelId === "actlumus_plus" ? "3.0.2" : "2.1.0",
+      hardwareVersion: spec.modelId === "actlumus_plus" ? "B" : "A",
+      deviceDateTime: now - spec.syncedMinutesAgo * 6e4,
+      memoryDataUsage: 37.5,
+      memorySystemUsage: 4.2,
+      batteryLevel: spec.battery,
+      batteryVoltage: 3.7 + spec.battery / 1e3,
+      isCharging: spec.charging,
+      isOnDock: spec.charging,
+      syncErrors: spec.syncError ? [
+        {
+          serialNo: spec.serialNo,
+          attemptDate: now - 10 * 6e4,
+          message: spec.syncError,
+          messageCode: "SYNC_FAILED"
+        }
+      ] : []
+    };
+  }
+  function userConfig(spec) {
+    return {
+      serialNo: spec.serialNo,
+      deviceId: spec.deviceId,
+      syncTime: false,
+      realTime: false,
+      deleteMemory: false,
+      readAllMemory: false,
+      readAllSystemLog: false
+    };
+  }
+  function payloadOf(specs, now = Date.now()) {
+    return {
+      lastUpdate: now,
+      devicesConfig: specs.map(config),
+      devicesTelemetry: specs.map((s) => telemetry(s, now)),
+      devicesUserConfig: specs.map(userConfig)
+    };
+  }
+  function twoDevices(now = Date.now()) {
+    return payloadOf(
+      [
+        {
+          deviceId: 9001,
+          serialNo: 4534,
+          modelId: "actlumus",
+          bodyPart: "wrist",
+          name: "ActLumus 4534",
+          battery: 82,
+          charging: false,
+          syncedMinutesAgo: 12
+        },
+        {
+          deviceId: 9002,
+          serialNo: 5120,
+          modelId: "actlumus_plus",
+          bodyPart: "necklace",
+          name: "ActLumus Plus 5120",
+          battery: 41,
+          charging: true,
+          syncedMinutesAgo: 190,
+          syncError: "Could not read the device memory."
+        }
+      ],
+      now
+    );
+  }
+  function sharedSerial(now = Date.now()) {
+    return payloadOf(
+      [
+        {
+          deviceId: 9101,
+          serialNo: 7047,
+          bodyPart: "wrist",
+          name: "ActLumus 7047",
+          battery: 67,
+          charging: false,
+          syncedMinutesAgo: 30
+        },
+        {
+          deviceId: 9102,
+          serialNo: 7047,
+          modelId: "actlumus_plus",
+          bodyPart: "necklace",
+          name: "ActLumus Plus 7047",
+          battery: 93,
+          charging: false,
+          syncedMinutesAgo: 8
+        }
+      ],
+      now
+    );
+  }
+  function systemStatus(overrides = {}) {
+    return {
+      bluetooth: true,
+      internet: true,
+      permission: true,
+      hasDevices: true,
+      missingOptionalPermissions: [],
+      missingEssentialPermissions: [],
+      deviceSyncError: {},
+      deviceSyncErrorById: {},
+      ...overrides
+    };
+  }
+  function lightAt(epochMs, serialNo) {
+    const d = new Date(epochMs);
+    const hour = d.getHours() + d.getMinutes() / 60;
+    const daylight = Math.max(0, Math.sin((hour - 6) / 12 * Math.PI));
+    const noise = (epochMs / 6e4 + serialNo) % 7 / 7;
+    const photopic = Math.round((daylight * 1800 + noise * 40) * 10) / 10;
+    return { photopic, melanopic: Math.round(photopic * 0.62 * 10) / 10 };
+  }
+  function logAt(epochMs, serialNo, deviceId) {
+    const { photopic, melanopic } = lightAt(epochMs, serialNo);
+    return {
+      id: Math.floor(epochMs / 1e3) * 10 + serialNo % 10,
+      log_time: formatLocalTimestamp(new Date(epochMs)),
+      log_type: 1,
+      body_part: "wrist",
+      temperature: 31.5,
+      lux_photopic: photopic,
+      lux_melanopic: melanopic,
+      device_id: deviceId,
+      act_data_pim: 120
+    };
+  }
+  var HISTORY_DAYS = 14;
+  var encodeCursor = (epochMs) => `mock:${epochMs}`;
+  var decodeCursor = (cursor) => Number(cursor.slice("mock:".length));
+  function sensorLogPage(query, opts = {}) {
+    const now = opts.now ?? Date.now();
+    const periodMs = (opts.periodS ?? DEFAULT_LOG_PERIOD_S) * 1e3;
+    const limit = query.limit ?? 10;
+    if (limit < 1 || limit > 1e3) {
+      return { requestId: query.requestId, success: false, error: "INVALID_LIMIT" };
+    }
+    if (query.startingAfter && query.endingBefore) {
+      return { requestId: query.requestId, success: false, error: "CONFLICTING_CURSORS" };
+    }
+    const newest = Math.floor(now / periodMs) * periodMs;
+    const oldest = newest - HISTORY_DAYS * 864e5;
+    const rangeStart = query.startTime ? parseLocalTimestamp(query.startTime) : oldest;
+    const rangeEnd = query.endTime ? parseLocalTimestamp(query.endTime) - 1 : newest;
+    if (Number.isNaN(rangeStart) || Number.isNaN(rangeEnd) || rangeStart > rangeEnd + 1) {
+      return { requestId: query.requestId, success: false, error: "INVALID_TIME_RANGE" };
+    }
+    const first = Math.max(oldest, Math.ceil(rangeStart / periodMs) * periodMs);
+    const last = Math.min(newest, Math.floor(rangeEnd / periodMs) * periodMs);
+    let from;
+    let to;
+    if (query.endingBefore) {
+      to = Math.min(last, decodeCursor(query.endingBefore) - periodMs);
+      from = Math.max(first, to - (limit - 1) * periodMs);
+    } else if (query.startingAfter) {
+      from = Math.max(first, decodeCursor(query.startingAfter) + periodMs);
+      to = Math.min(last, from + (limit - 1) * periodMs);
+    } else if (query.startTime) {
+      from = first;
+      to = Math.min(last, from + (limit - 1) * periodMs);
+    } else {
+      to = last;
+      from = Math.max(first, to - (limit - 1) * periodMs);
+    }
+    const logs = [];
+    for (let t = from; t <= to; t += periodMs) {
+      logs.push(logAt(t, query.serialNo, opts.deviceId ?? 0));
+    }
+    return {
+      requestId: query.requestId,
+      success: true,
+      logs,
+      startingAfter: logs.length ? encodeCursor(to) : null,
+      endingBefore: logs.length ? encodeCursor(from) : null,
+      hasMore: logs.length > 0 && to < last,
+      hasPrevious: logs.length > 0 && from > first
+    };
+  }
+
+  // src/keys.ts
+  var BRIDGE_KEYS = {
+    pingPong: "pingPong",
+    userDevice: "userDevice",
+    deviceLightSensors: "deviceLightSensors",
+    syncTime: "syncTime",
+    realTime: "realTime",
+    deleteMemory: "deleteMemory",
+    deviceNotification: "deviceNotification",
+    deviceConnection: "deviceConnection",
+    sensorLog: "sensorLog",
+    dfu: "dfu",
+    systemStatus: "systemStatus",
+    /**
+     * Native → client: the OS back button was pressed and the client had
+     * reported internal history via `reportNavigation(true)`. Go back exactly
+     * ONE internal page. Emitted only when the native side decided to delegate
+     * the back gesture. See `BridgeClient.onBack`.
+     */
+    navigationBack: "navigationBack",
+    /**
+     * Native → client: the app's language state. Carries the raw device locale
+     * AND the language explicitly chosen in the app Settings, so the client can
+     * apply its own precedence rule — including rendering a language the native
+     * chrome does not support. Emitted on attach, after `handshake-ack`, and on
+     * every change in Settings. See `LanguagePayload`.
+     */
+    language: "language"
+  };
+
+  // src/internal/dev-panel.ts
+  var PANEL_ID = "condor-mock-panel-root";
+  var REFRESH_INTERVAL_MS = 500;
+  var DEFAULTS = {
+    position: "bottom-right",
+    maxMessages: 20,
+    theme: "dark",
+    startCollapsed: false,
+    startAutoRespondEnabled: false,
+    autoRespondDelayMs: 50
+  };
+  function resolveOptions(opts) {
+    return {
+      position: opts?.position ?? DEFAULTS.position,
+      maxMessages: opts?.maxMessages ?? DEFAULTS.maxMessages,
+      theme: opts?.theme ?? DEFAULTS.theme,
+      startCollapsed: opts?.startCollapsed ?? DEFAULTS.startCollapsed,
+      startAutoRespondEnabled: opts?.startAutoRespondEnabled ?? DEFAULTS.startAutoRespondEnabled,
+      autoRespondDelayMs: opts?.autoRespondDelayMs ?? DEFAULTS.autoRespondDelayMs
+    };
+  }
+  function applyPanelStyles(el, opts) {
+    const isDark = opts.theme === "dark";
+    const positions = {
+      "bottom-right": { bottom: "12px", right: "12px" },
+      "bottom-left": { bottom: "12px", left: "12px" },
+      "top-right": { top: "12px", right: "12px" },
+      "top-left": { top: "12px", left: "12px" }
+    };
+    Object.assign(el.style, {
+      position: "fixed",
+      width: "340px",
+      maxHeight: "420px",
+      zIndex: "2147483647",
+      fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace",
+      fontSize: "12px",
+      color: isDark ? "#e0e0e0" : "#222",
+      background: isDark ? "#1a1a1aee" : "#ffffffee",
+      border: isDark ? "1px solid #444" : "1px solid #ccc",
+      borderRadius: "6px",
+      boxShadow: "0 4px 12px rgba(0,0,0,0.3)",
+      overflow: "hidden",
+      display: "flex",
+      flexDirection: "column",
+      ...positions[opts.position]
+    });
+  }
+  function buildHeader(badge, counter, toggle) {
+    const header = document.createElement("div");
+    header.className = "condor-mock-panel-header";
+    Object.assign(header.style, {
+      padding: "6px 10px",
+      display: "flex",
+      alignItems: "center",
+      gap: "8px",
+      background: "#0a84ff",
+      color: "#fff",
+      fontWeight: "600",
+      cursor: "pointer"
+    });
+    Object.assign(badge.style, {
+      background: "#fff",
+      color: "#0a84ff",
+      padding: "1px 6px",
+      borderRadius: "3px",
+      fontSize: "10px",
+      letterSpacing: "0.5px"
+    });
+    badge.textContent = "MOCK";
+    Object.assign(counter.style, {
+      marginLeft: "auto",
+      fontSize: "11px",
+      opacity: "0.9"
+    });
+    Object.assign(toggle.style, {
+      background: "transparent",
+      border: "1px solid rgba(255,255,255,0.5)",
+      color: "#fff",
+      cursor: "pointer",
+      padding: "0 6px",
+      borderRadius: "3px",
+      fontFamily: "inherit"
+    });
+    header.append(badge, document.createTextNode("condor-bridge"), counter, toggle);
+    return header;
+  }
+  function buildSentSection() {
+    const container = document.createElement("div");
+    container.className = "condor-mock-panel-sent";
+    Object.assign(container.style, {
+      padding: "6px 10px",
+      borderBottom: "1px solid rgba(255,255,255,0.08)",
+      maxHeight: "180px",
+      overflowY: "auto"
+    });
+    const title = document.createElement("div");
+    title.textContent = "Sent";
+    Object.assign(title.style, { opacity: "0.7", marginBottom: "4px", fontSize: "11px" });
+    const list = document.createElement("div");
+    list.className = "condor-mock-panel-sent-list";
+    container.append(title, list);
+    return { container, list };
+  }
+  function buildTriggerSection(bridgeKeys, onEmit, onClear) {
+    const container = document.createElement("div");
+    container.className = "condor-mock-panel-trigger";
+    Object.assign(container.style, {
+      padding: "6px 10px",
+      display: "flex",
+      flexDirection: "column",
+      gap: "4px"
+    });
+    const title = document.createElement("div");
+    title.textContent = "Trigger emit";
+    Object.assign(title.style, { opacity: "0.7", fontSize: "11px" });
+    const select = document.createElement("select");
+    select.className = "condor-mock-panel-key-select";
+    Object.assign(select.style, {
+      background: "transparent",
+      color: "inherit",
+      border: "1px solid rgba(255,255,255,0.2)",
+      padding: "4px",
+      borderRadius: "3px",
+      fontFamily: "inherit",
+      fontSize: "11px"
+    });
+    for (const key of bridgeKeys) {
+      const opt = document.createElement("option");
+      opt.value = key;
+      opt.textContent = key;
+      select.appendChild(opt);
+    }
+    const ackOpt = document.createElement("option");
+    ackOpt.value = "handshake-ack";
+    ackOpt.textContent = "handshake-ack";
+    select.appendChild(ackOpt);
+    const textarea = document.createElement("textarea");
+    textarea.className = "condor-mock-panel-payload";
+    textarea.placeholder = '{ "data": "pong" }';
+    Object.assign(textarea.style, {
+      background: "transparent",
+      color: "inherit",
+      border: "1px solid rgba(255,255,255,0.2)",
+      padding: "4px",
+      borderRadius: "3px",
+      fontFamily: "inherit",
+      fontSize: "11px",
+      minHeight: "50px",
+      resize: "vertical"
+    });
+    const buttons = document.createElement("div");
+    Object.assign(buttons.style, { display: "flex", gap: "6px" });
+    const emitBtn = document.createElement("button");
+    emitBtn.type = "button";
+    emitBtn.textContent = "Emit";
+    emitBtn.className = "condor-mock-panel-emit-btn";
+    Object.assign(emitBtn.style, {
+      background: "#0a84ff",
+      color: "#fff",
+      border: "none",
+      padding: "4px 10px",
+      borderRadius: "3px",
+      cursor: "pointer",
+      fontFamily: "inherit",
+      fontSize: "11px",
+      flex: "1"
+    });
+    emitBtn.addEventListener("click", () => {
+      onEmit(select.value, textarea.value);
+    });
+    const clearBtn = document.createElement("button");
+    clearBtn.type = "button";
+    clearBtn.textContent = "Clear sent";
+    clearBtn.className = "condor-mock-panel-clear-btn";
+    Object.assign(clearBtn.style, {
+      background: "transparent",
+      color: "inherit",
+      border: "1px solid rgba(255,255,255,0.3)",
+      padding: "4px 10px",
+      borderRadius: "3px",
+      cursor: "pointer",
+      fontFamily: "inherit",
+      fontSize: "11px"
+    });
+    clearBtn.addEventListener("click", onClear);
+    buttons.append(emitBtn, clearBtn);
+    container.append(title, select, textarea, buttons);
+    return container;
+  }
+  function buildAutoRespondSection(initialEnabled, onChange) {
+    const container = document.createElement("div");
+    container.className = "condor-mock-panel-auto-respond";
+    Object.assign(container.style, {
+      padding: "6px 10px",
+      borderBottom: "1px solid rgba(255,255,255,0.08)",
+      display: "flex",
+      flexDirection: "column",
+      gap: "2px"
+    });
+    const title = document.createElement("div");
+    title.textContent = "Auto-respond";
+    Object.assign(title.style, { opacity: "0.7", fontSize: "11px" });
+    const row = document.createElement("label");
+    Object.assign(row.style, {
+      display: "flex",
+      alignItems: "center",
+      gap: "8px",
+      cursor: "pointer",
+      fontSize: "12px"
+    });
+    const checkbox = document.createElement("input");
+    checkbox.type = "checkbox";
+    checkbox.className = "condor-mock-panel-auto-respond-toggle";
+    checkbox.checked = initialEnabled;
+    Object.assign(checkbox.style, {
+      cursor: "pointer"
+    });
+    const label = document.createElement("span");
+    label.textContent = "Enabled \u2014 mockEmit em resposta a cada send (policy do cliente)";
+    checkbox.addEventListener("change", () => {
+      onChange(checkbox.checked);
+    });
+    row.append(checkbox, label);
+    container.append(title, row);
+    return container;
+  }
+  function renderSentList(list, adapter, max) {
+    list.innerHTML = "";
+    const all = adapter.getMessages();
+    const tail = all.slice(-max).reverse();
+    for (const msg of tail) {
+      const row = document.createElement("div");
+      Object.assign(row.style, {
+        padding: "3px 0",
+        borderBottom: "1px solid rgba(255,255,255,0.06)",
+        wordBreak: "break-all"
+      });
+      const ts = new Date(msg.timestamp).toLocaleTimeString();
+      const payload = msg.payload;
+      const type = payload?.type ?? "?";
+      row.textContent = `${ts}  \u2192  ${type}  ${JSON.stringify(msg.payload).slice(0, 80)}`;
+      list.appendChild(row);
+    }
+  }
+  var currentPanel = null;
+  function installDevPanel(params) {
+    if (typeof document === "undefined") {
+      throw new Error("condor-mobile-bridge dev panel: document is undefined (Node-only env).");
+    }
+    if (currentPanel) {
+      currentPanel.uninstall();
+      currentPanel = null;
+    }
+    const opts = resolveOptions(params.options);
+    const root = document.createElement("div");
+    root.id = PANEL_ID;
+    applyPanelStyles(root, opts);
+    const badge = document.createElement("span");
+    const counter = document.createElement("span");
+    const toggle = document.createElement("button");
+    toggle.type = "button";
+    toggle.textContent = opts.startCollapsed ? "+" : "\u2212";
+    const header = buildHeader(badge, counter, toggle);
+    const body = document.createElement("div");
+    Object.assign(body.style, {
+      display: opts.startCollapsed ? "none" : "flex",
+      flexDirection: "column",
+      overflow: "hidden"
+    });
+    const { container: sentContainer, list: sentList } = buildSentSection();
+    const policy = params.options?.onSendForAutoRespond;
+    let autoRespondEnabled = opts.startAutoRespondEnabled;
+    let unsubscribeSendListener = null;
+    let autoRespondSection = null;
+    if (policy) {
+      autoRespondSection = buildAutoRespondSection(autoRespondEnabled, (next) => {
+        autoRespondEnabled = next;
+      });
+      unsubscribeSendListener = params.adapter.onCallHandler((msg) => {
+        if (!autoRespondEnabled) return;
+        let response;
+        try {
+          response = policy(msg);
+        } catch (err) {
+          console.error("[condor-mobile-bridge dev-panel] onSendForAutoRespond threw:", err);
+          return;
+        }
+        if (!response) return;
+        setTimeout(() => {
+          try {
+            params.adapter.triggerEmit(response.key, response.payload);
+          } catch (err) {
+            console.error(
+              "[condor-mobile-bridge dev-panel] triggerEmit failed in auto-respond:",
+              err
+            );
+          }
+        }, opts.autoRespondDelayMs);
+      });
+    }
+    const trigger = buildTriggerSection(
+      Object.values(BRIDGE_KEYS),
+      (key, payloadJson) => {
+        let payload = {};
+        const trimmed = payloadJson.trim();
+        if (trimmed.length > 0) {
+          try {
+            payload = JSON.parse(trimmed);
+          } catch (err) {
+            console.error("[condor-mobile-bridge dev-panel] invalid JSON payload", err);
+            return;
+          }
+        }
+        params.adapter.triggerEmit(key, payload);
+      },
+      () => {
+        params.adapter.clearMessages();
+        renderSentList(sentList, params.adapter, opts.maxMessages);
+        counter.textContent = "0 sent";
+      }
+    );
+    if (autoRespondSection) {
+      body.append(sentContainer, autoRespondSection, trigger);
+    } else {
+      body.append(sentContainer, trigger);
+    }
+    root.append(header, body);
+    toggle.addEventListener("click", (e) => {
+      e.stopPropagation();
+      const collapsed = body.style.display === "none";
+      body.style.display = collapsed ? "flex" : "none";
+      toggle.textContent = collapsed ? "\u2212" : "+";
+    });
+    document.body.appendChild(root);
+    const refresh = () => {
+      const count = params.adapter.getMessages().length;
+      counter.textContent = `${count} sent`;
+      renderSentList(sentList, params.adapter, opts.maxMessages);
+    };
+    refresh();
+    const interval = setInterval(refresh, REFRESH_INTERVAL_MS);
+    const panel = {
+      uninstall() {
+        clearInterval(interval);
+        unsubscribeSendListener?.();
+        unsubscribeSendListener = null;
+        root.remove();
+        if (currentPanel === panel) currentPanel = null;
+      },
+      refresh
+    };
+    currentPanel = panel;
+    return panel;
+  }
+
+  // src/internal/mock.ts
+  var MAX_BUFFER = 100;
+  function createMockAdapter() {
+    const messages = [];
+    const sendListeners = /* @__PURE__ */ new Set();
+    return {
+      isMock: true,
+      callHandler(handlerName, payload) {
+        const msg = { handlerName, payload, timestamp: Date.now() };
+        messages.push(msg);
+        if (messages.length > MAX_BUFFER) {
+          messages.shift();
+        }
+        console.debug("[condor-mobile-bridge mock] \u2192", handlerName, payload);
+        for (const listener of sendListeners) {
+          try {
+            listener(msg);
+          } catch (err) {
+            console.error("[condor-mobile-bridge mock] send listener threw:", err);
+          }
+        }
+      },
+      getMessages() {
+        return messages;
+      },
+      clearMessages() {
+        messages.length = 0;
+      },
+      triggerEmit(key, payload) {
+        const bridge = typeof window !== "undefined" ? window.CondorBridge : void 0;
+        if (!bridge || typeof bridge.emit !== "function") {
+          throw new Error(
+            "condor-mobile-bridge mock: window.CondorBridge not bootstrapped; cannot emit."
+          );
+        }
+        bridge.emit(key, payload);
+      },
+      onCallHandler(listener) {
+        sendListeners.add(listener);
+        return () => {
+          sendListeners.delete(listener);
+        };
+      }
+    };
+  }
+
+  // src/internal/native.ts
+  var outgoingStamp = null;
+  function setOutgoingStamp(stamp) {
+    outgoingStamp = stamp;
+  }
+  var activeAdapter = null;
+  function createChannelAdapter(channel) {
+    return {
+      isMock: false,
+      // Single channel: `handlerName` does not travel — the native side routes
+      // on `type`.
+      callHandler(_handlerName, payload) {
+        channel.postMessage(JSON.stringify(payload));
+      }
+    };
+  }
+  function createLegacyAdapter(host) {
+    return {
+      isMock: false,
+      callHandler(handlerName, payload) {
+        void host.callHandler(handlerName, payload);
+      }
+    };
+  }
+  function detectAdapter() {
+    if (typeof window === "undefined") {
+      return createMockAdapter();
+    }
+    const channel = window.CondorNative;
+    if (channel && typeof channel.postMessage === "function") {
+      return createChannelAdapter(channel);
+    }
+    const host = window.flutter_inappwebview;
+    if (host && typeof host.callHandler === "function") {
+      return createLegacyAdapter(host);
+    }
+    return createMockAdapter();
+  }
+  function getActiveAdapter() {
+    if (!activeAdapter) {
+      activeAdapter = detectAdapter();
+    }
+    return activeAdapter;
+  }
+  function callNative(handlerName, payload) {
+    const stamped = outgoingStamp ? outgoingStamp(payload) : payload;
+    getActiveAdapter().callHandler(handlerName, stamped);
+  }
+
+  // src/internal/subscribers.ts
+  var subscribers = /* @__PURE__ */ new Map();
+  function addSubscriber(key, cb) {
+    let set = subscribers.get(key);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      subscribers.set(key, set);
+    }
+    set.add(cb);
+    return () => {
+      const current = subscribers.get(key);
+      if (!current) return;
+      current.delete(cb);
+      if (current.size === 0) {
+        subscribers.delete(key);
+      }
+    };
+  }
+  function dispatchToSubscribers(key, payload) {
+    const set = subscribers.get(key);
+    if (!set) return;
+    for (const cb of set) {
+      try {
+        cb(payload);
+      } catch (err) {
+        console.error(`[condor-mobile-bridge] subscriber for "${key}" threw:`, err);
+      }
+    }
+  }
+  function getSubscriberKeys() {
+    return Array.from(subscribers.keys());
+  }
+
+  // src/bridge.ts
+  var HANDSHAKE_ACK_KEY = "handshake-ack";
+  var NATIVE_HANDLER = "CondorBridge";
+  var PROTOCOL_VERSION = "0.1.0";
+  var pendingHandshake = null;
+  var bridgeBootstrapped = false;
+  function emit(key, payload) {
+    if (key === HANDSHAKE_ACK_KEY && pendingHandshake) {
+      const ack = payload ?? {};
+      const resolver = pendingHandshake;
+      pendingHandshake = null;
+      resolver.resolve({
+        nativeVersion: ack.nativeVersion ?? "unknown",
+        accepted: ack.accepted ?? false
+      });
+      return;
+    }
+    dispatchToSubscribers(key, payload);
+  }
+  function bootstrapWindowBridge() {
+    if (bridgeBootstrapped) return;
+    if (typeof window === "undefined") return;
+    bridgeBootstrapped = true;
+    if (window.CondorBridge && typeof window.CondorBridge.emit === "function") {
+      window.CondorBridge.emit = emit;
+    } else {
+      window.CondorBridge = { emit };
+    }
+  }
+  bootstrapWindowBridge();
+  function requireMockAdapter() {
+    const adapter = getActiveAdapter();
+    if (!adapter.isMock) {
+      throw new Error(
+        "condor-mobile-bridge: this API is available only in mock mode (no native host detected)."
+      );
+    }
+    return adapter;
+  }
+  var Bridge = {
+    get isMock() {
+      return getActiveAdapter().isMock;
+    },
+    handshake(opts) {
+      bootstrapWindowBridge();
+      if (pendingHandshake) {
+        return Promise.reject(
+          new Error(
+            "condor-mobile-bridge: handshake already in flight. Await the previous call before issuing another."
+          )
+        );
+      }
+      return new Promise((resolve, reject) => {
+        pendingHandshake = { resolve, reject };
+        try {
+          callNative(NATIVE_HANDLER, {
+            type: "handshake",
+            version: PROTOCOL_VERSION,
+            payload: { clientVersion: opts.clientVersion }
+          });
+        } catch (err) {
+          pendingHandshake = null;
+          reject(err instanceof Error ? err : new Error(String(err)));
+        }
+      });
+    },
+    on(key, cb) {
+      bootstrapWindowBridge();
+      return addSubscriber(key, cb);
+    },
+    send(type, payload) {
+      callNative(NATIVE_HANDLER, {
+        type,
+        version: PROTOCOL_VERSION,
+        payload: payload ?? {}
+      });
+    },
+    openSettings() {
+      this.send("openSettings");
+    },
+    setOutgoingStamp(stamp) {
+      setOutgoingStamp(stamp);
+    },
+    mockEmit(key, payload) {
+      requireMockAdapter().triggerEmit(key, payload ?? {});
+    },
+    getMockState() {
+      const adapter = requireMockAdapter();
+      return {
+        isMock: true,
+        messages: adapter.getMessages(),
+        subscriberKeys: getSubscriberKeys()
+      };
+    },
+    installDevPanel(options) {
+      const adapter = requireMockAdapter();
+      installDevPanel({ adapter, options });
+    }
+  };
+
+  // node_modules/valibot/dist/index.mjs
+  var store$4;
+  var DEFAULT_CONFIG = {
+    lang: void 0,
+    message: void 0,
+    abortEarly: void 0,
+    abortPipeEarly: void 0
+  };
+  // @__NO_SIDE_EFFECTS__
+  function getGlobalConfig(config$1) {
+    if (!config$1 && !store$4) return DEFAULT_CONFIG;
+    return {
+      lang: config$1?.lang ?? store$4?.lang,
+      message: config$1?.message,
+      abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
+      abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
+    };
+  }
+  var store$3;
+  // @__NO_SIDE_EFFECTS__
+  function getGlobalMessage(lang) {
+    return store$3?.get(lang);
+  }
+  var store$2;
+  // @__NO_SIDE_EFFECTS__
+  function getSchemaMessage(lang) {
+    return store$2?.get(lang);
+  }
+  var store$1;
+  // @__NO_SIDE_EFFECTS__
+  function getSpecificMessage(reference, lang) {
+    return store$1?.get(reference)?.get(lang);
+  }
+  // @__NO_SIDE_EFFECTS__
+  function _stringify(input) {
+    const type = typeof input;
+    if (type === "string") return `"${input}"`;
+    if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
+    if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+    return type;
+  }
+  function _addIssue(context, label, dataset, config$1, other) {
+    const input = other && "input" in other ? other.input : dataset.value;
+    const expected = other?.expected ?? context.expects ?? null;
+    const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+    const issue = {
+      kind: context.kind,
+      type: context.type,
+      input,
+      expected,
+      received,
+      message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+      requirement: context.requirement,
+      path: other?.path,
+      issues: other?.issues,
+      lang: config$1.lang,
+      abortEarly: config$1.abortEarly,
+      abortPipeEarly: config$1.abortPipeEarly
+    };
+    const isSchema = context.kind === "schema";
+    const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+    if (message$1 !== void 0) issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
+    if (isSchema) dataset.typed = false;
+    if (dataset.issues) dataset.issues.push(issue);
+    else dataset.issues = [issue];
+  }
+  var _standardCache = /* @__PURE__ */ new WeakMap();
+  // @__NO_SIDE_EFFECTS__
+  function _getStandardProps(context) {
+    let cached = _standardCache.get(context);
+    if (!cached) {
+      cached = {
+        version: 1,
+        vendor: "valibot",
+        validate(value$1) {
+          return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
+        }
+      };
+      _standardCache.set(context, cached);
+    }
+    return cached;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function _isValidObjectKey(object$1, key) {
+    return Object.prototype.hasOwnProperty.call(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+  }
+  // @__NO_SIDE_EFFECTS__
+  function _joinExpects(values$1, separator) {
+    const list = [...new Set(values$1)];
+    if (list.length > 1) return `(${list.join(` ${separator} `)})`;
+    return list[0] ?? "never";
+  }
+  var ABORT_EARLY_CONFIG = { abortEarly: true };
+  // @__NO_SIDE_EFFECTS__
+  function getFallback(schema, dataset, config$1) {
+    return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function getDefault(schema, dataset, config$1) {
+    return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function boolean(message$1) {
+    return {
+      kind: "schema",
+      type: "boolean",
+      reference: boolean,
+      expects: "boolean",
+      async: false,
+      message: message$1,
+      get "~standard"() {
+        return /* @__PURE__ */ _getStandardProps(this);
+      },
+      "~run"(dataset, config$1) {
+        if (typeof dataset.value === "boolean") dataset.typed = true;
+        else _addIssue(this, "type", dataset, config$1);
+        return dataset;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function literal(literal_, message$1) {
+    return {
+      kind: "schema",
+      type: "literal",
+      reference: literal,
+      expects: /* @__PURE__ */ _stringify(literal_),
+      async: false,
+      literal: literal_,
+      message: message$1,
+      get "~standard"() {
+        return /* @__PURE__ */ _getStandardProps(this);
+      },
+      "~run"(dataset, config$1) {
+        if (dataset.value === this.literal) dataset.typed = true;
+        else _addIssue(this, "type", dataset, config$1);
+        return dataset;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function nullable(wrapped, default_) {
+    return {
+      kind: "schema",
+      type: "nullable",
+      reference: nullable,
+      expects: `(${wrapped.expects} | null)`,
+      async: false,
+      wrapped,
+      default: default_,
+      get "~standard"() {
+        return /* @__PURE__ */ _getStandardProps(this);
+      },
+      "~run"(dataset, config$1) {
+        if (dataset.value === null) {
+          if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+          if (dataset.value === null) {
+            dataset.typed = true;
+            return dataset;
+          }
+        }
+        return this.wrapped["~run"](dataset, config$1);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function number(message$1) {
+    return {
+      kind: "schema",
+      type: "number",
+      reference: number,
+      expects: "number",
+      async: false,
+      message: message$1,
+      get "~standard"() {
+        return /* @__PURE__ */ _getStandardProps(this);
+      },
+      "~run"(dataset, config$1) {
+        if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
+        else _addIssue(this, "type", dataset, config$1);
+        return dataset;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function object(entries$1, message$1) {
+    return {
+      kind: "schema",
+      type: "object",
+      reference: object,
+      expects: "Object",
+      async: false,
+      entries: entries$1,
+      message: message$1,
+      get "~standard"() {
+        return /* @__PURE__ */ _getStandardProps(this);
+      },
+      "~run"(dataset, config$1) {
+        const input = dataset.value;
+        if (input && typeof input === "object") {
+          dataset.typed = true;
+          dataset.value = {};
+          for (const key in this.entries) {
+            const valueSchema = this.entries[key];
+            if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+              const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+              const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+              if (valueDataset.issues) {
+                const pathItem = {
+                  type: "object",
+                  origin: "value",
+                  input,
+                  key,
+                  value: value$1
+                };
+                for (const issue of valueDataset.issues) {
+                  if (issue.path) issue.path.unshift(pathItem);
+                  else issue.path = [pathItem];
+                  dataset.issues?.push(issue);
+                }
+                if (!dataset.issues) dataset.issues = valueDataset.issues;
+                if (config$1.abortEarly) {
+                  dataset.typed = false;
+                  break;
+                }
+              }
+              if (!valueDataset.typed) dataset.typed = false;
+              dataset.value[key] = valueDataset.value;
+            } else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+            else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+              _addIssue(this, "key", dataset, config$1, {
+                input: void 0,
+                expected: `"${key}"`,
+                path: [{
+                  type: "object",
+                  origin: "key",
+                  input,
+                  key,
+                  value: input[key]
+                }]
+              });
+              if (config$1.abortEarly) break;
+            }
+          }
+        } else _addIssue(this, "type", dataset, config$1);
+        return dataset;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function optional(wrapped, default_) {
+    return {
+      kind: "schema",
+      type: "optional",
+      reference: optional,
+      expects: `(${wrapped.expects} | undefined)`,
+      async: false,
+      wrapped,
+      default: default_,
+      get "~standard"() {
+        return /* @__PURE__ */ _getStandardProps(this);
+      },
+      "~run"(dataset, config$1) {
+        if (dataset.value === void 0) {
+          if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+          if (dataset.value === void 0) {
+            dataset.typed = true;
+            return dataset;
+          }
+        }
+        return this.wrapped["~run"](dataset, config$1);
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function picklist(options, message$1) {
+    return {
+      kind: "schema",
+      type: "picklist",
+      reference: picklist,
+      expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
+      async: false,
+      options,
+      message: message$1,
+      get "~standard"() {
+        return /* @__PURE__ */ _getStandardProps(this);
+      },
+      "~run"(dataset, config$1) {
+        if (this.options.includes(dataset.value)) dataset.typed = true;
+        else _addIssue(this, "type", dataset, config$1);
+        return dataset;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function record(key, value$1, message$1) {
+    return {
+      kind: "schema",
+      type: "record",
+      reference: record,
+      expects: "Object",
+      async: false,
+      key,
+      value: value$1,
+      message: message$1,
+      get "~standard"() {
+        return /* @__PURE__ */ _getStandardProps(this);
+      },
+      "~run"(dataset, config$1) {
+        const input = dataset.value;
+        if (input && typeof input === "object") {
+          dataset.typed = true;
+          dataset.value = {};
+          for (const entryKey in input) if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
+            const entryValue = input[entryKey];
+            const keyDataset = this.key["~run"]({ value: entryKey }, config$1);
+            if (keyDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "key",
+                input,
+                key: entryKey,
+                value: entryValue
+              };
+              for (const issue of keyDataset.issues) {
+                issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) dataset.issues = keyDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            const valueDataset = this.value["~run"]({ value: entryValue }, config$1);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key: entryKey,
+                value: entryValue
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) issue.path.unshift(pathItem);
+                else issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) dataset.issues = valueDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!keyDataset.typed || !valueDataset.typed) dataset.typed = false;
+            if (keyDataset.typed) dataset.value[keyDataset.value] = valueDataset.value;
+          }
+        } else _addIssue(this, "type", dataset, config$1);
+        return dataset;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function string(message$1) {
+    return {
+      kind: "schema",
+      type: "string",
+      reference: string,
+      expects: "string",
+      async: false,
+      message: message$1,
+      get "~standard"() {
+        return /* @__PURE__ */ _getStandardProps(this);
+      },
+      "~run"(dataset, config$1) {
+        if (typeof dataset.value === "string") dataset.typed = true;
+        else _addIssue(this, "type", dataset, config$1);
+        return dataset;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function unknown() {
+    return {
+      kind: "schema",
+      type: "unknown",
+      reference: unknown,
+      expects: "unknown",
+      async: false,
+      get "~standard"() {
+        return /* @__PURE__ */ _getStandardProps(this);
+      },
+      "~run"(dataset) {
+        dataset.typed = true;
+        return dataset;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function variant(key, options, message$1) {
+    return {
+      kind: "schema",
+      type: "variant",
+      reference: variant,
+      expects: "Object",
+      async: false,
+      key,
+      options,
+      message: message$1,
+      get "~standard"() {
+        return /* @__PURE__ */ _getStandardProps(this);
+      },
+      "~run"(dataset, config$1) {
+        const input = dataset.value;
+        if (input && typeof input === "object") {
+          let outputDataset;
+          let maxDiscriminatorPriority = 0;
+          let invalidDiscriminatorKey = this.key;
+          let expectedDiscriminators = [];
+          const parseOptions = (variant$1, allKeys) => {
+            for (const schema of variant$1.options) {
+              if (schema.type === "variant") parseOptions(schema, new Set(allKeys).add(schema.key));
+              else {
+                let keysAreValid = true;
+                let currentPriority = 0;
+                for (const currentKey of allKeys) {
+                  const discriminatorSchema = schema.entries[currentKey];
+                  if (currentKey in input ? discriminatorSchema["~run"]({
+                    typed: false,
+                    value: input[currentKey]
+                  }, ABORT_EARLY_CONFIG).issues : discriminatorSchema.type !== "exact_optional" && discriminatorSchema.type !== "optional" && discriminatorSchema.type !== "nullish") {
+                    keysAreValid = false;
+                    if (invalidDiscriminatorKey !== currentKey && (maxDiscriminatorPriority < currentPriority || maxDiscriminatorPriority === currentPriority && currentKey in input && !(invalidDiscriminatorKey in input))) {
+                      maxDiscriminatorPriority = currentPriority;
+                      invalidDiscriminatorKey = currentKey;
+                      expectedDiscriminators = [];
+                    }
+                    if (invalidDiscriminatorKey === currentKey) expectedDiscriminators.push(schema.entries[currentKey].expects);
+                    break;
+                  }
+                  currentPriority++;
+                }
+                if (keysAreValid) {
+                  const optionDataset = schema["~run"]({ value: input }, config$1);
+                  if (!outputDataset || !outputDataset.typed && optionDataset.typed) outputDataset = optionDataset;
+                }
+              }
+              if (outputDataset && !outputDataset.issues) break;
+            }
+          };
+          parseOptions(this, /* @__PURE__ */ new Set([this.key]));
+          if (outputDataset) return outputDataset;
+          _addIssue(this, "type", dataset, config$1, {
+            input: input[invalidDiscriminatorKey],
+            expected: /* @__PURE__ */ _joinExpects(expectedDiscriminators, "|"),
+            path: [{
+              type: "object",
+              origin: "value",
+              input,
+              key: invalidDiscriminatorKey,
+              value: input[invalidDiscriminatorKey]
+            }]
+          });
+        } else _addIssue(this, "type", dataset, config$1);
+        return dataset;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function safeParse(schema, input, config$1) {
+    const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+    return {
+      typed: dataset.typed,
+      success: !dataset.issues,
+      output: dataset.value,
+      issues: dataset.issues
+    };
+  }
+
+  // src/shell-messages.ts
+  var BridgeKeySchema = picklist(Object.values(BRIDGE_KEYS));
+  var SubscribeMessage = object({
+    type: literal("subscribe"),
+    key: BridgeKeySchema
+  });
+  var UnsubscribeMessage = object({
+    type: literal("unsubscribe"),
+    key: BridgeKeySchema
+  });
+  var SendMessage = object({
+    type: literal("send"),
+    command: string(),
+    args: optional(record(string(), unknown()), {})
+  });
+  var HandshakeMessage = object({
+    type: literal("handshake"),
+    payload: object({ clientVersion: string() })
+  });
+  var JsErrorMessage = object({
+    type: literal("jsError"),
+    payload: object({
+      message: string(),
+      stack: optional(string()),
+      source: optional(string()),
+      lineno: optional(number()),
+      colno: optional(number())
+    })
+  });
+  var SandboxVerifyResponseMessage = object({
+    type: literal("sandbox-verify-response"),
+    flutterBridgeReachable: boolean(),
+    condorBridgeReachable: boolean(),
+    // Optional: clients on SDK < 0.18.0 do not send it.
+    nativeChannelReachable: optional(boolean())
+  });
+  var ClientToShellMessageSchema = variant("type", [
+    SubscribeMessage,
+    UnsubscribeMessage,
+    SendMessage,
+    HandshakeMessage,
+    JsErrorMessage,
+    SandboxVerifyResponseMessage
+  ]);
+  var EventMessage = object({
+    type: literal("event"),
+    key: BridgeKeySchema,
+    payload: unknown()
+  });
+  var HandshakeAckMessage = object({
+    type: literal("handshake-ack"),
+    ack: object({
+      shellVersion: string(),
+      /**
+       * Schema version declared by the **native** side, relayed by the shell.
+       *
+       * `null` when the native side has not answered, or does not exist (browser
+       * mock mode). The client runs inside a sandboxed iframe and never talks to
+       * the native side directly, so this is the **only** way it can learn which
+       * capabilities are available.
+       */
+      nativeVersion: nullable(string()),
+      accepted: boolean()
+    })
+  });
+  var NackMessage = object({
+    type: literal("nack"),
+    key: optional(string()),
+    command: optional(string()),
+    reason: string()
+  });
+  var VerifySandboxMessage = object({
+    type: literal("verify-sandbox")
+  });
+  var ShellToClientMessageSchema = variant("type", [
+    EventMessage,
+    HandshakeAckMessage,
+    NackMessage,
+    VerifySandboxMessage
+  ]);
+
+  // src/bridge-shell.ts
+  var SHELL_VERSION = "0.6.0";
+  var NATIVE_HANDSHAKE_TIMEOUT_MS = 2e3;
+  var VERIFY_TIMEOUT_MS = 2e3;
+  var OVERRIDE_PREFIX = `<script>
+(function(){
+  try { delete window.flutter_inappwebview; } catch (_) {}
+  try { delete window.CondorBridge; } catch (_) {}
+  try { delete window.CondorNative; } catch (_) {}
+  try {
+    Object.defineProperty(window, 'flutter_inappwebview', {
+      get: function(){ return undefined; },
+      set: function(_){ /* no-op: blocks the plugin injecting into the iframe */ },
+      configurable: false,
+    });
+  } catch (_) {}
+  try {
+    Object.defineProperty(window, 'CondorNative', {
+      get: function(){ return undefined; },
+      set: function(_){ /* no-op: bloqueia o canal do webview_flutter no iframe */ },
+      configurable: false,
+    });
+  } catch (_) {}
+  try {
+    Object.defineProperty(window, 'CondorBridge', {
+      get: function(){ return undefined; },
+      set: function(_){ /* no-op: bloqueia bootstrap do package legado */ },
+      configurable: false,
+    });
+  } catch (_) {}
+  try {
+    // Neutralize navigator.sendBeacon: an exfiltration channel that CSP
+    // connect-src does not reliably block in some WebViews (pen test PT-10).
+    // The client communicates only through BridgeClient/postMessage, so it has
+    // no legitimate use for sendBeacon. The no-op getter returns a function
+    // that answers false; the no-op setter ignores attempts to restore it.
+    Object.defineProperty(navigator, 'sendBeacon', {
+      get: function(){ return function(){ return false; }; },
+      set: function(_){ /* no-op */ },
+      configurable: false,
+    });
+  } catch (_) {}
+})();
+</script>`;
+  var BridgeShell = class {
+    constructor(opts) {
+      this.subscriptions = /* @__PURE__ */ new Map();
+      this.detached = false;
+      /**
+       * The native version, fetched once and cached. `null` until the native side
+       * answers, and permanently `null` in a browser with no native host.
+       */
+      this.nativeVersion = null;
+      /** In-flight native handshake; guarantees a single call. */
+      this.nativeHandshake = null;
+      // Pending `verify-sandbox` round trips, keyed by a generated nonce.
+      this.pendingVerifies = /* @__PURE__ */ new Map();
+      this.onMessage = async (event) => {
+        if (this.detached) return;
+        if (event.source !== this.iframe.contentWindow) return;
+        const parsed = safeParse(ClientToShellMessageSchema, event.data);
+        if (!parsed.success) {
+          if (typeof console !== "undefined") {
+            console.debug("[BridgeShell] dropped malformed message:", parsed.issues?.[0]?.message);
+          }
+          return;
+        }
+        const msg = parsed.output;
+        switch (msg.type) {
+          case "subscribe":
+            await this.handleSubscribe(msg.key);
+            break;
+          case "unsubscribe":
+            this.handleUnsubscribe(msg.key);
+            break;
+          case "send":
+            await this.handleSend(msg.command, msg.args ?? {});
+            break;
+          case "handshake":
+            void this.resolveNativeVersion().then((nativeVersion) => {
+              this.postToClient({
+                type: "handshake-ack",
+                ack: { shellVersion: SHELL_VERSION, nativeVersion, accepted: true }
+              });
+            });
+            break;
+          case "jsError":
+            Bridge.send("jsError", {
+              origin: "iframe",
+              message: msg.payload.message,
+              stack: msg.payload.stack,
+              source: msg.payload.source,
+              lineno: msg.payload.lineno,
+              colno: msg.payload.colno
+            });
+            break;
+          case "sandbox-verify-response": {
+            const first = this.pendingVerifies.keys().next().value;
+            if (first !== void 0) {
+              const pending = this.pendingVerifies.get(first);
+              if (pending) {
+                clearTimeout(pending.timer);
+                this.pendingVerifies.delete(first);
+                const nativeChannelReachable = msg.nativeChannelReachable ?? false;
+                const ok = !msg.flutterBridgeReachable && !msg.condorBridgeReachable && !nativeChannelReachable;
+                pending.resolve({
+                  flutterBridgeReachable: msg.flutterBridgeReachable,
+                  condorBridgeReachable: msg.condorBridgeReachable,
+                  nativeChannelReachable,
+                  ok
+                });
+              }
+            }
+            break;
+          }
+        }
+      };
+      this.iframe = opts.iframe;
+      this.policy = opts.policy;
+      this.onConfirm = opts.onConfirmationRequest;
+      if (typeof window !== "undefined") {
+        window.addEventListener("message", this.onMessage);
+      }
+    }
+    /**
+     * **Layer 1.** Bootstraps by fetching a URL.
+     *
+     * A shortcut for the common HTTP/HTTPS case: it runs `fetch(clientPath)` and
+     * delegates to `bootstrapClientIframeWithHtml`.
+     *
+     * **It does not work on the `file://` scheme** — Android's Chromium WebView
+     * blocks it with "URL scheme 'file' is not supported". For an asset bundled
+     * in the APK, or a bundle inlined at build time, use
+     * `bootstrapClientIframeWithHtml(htmlString)` instead.
+     *
+     * **Call it once at shell boot**, before any other interaction. After it
+     * returns, invoke `verifySandbox()` for attestation (Layer 2).
+     */
+    async bootstrapClientIframe(clientPath = "client.html") {
+      const res = await fetch(clientPath);
+      if (!res.ok) throw new Error(`BridgeShell: failed to load ${clientPath} (${res.status})`);
+      const clientHtml = await res.text();
+      await this.bootstrapClientIframeWithHtml(clientHtml);
+    }
+    /**
+     * **Layer 1.** Bootstraps from an HTML string.
+     *
+     * Takes the client HTML directly — already read from a file, embedded at
+     * build time, read from storage — and sets it as the iframe's `srcdoc`,
+     * prefixed by the override script, which runs at parse time before any
+     * client script.
+     *
+     * Use this when `fetch` does not apply: an asset bundled under `file://`, a
+     * bundle inlined at build time, any scenario without network. Android
+     * WebView blocks `fetch` on the `file://` scheme, so this is the path the
+     * app actually takes. For HTTP, use `bootstrapClientIframe(clientPath)`.
+     *
+     * **Call it once at shell boot**, before any other interaction. After it
+     * returns, invoke `verifySandbox()` for attestation (Layer 2).
+     */
+    async bootstrapClientIframeWithHtml(clientHtml) {
+      this.iframe.srcdoc = OVERRIDE_PREFIX + clientHtml;
+      await this.waitForIframeLoad();
+    }
+    waitForIframeLoad() {
+      return new Promise((resolve) => {
+        const onLoad = () => {
+          this.iframe.removeEventListener("load", onLoad);
+          resolve();
+        };
+        this.iframe.addEventListener("load", onLoad);
+      });
+    }
+    /**
+     * **Layer 2.** A `postMessage` round trip asking the iframe for an
+     * authoritative attestation of whether the native globals are reachable.
+     * Times out after 2 s.
+     *
+     * `ok` is `true` only when none of them is reachable. If it comes back
+     * `false`, **the shell must abort the app boot**: Layer 1 failed, and client
+     * code would run with a path to the native layer.
+     */
+    verifySandbox() {
+      if (!this.iframe.contentWindow) {
+        return Promise.reject(new Error("BridgeShell: iframe has no contentWindow"));
+      }
+      return new Promise((resolve, reject) => {
+        const nonce = Math.random().toString(36).slice(2);
+        const timer = setTimeout(() => {
+          this.pendingVerifies.delete(nonce);
+          reject(new Error(`BridgeShell: verify-sandbox timed out after ${VERIFY_TIMEOUT_MS}ms`));
+        }, VERIFY_TIMEOUT_MS);
+        this.pendingVerifies.set(nonce, { resolve, reject, timer });
+        this.postToClient({ type: "verify-sandbox" });
+      });
+    }
+    /**
+     * Tears the shell down: removes the `message` listener, cancels pending
+     * subscriptions on the native `Bridge`, and clears internal state.
+     */
+    detach() {
+      if (this.detached) return;
+      this.detached = true;
+      if (typeof window !== "undefined") {
+        window.removeEventListener("message", this.onMessage);
+      }
+      for (const unsub of this.subscriptions.values()) unsub();
+      this.subscriptions.clear();
+      for (const pending of this.pendingVerifies.values()) {
+        clearTimeout(pending.timer);
+        pending.reject(new Error("BridgeShell: detached"));
+      }
+      this.pendingVerifies.clear();
+    }
+    async handleSubscribe(key) {
+      if (!this.policy.readOnlyKeys.includes(key)) {
+        this.postToClient({ type: "nack", key, reason: "not-read-only" });
+        return;
+      }
+      if (this.subscriptions.has(key)) return;
+      const unsub = Bridge.on(key, (payload) => {
+        if (this.detached) return;
+        this.postToClient({ type: "event", key, payload });
+      });
+      this.subscriptions.set(key, unsub);
+    }
+    handleUnsubscribe(key) {
+      const unsub = this.subscriptions.get(key);
+      if (!unsub) return;
+      unsub();
+      this.subscriptions.delete(key);
+    }
+    async handleSend(command, args) {
+      if (this.policy.deniedCommands.includes(command)) {
+        this.postToClient({ type: "nack", command, reason: "denied" });
+        return;
+      }
+      if (this.policy.requiresConfirmation.includes(command)) {
+        if (!this.onConfirm) {
+          this.postToClient({ type: "nack", command, reason: "no-confirmation-handler" });
+          return;
+        }
+        let approved = false;
+        try {
+          approved = await this.onConfirm({ command, args });
+        } catch (err) {
+          this.postToClient({
+            type: "nack",
+            command,
+            reason: `confirmation-error: ${err instanceof Error ? err.message : String(err)}`
+          });
+          return;
+        }
+        if (!approved) {
+          this.postToClient({ type: "nack", command, reason: "user-rejected" });
+          return;
+        }
+      } else if (!this.policy.allowedCommands.includes(command)) {
+        this.postToClient({ type: "nack", command, reason: "not-allowed" });
+        return;
+      }
+      Bridge.send(command, args);
+    }
+    /**
+     * Resolves `nativeVersion`, firing the native handshake the first time and
+     * caching the result.
+     *
+     * ⚠️ `Bridge.handshake` has **no timeout**: its promise only settles when the
+     * native side emits `handshake-ack`. In a browser with no native host it
+     * never settles, so the race below is what guarantees the client always gets
+     * an answer — `null` — instead of hanging.
+     */
+    async resolveNativeVersion() {
+      if (this.nativeVersion !== null) return this.nativeVersion;
+      if (!this.nativeHandshake) {
+        this.nativeHandshake = Bridge.handshake({ clientVersion: SHELL_VERSION }).then((ack) => {
+          this.nativeVersion = ack.nativeVersion;
+        }).catch(() => {
+        });
+      }
+      await Promise.race([
+        this.nativeHandshake,
+        new Promise((resolve) => setTimeout(resolve, NATIVE_HANDSHAKE_TIMEOUT_MS))
+      ]);
+      return this.nativeVersion;
+    }
+    postToClient(msg) {
+      if (this.detached) return;
+      this.iframe.contentWindow?.postMessage(msg, "*");
+    }
+  };
+
+  // src/dev/policy.ts
+  var CANVAS_POLICY = {
+    readOnlyKeys: [
+      BRIDGE_KEYS.userDevice,
+      BRIDGE_KEYS.deviceConnection,
+      BRIDGE_KEYS.deviceLightSensors,
+      BRIDGE_KEYS.deviceNotification,
+      BRIDGE_KEYS.pingPong,
+      BRIDGE_KEYS.realTime,
+      BRIDGE_KEYS.syncTime,
+      BRIDGE_KEYS.deleteMemory,
+      BRIDGE_KEYS.sensorLog,
+      BRIDGE_KEYS.systemStatus,
+      BRIDGE_KEYS.navigationBack,
+      BRIDGE_KEYS.language
+    ],
+    allowedCommands: [
+      "userDevice",
+      "realTime",
+      "openSettings",
+      "deviceConnection",
+      "ping",
+      "jsError",
+      "sensorLog",
+      "setStatusBarColor",
+      "requestPermission",
+      "navigationState",
+      "language"
+    ],
+    requiresConfirmation: ["syncTime", "deleteMemory", "logout"],
+    deniedCommands: ["dfu"]
+  };
+  var CANVAS_CSP = "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self' data:; connect-src 'self'; frame-src 'self'; object-src 'none'; base-uri 'none'; form-action 'none';";
+
+  // src/dev/scenarios.ts
+  var HARNESS_NATIVE_VERSION = "0.17.0";
+  var base = {
+    description: "Two devices, background service already running, realistic latency.",
+    nativeVersion: HARNESS_NATIVE_VERSION,
+    latencyMs: [80, 250],
+    serviceStartMs: 0,
+    userDeviceSilent: false,
+    logPeriodS: 60,
+    systemStatus: systemStatus(),
+    devices: () => twoDevices()
+  };
+  var SCENARIOS = {
+    default: base,
+    "cold-start": {
+      ...base,
+      description: "App launched from cold: the background service takes 4 s to start, and every ping/userDevice sent before that is lost. A bundle that asks once stays on its loading screen forever.",
+      serviceStartMs: 4e3
+    },
+    "no-devices": {
+      ...base,
+      description: "Account with no linked device: userDevice never answers and systemStatus.hasDevices is false. Your bundle must show an empty state.",
+      userDeviceSilent: true,
+      systemStatus: systemStatus({ hasDevices: false })
+    },
+    "shared-serial": {
+      ...base,
+      description: "An ActLumus and an ActLumus Plus share serial number 7047. Only deviceId tells them apart; sensorLog cannot address one of them.",
+      devices: () => sharedSerial()
+    },
+    offline: {
+      ...base,
+      description: "No internet. systemStatus.internet is false and sensorLog fails; userDevice answers from the cache.",
+      sensorLogError: "Connection failed",
+      systemStatus: systemStatus({ internet: false })
+    }
+  };
+  function resolveScenario(scenario) {
+    if (scenario === void 0) return SCENARIOS.default;
+    if (typeof scenario === "string") {
+      const found = SCENARIOS[scenario];
+      if (!found) {
+        throw new Error(
+          `condor-mobile-bridge dev: unknown scenario "${scenario}". Known: ${Object.keys(SCENARIOS).join(", ")}.`
+        );
+      }
+      return found;
+    }
+    return scenario;
+  }
+
+  // src/dev/harness.ts
+  var DEV_HARNESS_MARKER = "__condorDevHarness__";
+  function createSimulatedNative(adapter, scenario, hooks = {}) {
+    const now = hooks.now ?? Date.now;
+    const startedAt = now();
+    const log = [];
+    const timers = /* @__PURE__ */ new Set();
+    let status = { ...scenario.systemStatus };
+    let canGoBack = false;
+    const record2 = (entry) => {
+      const full = { at: now(), ...entry };
+      log.push(full);
+      if (log.length > 500) log.shift();
+      hooks.onLog?.(full);
+      if (typeof console !== "undefined") console.info(`[condor dev] ${full.kind}: ${full.detail}`);
+    };
+    const latency = () => {
+      const l = scenario.latencyMs;
+      return Array.isArray(l) ? l[0] + Math.random() * (l[1] - l[0]) : l;
+    };
+    const reply = (key, payload, delay = latency()) => {
+      const timer = setTimeout(() => {
+        timers.delete(timer);
+        record2({ kind: "reply", key, detail: `${key} \u2192 bundle` });
+        adapter.triggerEmit(key, payload);
+      }, delay);
+      timers.add(timer);
+    };
+    const serviceUp = () => now() - startedAt >= scenario.serviceStartMs;
+    const language = () => {
+      const deviceLocale = typeof navigator !== "undefined" ? navigator.language : "en-US";
+      const lang = deviceLocale.slice(0, 2);
+      return {
+        deviceLocale,
+        appLanguage: null,
+        resolvedLanguage: ["en", "pt", "de", "fr"].includes(lang) ? lang : "en"
+      };
+    };
+    const handle = (msg) => {
+      const env = msg.payload ?? {};
+      const command = env.type ?? "";
+      const args = env.payload ?? {};
+      if (command !== "handshake") {
+        const shown = JSON.stringify(args);
+        const detail = shown === "{}" ? command : `${command} ${shown.length > 160 ? `${shown.slice(0, 157)}...` : shown}`;
+        record2({ kind: "sent", command, detail });
+      }
+      switch (command) {
+        case "handshake":
+          if (scenario.nativeVersion === null) {
+            record2({
+              kind: "info",
+              detail: "handshake unanswered: the bundle gets nativeVersion null"
+            });
+            return;
+          }
+          reply("handshake-ack", { nativeVersion: scenario.nativeVersion, accepted: true });
+          reply("systemStatus", status, latency() + 20);
+          reply("language", language(), latency() + 30);
+          return;
+        case "ping":
+          if (!serviceUp()) {
+            record2({
+              kind: "dropped",
+              command,
+              detail: "ping lost: the background service is not running yet"
+            });
+            return;
+          }
+          reply("pingPong", { data: "pong" });
+          return;
+        case "userDevice":
+          if (!serviceUp()) {
+            record2({
+              kind: "dropped",
+              command,
+              detail: "userDevice lost: the background service is not running yet. Ask again."
+            });
+            return;
+          }
+          if (scenario.userDeviceSilent) {
+            record2({
+              kind: "dropped",
+              command,
+              detail: "userDevice unanswered: the account has no linked device (the app replies only on success)"
+            });
+            return;
+          }
+          reply("userDevice", scenario.devices());
+          return;
+        case "sensorLog": {
+          const query = args;
+          if (scenario.sensorLogError) {
+            reply("sensorLog", {
+              requestId: query.requestId,
+              success: false,
+              error: scenario.sensorLogError
+            });
+            return;
+          }
+          const matches = scenario.devices().devicesConfig.filter((d) => d.serialNo === query.serialNo);
+          if (matches.length > 1) {
+            reply("sensorLog", {
+              requestId: query.requestId,
+              success: false,
+              error: "DEVICE_SERIAL_AMBIGUOUS"
+            });
+            return;
+          }
+          const device = matches[0];
+          reply(
+            "sensorLog",
+            sensorLogPage(query, {
+              now: now(),
+              periodS: scenario.logPeriodS,
+              deviceId: device?.deviceId
+            })
+          );
+          return;
+        }
+        case "realTime":
+          reply("realTime", {
+            serialNo: args.serialNo,
+            ...args.deviceId !== void 0 ? { deviceId: args.deviceId } : {},
+            success: true,
+            value: args.value === true
+          });
+          return;
+        case "syncTime":
+        case "deleteMemory":
+          reply(command, {
+            serialNo: args.serialNo,
+            ...args.deviceId !== void 0 ? { deviceId: args.deviceId } : {},
+            success: true
+          });
+          return;
+        case "deviceConnection":
+          if (args.type === "add") {
+            reply("deviceConnection", {
+              serialNo: args.serialNo,
+              ...args.deviceId !== void 0 ? { deviceId: args.deviceId } : {},
+              isConnect: true
+            });
+          }
+          return;
+        case "language":
+          reply("language", language());
+          return;
+        case "requestPermission": {
+          const name = String(args.permission);
+          status = {
+            ...status,
+            missingEssentialPermissions: status.missingEssentialPermissions.filter((p) => p !== name),
+            missingOptionalPermissions: status.missingOptionalPermissions.filter((p) => p !== name)
+          };
+          reply("systemStatus", status, latency() + 400);
+          return;
+        }
+        case "jsError":
+          record2({
+            kind: "info",
+            command,
+            detail: `jsError from the bundle: ${String(args.message)}`
+          });
+          return;
+        case "logout":
+          record2({
+            kind: "info",
+            command,
+            detail: "logout confirmed: the app would return to its login screen"
+          });
+          return;
+        case "navigationState":
+          canGoBack = args.canGoBack === true;
+          return;
+        default:
+          return;
+      }
+    };
+    const unsubscribe = adapter.onCallHandler(handle);
+    if (scenario.serviceStartMs > 0) {
+      const timer = setTimeout(() => {
+        timers.delete(timer);
+        record2({ kind: "info", detail: "background service is up: ping and userDevice now answer" });
+      }, scenario.serviceStartMs);
+      timers.add(timer);
+    }
+    return {
+      log,
+      pressBack() {
+        if (!canGoBack) {
+          record2({
+            kind: "info",
+            detail: "OS back: the bundle reported canGoBack false, so the app keeps the Home"
+          });
+          return;
+        }
+        reply("navigationBack", {}, 0);
+      },
+      dispose() {
+        unsubscribe();
+        for (const t of timers) clearTimeout(t);
+        timers.clear();
+      }
+    };
+  }
+  function confirmInPage(req) {
+    return new Promise((resolve) => {
+      const overlay = document.createElement("div");
+      overlay.setAttribute(
+        "style",
+        "position:fixed;inset:0;background:rgba(0,0,0,.45);display:flex;align-items:center;justify-content:center;z-index:2147483646;font:14px system-ui,sans-serif"
+      );
+      const box = document.createElement("div");
+      box.setAttribute(
+        "style",
+        "background:#fff;color:#111;border-radius:12px;padding:20px;max-width:320px;box-shadow:0 8px 32px rgba(0,0,0,.3)"
+      );
+      const text = document.createElement("p");
+      text.textContent = `The app asks the person to confirm "${req.command}". On a device this is a Condor dialog; if they decline, your bundle receives nothing.`;
+      const buttons = document.createElement("div");
+      buttons.setAttribute("style", "display:flex;gap:8px;justify-content:flex-end;margin-top:12px");
+      const done = (value) => {
+        overlay.remove();
+        resolve(value);
+      };
+      for (const [label, value] of [
+        ["Decline", false],
+        ["Confirm", true]
+      ]) {
+        const button = document.createElement("button");
+        button.textContent = label;
+        button.addEventListener("click", () => done(value));
+        buttons.appendChild(button);
+      }
+      box.append(text, buttons);
+      overlay.appendChild(box);
+      document.body.appendChild(overlay);
+    });
+  }
+  async function createDevHarness(opts) {
+    if (typeof document === "undefined") {
+      throw new Error(
+        "createDevHarness: needs a DOM (run it in the browser page that hosts the bundle)."
+      );
+    }
+    const adapter = getActiveAdapter();
+    if (!adapter.isMock) {
+      throw new Error(
+        "createDevHarness: a native host is present; the harness only runs in a plain browser."
+      );
+    }
+    globalThis[DEV_HARNESS_MARKER] = true;
+    const scenario = resolveScenario(opts.scenario);
+    const native = createSimulatedNative(adapter, scenario, { onLog: opts.onLog });
+    const iframe = document.createElement("iframe");
+    iframe.setAttribute("sandbox", "allow-scripts");
+    iframe.setAttribute("title", "Condor Canvas bundle");
+    iframe.setAttribute("style", "border:0;width:100%;height:100%;display:block;background:#fff");
+    (opts.mount ?? document.body).appendChild(iframe);
+    const shell = new BridgeShell({
+      iframe,
+      policy: CANVAS_POLICY,
+      onConfirmationRequest: opts.onConfirmationRequest ?? confirmInPage
+    });
+    if (opts.devPanel !== false) {
+      installDevPanel({ adapter, options: { startCollapsed: true } });
+    }
+    await shell.bootstrapClientIframeWithHtml(opts.html);
+    try {
+      const result = await shell.verifySandbox();
+      if (!result.ok) {
+        console.error(
+          "[condor dev] sandbox verification failed: the app would abort the boot.",
+          result
+        );
+      }
+    } catch (err) {
+      console.warn(
+        "[condor dev] the bundle did not answer the sandbox probe: its script did not run. Check the console of the iframe for errors, that the page imports BridgeClient, and that the input is self-contained (or let the harness inline it: pass the dist/index.html your bundler wrote).",
+        err
+      );
+    }
+    return {
+      scenario,
+      iframe,
+      shell,
+      get log() {
+        return native.log;
+      },
+      emit(key, payload) {
+        Bridge.mockEmit(key, payload);
+      },
+      pressBack() {
+        native.pressBack();
+      },
+      destroy() {
+        native.dispose();
+        shell.detach();
+        iframe.remove();
+      }
+    };
+  }
+  return __toCommonJS(dev_exports);
+})();