@condorinst/mobile-bridge 0.19.2 → 0.21.0

package/dist/dev.js

@@ -0,0 +1,1611 @@
+// 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 });
+  }
+};
+
+// src/bridge-shell.ts
+import * as v2 from "valibot";
+
+// src/shell-messages.ts
+import * as v from "valibot";
+var BridgeKeySchema = v.picklist(Object.values(BRIDGE_KEYS));
+var SubscribeMessage = v.object({
+  type: v.literal("subscribe"),
+  key: BridgeKeySchema
+});
+var UnsubscribeMessage = v.object({
+  type: v.literal("unsubscribe"),
+  key: BridgeKeySchema
+});
+var SendMessage = v.object({
+  type: v.literal("send"),
+  command: v.string(),
+  args: v.optional(v.record(v.string(), v.unknown()), {})
+});
+var HandshakeMessage = v.object({
+  type: v.literal("handshake"),
+  payload: v.object({ clientVersion: v.string() })
+});
+var JsErrorMessage = v.object({
+  type: v.literal("jsError"),
+  payload: v.object({
+    message: v.string(),
+    stack: v.optional(v.string()),
+    source: v.optional(v.string()),
+    lineno: v.optional(v.number()),
+    colno: v.optional(v.number())
+  })
+});
+var SandboxVerifyResponseMessage = v.object({
+  type: v.literal("sandbox-verify-response"),
+  flutterBridgeReachable: v.boolean(),
+  condorBridgeReachable: v.boolean(),
+  // Optional: clients on SDK < 0.18.0 do not send it.
+  nativeChannelReachable: v.optional(v.boolean())
+});
+var ClientToShellMessageSchema = v.variant("type", [
+  SubscribeMessage,
+  UnsubscribeMessage,
+  SendMessage,
+  HandshakeMessage,
+  JsErrorMessage,
+  SandboxVerifyResponseMessage
+]);
+var EventMessage = v.object({
+  type: v.literal("event"),
+  key: BridgeKeySchema,
+  payload: v.unknown()
+});
+var HandshakeAckMessage = v.object({
+  type: v.literal("handshake-ack"),
+  ack: v.object({
+    shellVersion: v.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: v.nullable(v.string()),
+    accepted: v.boolean()
+  })
+});
+var NackMessage = v.object({
+  type: v.literal("nack"),
+  key: v.optional(v.string()),
+  command: v.optional(v.string()),
+  reason: v.string()
+});
+var VerifySandboxMessage = v.object({
+  type: v.literal("verify-sandbox")
+});
+var ShellToClientMessageSchema = v.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 = v2.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();
+    }
+  };
+}
+export {
+  CANVAS_CSP,
+  CANVAS_POLICY,
+  DEFAULT_LOG_PERIOD_S,
+  DEV_HARNESS_MARKER,
+  HARNESS_NATIVE_VERSION,
+  SCENARIOS,
+  createDevHarness,
+  createSimulatedNative,
+  formatLocalTimestamp,
+  parseLocalTimestamp,
+  resolveScenario,
+  sensorLogPage,
+  sharedSerial,
+  systemStatus,
+  twoDevices
+};
+//# sourceMappingURL=dev.js.map