@condorinst/mobile-bridge 0.8.0

package/dist/index.js

@@ -0,0 +1,1005 @@
+// 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"
+};
+
+// 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 activeAdapter = null;
+function createRealAdapter(host) {
+  return {
+    isMock: false,
+    callHandler(handlerName, payload) {
+      void host.callHandler(handlerName, payload);
+    }
+  };
+}
+function detectAdapter() {
+  if (typeof window === "undefined") {
+    return createMockAdapter();
+  }
+  const host = window.flutter_inappwebview;
+  if (host && typeof host.callHandler === "function") {
+    return createRealAdapter(host);
+  }
+  return createMockAdapter();
+}
+function getActiveAdapter() {
+  if (!activeAdapter) {
+    activeAdapter = detectAdapter();
+  }
+  return activeAdapter;
+}
+function callNative(handlerName, payload) {
+  getActiveAdapter().callHandler(handlerName, payload);
+}
+
+// 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");
+  },
+  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-client.ts
+var PROTOCOL_VERSION2 = "0.5.0";
+var HANDSHAKE_TIMEOUT_MS = 5e3;
+var subscribers2 = /* @__PURE__ */ new Map();
+var pendingHandshake2 = null;
+var messageListenerInstalled = false;
+function postToShell(msg) {
+  if (typeof window === "undefined" || window.parent === window) {
+    console.warn("[BridgeClient] no parent window; message dropped:", msg.type);
+    return;
+  }
+  window.parent.postMessage(msg, "*");
+}
+function dispatchEvent(key, payload) {
+  const arr = subscribers2.get(key);
+  if (!arr || arr.length === 0) return;
+  for (const sub of arr) {
+    try {
+      sub.cb(payload);
+    } catch (err) {
+      console.error("[BridgeClient] subscriber error:", err);
+    }
+  }
+}
+function onMessage(event) {
+  if (event.source !== window.parent) return;
+  const data = event.data;
+  if (!data || typeof data !== "object" || typeof data.type !== "string") return;
+  switch (data.type) {
+    case "event": {
+      const msg = data;
+      if (typeof msg.key === "string") dispatchEvent(msg.key, msg.payload);
+      break;
+    }
+    case "handshake-ack": {
+      const msg = data;
+      if (pendingHandshake2) {
+        clearTimeout(pendingHandshake2.timer);
+        const { resolve } = pendingHandshake2;
+        pendingHandshake2 = null;
+        resolve({
+          shellVersion: msg.ack?.shellVersion ?? "unknown",
+          accepted: msg.ack?.accepted ?? false
+        });
+      }
+      break;
+    }
+    case "nack":
+      console.warn("[BridgeClient] command nacked by shell:", data);
+      break;
+    case "verify-sandbox": {
+      const w = window;
+      postToShell({
+        type: "sandbox-verify-response",
+        flutterBridgeReachable: typeof w.flutter_inappwebview !== "undefined",
+        condorBridgeReachable: typeof w.CondorBridge !== "undefined"
+      });
+      break;
+    }
+  }
+}
+function ensureMessageListener() {
+  if (messageListenerInstalled) return;
+  if (typeof window === "undefined") return;
+  messageListenerInstalled = true;
+  window.addEventListener("message", onMessage);
+}
+ensureMessageListener();
+var BridgeClient = {
+  protocolVersion: PROTOCOL_VERSION2,
+  on(key, cb) {
+    ensureMessageListener();
+    const arr = subscribers2.get(key) ?? [];
+    const sub = { cb };
+    arr.push(sub);
+    subscribers2.set(key, arr);
+    postToShell({ type: "subscribe", key });
+    return () => {
+      const remaining = (subscribers2.get(key) ?? []).filter((s) => s !== sub);
+      subscribers2.set(key, remaining);
+      if (remaining.length === 0) postToShell({ type: "unsubscribe", key });
+    };
+  },
+  send(command, args = {}) {
+    postToShell({ type: "send", command, args });
+  },
+  openSettings() {
+    this.send("openSettings");
+  },
+  handshake(opts) {
+    ensureMessageListener();
+    if (pendingHandshake2) {
+      return Promise.reject(
+        new Error(
+          "BridgeClient: handshake already in flight. Await previous before issuing another."
+        )
+      );
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pendingHandshake2 = null;
+        reject(new Error(`BridgeClient: handshake timeout after ${HANDSHAKE_TIMEOUT_MS}ms`));
+      }, HANDSHAKE_TIMEOUT_MS);
+      pendingHandshake2 = { resolve, reject, timer };
+      postToShell({
+        type: "handshake",
+        payload: { clientVersion: opts.clientVersion }
+      });
+    });
+  }
+};
+
+// 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()
+});
+var ClientToShellMessage = 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(),
+    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 ShellToClientMessage = v.variant("type", [
+  EventMessage,
+  HandshakeAckMessage,
+  NackMessage,
+  VerifySandboxMessage
+]);
+
+// src/bridge-shell.ts
+var SHELL_VERSION = "0.5.1";
+var VERIFY_TIMEOUT_MS = 2e3;
+var OVERRIDE_PREFIX = `<script>
+(function(){
+  try { delete window.flutter_inappwebview; } catch (_) {}
+  try { delete window.CondorBridge; } catch (_) {}
+  try {
+    Object.defineProperty(window, 'flutter_inappwebview', {
+      get: function(){ return undefined; },
+      set: function(_){ /* no-op: bloqueia inje\xE7\xE3o do plugin 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 (_) {}
+})();
+</script>`;
+var BridgeShell = class {
+  constructor(opts) {
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.detached = false;
+    // Map de `verify-sandbox` round-trips pendentes — key gerada por 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(ClientToShellMessage, 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":
+          this.postToClient({
+            type: "handshake-ack",
+            ack: { shellVersion: SHELL_VERSION, 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 ok = !msg.flutterBridgeReachable && !msg.condorBridgeReachable;
+              pending.resolve({
+                flutterBridgeReachable: msg.flutterBridgeReachable,
+                condorBridgeReachable: msg.condorBridgeReachable,
+                ok
+              });
+            }
+          }
+          break;
+        }
+      }
+    };
+    this.iframe = opts.iframe;
+    this.policy = opts.policy;
+    this.onConfirm = opts.onConfirmationRequest;
+    if (typeof window !== "undefined") {
+      window.addEventListener("message", this.onMessage);
+    }
+  }
+  /**
+   * **Camada 1 do Risco 1.** Bootstrap via fetch de URL.
+   *
+   * Atalho para o caso comum HTTP/HTTPS: faz `fetch(clientPath)` e
+   * delega para `bootstrapClientIframeWithHtml`.
+   *
+   * **Não funciona em scheme `file://`** — `fetch` em WebView Android
+   * (Chromium) bloqueia o scheme com "URL scheme 'file' is not supported".
+   * Para asset bundled em APK ou bundle inlined no build-time, use
+   * `bootstrapClientIframeWithHtml(htmlString)`.
+   *
+   * **Devo ser chamado uma vez no boot do shell**, antes de qualquer
+   * outra interação. Após retornar, `verifySandbox()` deve ser invocado
+   * para atestation (Camada 2).
+   */
+  async bootstrapClientIframe(clientPath = "client.html") {
+    const res = await fetch(clientPath);
+    if (!res.ok) throw new Error(`BridgeShell: falha ao carregar ${clientPath} (${res.status})`);
+    const clientHtml = await res.text();
+    await this.bootstrapClientIframeWithHtml(clientHtml);
+  }
+  /**
+   * **Camada 1 do Risco 1.** Bootstrap a partir de HTML string.
+   *
+   * Aceita HTML do cliente diretamente (já lido de arquivo, embedado em
+   * build-time via `esbuild.define`, lido de IndexedDB, etc.) e seta
+   * como `srcdoc` do iframe prefixado pelo override script. Override
+   * roda em parse-time, antes de qualquer outro script do cliente.
+   *
+   * Use quando `fetch` não é aplicável (asset bundled em `file://`,
+   * bundle inlined no build, qualquer cenário sem rede). Para HTTP
+   * use `bootstrapClientIframe(clientPath)`.
+   *
+   * **Devo ser chamado uma vez no boot do shell**, antes de qualquer
+   * outra interação. Após retornar, `verifySandbox()` deve ser invocado
+   * para atestation (Camada 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);
+    });
+  }
+  /**
+   * **Camada 2 do Risco 1.** Round-trip `postMessage` que pede ao iframe
+   * atestation autoritativa do estado de `window.flutter_inappwebview`
+   * e `window.CondorBridge`. Timeout em 2s.
+   *
+   * `ok` é `true` apenas se ambos forem `undefined` no iframe. Se vier
+   * `false`, **shell deve abortar o boot do app** — Camada 1 falhou e
+   * Camada 4 (dual WebView) precisa ser acionada manualmente.
+   */
+  verifySandbox() {
+    if (!this.iframe.contentWindow) {
+      return Promise.reject(new Error("BridgeShell: iframe sem 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 timeout ap\xF3s ${VERIFY_TIMEOUT_MS}ms`));
+      }, VERIFY_TIMEOUT_MS);
+      this.pendingVerifies.set(nonce, { resolve, reject, timer });
+      this.postToClient({ type: "verify-sandbox" });
+    });
+  }
+  /**
+   * Encerra o shell — remove listener `message`, cancela subscriptions
+   * pendentes no `Bridge` nativo, limpa estado interno.
+   */
+  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);
+  }
+  postToClient(msg) {
+    if (this.detached) return;
+    this.iframe.contentWindow?.postMessage(msg, "*");
+  }
+};
+export {
+  BRIDGE_KEYS,
+  Bridge,
+  BridgeClient,
+  BridgeShell
+};
+//# sourceMappingURL=index.js.map