@dimina-kit/devtools 0.3.2-dev.20260525152421 → 0.3.2-dev.20260610082053

package/dist/preload/windows/simulator.cjs

@@ -0,0 +1,925 @@
+"use strict";
+
+// src/preload/shared/expose.ts
+var import_electron = require("electron");
+function exposeOnMainWorld(key, value) {
+  let assignedToWindow = false;
+  if (process.contextIsolated) {
+    try {
+      import_electron.contextBridge.exposeInMainWorld(key, value);
+    } catch (err) {
+      console.warn("[devtools/expose] contextBridge.exposeInMainWorld failed, falling back to direct window assignment:", err);
+      window[key] = value;
+      assignedToWindow = true;
+    }
+  } else {
+    ;
+    window[key] = value;
+    assignedToWindow = true;
+  }
+  return () => {
+    if (!assignedToWindow) return;
+    const w = window;
+    if (w[key] === value) delete w[key];
+  };
+}
+
+// src/preload/shared/page-iframe.ts
+function getActivePageIframe() {
+  const iframes = document.querySelectorAll(".dimina-native-webview__window");
+  return iframes.length > 0 ? iframes[iframes.length - 1] : null;
+}
+
+// src/preload/shared/sid-registry.ts
+var SYNTHETIC_SID_PREFIX = "devtools-";
+var elBySyntheticSid = /* @__PURE__ */ new Map();
+function findElementBySid(doc, sid) {
+  if (sid.startsWith(SYNTHETIC_SID_PREFIX)) {
+    const ref = elBySyntheticSid.get(sid);
+    if (!ref) return null;
+    const el = ref.deref();
+    if (!el || !el.isConnected) {
+      elBySyntheticSid.delete(sid);
+      return null;
+    }
+    if (el.ownerDocument !== doc) return null;
+    return el;
+  }
+  return doc.querySelector(`[data-sid="${CSS.escape(sid)}"]`);
+}
+
+// src/preload/runtime/bridge.ts
+var state = {
+  appdata: { gen: 0, ready: true, data: {} },
+  storage: { gen: 0, ready: false, namespace: null, data: {} },
+  wxml: { gen: 0, ready: false, data: null },
+  refreshHandler: null
+};
+var highlightOverlay = null;
+var exposedApi = null;
+function clone(value) {
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return value;
+  }
+}
+function ensureOverlay(doc) {
+  if (highlightOverlay && highlightOverlay.ownerDocument === doc) return highlightOverlay;
+  highlightOverlay = doc.createElement("div");
+  highlightOverlay.id = "__simulator-highlight";
+  highlightOverlay.style.cssText = "position:fixed;pointer-events:none;z-index:999999;border:2px solid #1a73e8;background:rgba(26,115,232,0.12);transition:all 0.1s ease;display:none;border-radius:2px;box-sizing:border-box;";
+  doc.body.appendChild(highlightOverlay);
+  return highlightOverlay;
+}
+function highlightElement(sid) {
+  if (!sid) return null;
+  const iframe = getActivePageIframe();
+  if (!iframe?.contentDocument) return null;
+  const doc = iframe.contentDocument;
+  const el = findElementBySid(doc, sid);
+  if (!el) return null;
+  const rect = el.getBoundingClientRect();
+  const overlay = ensureOverlay(doc);
+  overlay.style.left = `${rect.left}px`;
+  overlay.style.top = `${rect.top}px`;
+  overlay.style.width = `${rect.width}px`;
+  overlay.style.height = `${rect.height}px`;
+  overlay.style.display = "block";
+  const style = el.ownerDocument.defaultView?.getComputedStyle(el);
+  if (!style) return null;
+  return {
+    sid,
+    rect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height },
+    style: {
+      display: style.display,
+      position: style.position,
+      boxSizing: style.boxSizing,
+      margin: style.margin,
+      padding: style.padding,
+      color: style.color,
+      backgroundColor: style.backgroundColor,
+      fontSize: style.fontSize
+    }
+  };
+}
+function unhighlightElement() {
+  if (highlightOverlay) highlightOverlay.style.display = "none";
+}
+function buildApi() {
+  return {
+    getAppdata: () => clone(state.appdata.data),
+    getAppdataSnapshot: () => clone(state.appdata),
+    getAppdataGen: () => state.appdata.gen,
+    getStorageSnapshot: () => clone(state.storage),
+    getStorageGen: () => state.storage.gen,
+    getWxml: () => clone(state.wxml.data),
+    getWxmlSnapshot: () => clone(state.wxml),
+    getWxmlGen: () => state.wxml.gen,
+    refresh: (type) => state.refreshHandler?.(type),
+    highlightElement,
+    unhighlightElement
+  };
+}
+function setAppDataSnapshot(data) {
+  state.appdata = {
+    gen: state.appdata.gen + 1,
+    ready: true,
+    data: clone(data)
+  };
+}
+function clearAppDataSnapshot() {
+  state.appdata = {
+    gen: state.appdata.gen + 1,
+    ready: true,
+    data: {}
+  };
+}
+function clearStorageSnapshot() {
+  state.storage = {
+    gen: state.storage.gen + 1,
+    ready: false,
+    namespace: null,
+    data: {}
+  };
+}
+function clearWxmlSnapshot() {
+  state.wxml = {
+    gen: state.wxml.gen + 1,
+    ready: false,
+    data: null
+  };
+}
+function resetBridgeState() {
+  clearAppDataSnapshot();
+  clearStorageSnapshot();
+  clearWxmlSnapshot();
+  unhighlightElement();
+  state.refreshHandler = null;
+}
+function installSimulatorBridge() {
+  if (!exposedApi) {
+    exposedApi = buildApi();
+  }
+  const dispose = exposeOnMainWorld("__simulatorData", exposedApi);
+  return () => {
+    resetBridgeState();
+    dispose();
+  };
+}
+
+// src/preload/runtime/custom-apis.ts
+var import_electron2 = require("electron");
+
+// src/shared/ipc-channels.ts
+var SimulatorChannel = {
+  // Ask main to create the simulator as a top-level WebContentsView (so nested
+  // render-host <webview>s can attach). Native-host is the sole runtime.
+  AttachNative: "simulator:attach-native",
+  // Renderer reports the device-bezel inner-screen rect (CSS px from content
+  // top-left) + zoom so main can overlay the simulator WCV on it.
+  SetNativeBounds: "simulator:set-native-bounds",
+  // Renderer pushes the selected device's LOGICAL metrics (screen size,
+  // pixelRatio, statusBarHeight, …) when the device dropdown changes. Main
+  // maps it to a HostEnvSnapshot and live-updates the running service-host
+  // window — the authoritative `wx.getSystemInfoSync()` source — so the
+  // mini-app sees the selected device without a relaunch.
+  SetDeviceInfo: "simulator:set-device-info",
+  Detach: "simulator:detach",
+  Resize: "simulator:resize",
+  SetVisible: "simulator:setVisible",
+  Console: "simulator:console",
+  // Main → renderer push of the visible top-of-stack page route whenever the
+  // mini-app navigates (navigateTo / switchTab / back). Payload: the page path
+  // string (same bare format as `getCurrentPagePath`), or '' when unknown.
+  CurrentPage: "simulator:current-page"
+};
+var SimulatorCustomApiBridgeChannel = {
+  Request: "simulator:custom-apis:bridge-request",
+  Response: "simulator:custom-apis:bridge-response"
+};
+
+// src/preload/runtime/custom-apis.ts
+var LIST_RETRY_INTERVAL_MS = 150;
+var LIST_RETRY_CEILING_MS = 2500;
+function buildBridge() {
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  const sendRequest = (req) => {
+    import_electron2.ipcRenderer.send(SimulatorCustomApiBridgeChannel.Request, req);
+  };
+  import_electron2.ipcRenderer.on(SimulatorCustomApiBridgeChannel.Response, (_event, payload) => {
+    const entry = pending.get(payload.id);
+    if (!entry) return;
+    pending.delete(payload.id);
+    if ("error" in payload) {
+      entry.reject(new Error(payload.error));
+    } else {
+      entry.resolve(payload.result);
+    }
+  });
+  const send = (req) => {
+    return new Promise((resolve, reject) => {
+      pending.set(req.id, {
+        resolve: (value) => resolve(value),
+        reject
+      });
+      sendRequest(req);
+    });
+  };
+  const listWithRetry = () => {
+    return new Promise((resolve, reject) => {
+      const attemptIds = /* @__PURE__ */ new Set();
+      const state2 = { settled: false };
+      const cleanup = () => {
+        state2.settled = true;
+        if (state2.retryTimer) clearInterval(state2.retryTimer);
+        if (state2.ceilingTimer) clearTimeout(state2.ceilingTimer);
+        for (const id of attemptIds) pending.delete(id);
+        attemptIds.clear();
+      };
+      const attempt = () => {
+        if (state2.settled) return;
+        const id = nextId++;
+        attemptIds.add(id);
+        pending.set(id, {
+          resolve: (value) => {
+            if (state2.settled) return;
+            cleanup();
+            resolve(value);
+          },
+          reject: (reason) => {
+            if (state2.settled) return;
+            cleanup();
+            reject(reason);
+          }
+        });
+        sendRequest({ id, op: "list" });
+      };
+      state2.retryTimer = setInterval(attempt, LIST_RETRY_INTERVAL_MS);
+      state2.ceilingTimer = setTimeout(() => {
+        if (state2.settled) return;
+        cleanup();
+        reject(new Error("custom-apis bridge list() got no response from the host renderer"));
+      }, LIST_RETRY_CEILING_MS);
+      attempt();
+    });
+  };
+  return {
+    list: listWithRetry,
+    invoke: (name, params) => send({ id: nextId++, op: "invoke", name, params })
+  };
+}
+function installCustomApisBridge() {
+  const bridge = buildBridge();
+  return exposeOnMainWorld("__diminaCustomApis", bridge);
+}
+
+// src/preload/runtime/temp-files.ts
+var import_electron3 = require("electron");
+
+// src/simulator/temp-files.ts
+var activeSink = null;
+function setTempFileSink(sink) {
+  activeSink = sink;
+}
+
+// src/preload/runtime/temp-files.ts
+function installTempFileBridge() {
+  setTempFileSink({
+    write(path, blob) {
+      blob.arrayBuffer().then((bytes) => {
+        import_electron3.ipcRenderer.send("simulator:temp-file:write", {
+          path,
+          mime: blob.type,
+          bytes
+        });
+      }).catch(() => {
+      });
+    },
+    revoke(path) {
+      import_electron3.ipcRenderer.send("simulator:temp-file:revoke", { path });
+    },
+    revokeAll() {
+      import_electron3.ipcRenderer.send("simulator:temp-file:revoke-all");
+    }
+  });
+}
+
+// src/preload/runtime/host.ts
+var import_electron4 = require("electron");
+function sendToHost(channel, data) {
+  import_electron4.ipcRenderer.sendToHost(channel, data);
+}
+function safeSerialize(val) {
+  if (val === null || val === void 0) return val;
+  if (typeof val === "function") return `[Function: ${val.name || "anonymous"}]`;
+  if (typeof val !== "object") return val;
+  if (val instanceof Error) return { __isError: true, message: val.message, stack: val.stack };
+  try {
+    return structuredClone(val);
+  } catch {
+  }
+  try {
+    return JSON.parse(JSON.stringify(val));
+  } catch {
+  }
+  return String(val);
+}
+
+// src/preload/instrumentation/console.ts
+function installConsoleInstrumentation() {
+  const consoleRef = console;
+  const originals = /* @__PURE__ */ new Map();
+  const levels = ["log", "warn", "error", "info", "debug"];
+  for (const level of levels) {
+    const original = consoleRef[level]?.bind(console);
+    if (!original) continue;
+    originals.set(level, original);
+    consoleRef[level] = (...args) => {
+      original(...args);
+      sendToHost(SimulatorChannel.Console, {
+        source: "container",
+        level,
+        args: args.map(safeSerialize),
+        ts: Date.now()
+      });
+    };
+  }
+  const handleError = (event) => {
+    sendToHost(SimulatorChannel.Console, {
+      source: "container",
+      level: "error",
+      args: [{
+        message: event.message,
+        source: event.filename,
+        lineno: event.lineno,
+        colno: event.colno,
+        stack: event.error?.stack
+      }],
+      ts: Date.now()
+    });
+  };
+  const handleRejection = (event) => {
+    sendToHost(SimulatorChannel.Console, {
+      source: "container",
+      level: "error",
+      args: [{ message: "Unhandled Promise Rejection", reason: String(event.reason) }],
+      ts: Date.now()
+    });
+  };
+  window.addEventListener("error", handleError);
+  window.addEventListener("unhandledrejection", handleRejection);
+  return () => {
+    for (const [level, original] of originals) {
+      consoleRef[level] = original;
+    }
+    window.removeEventListener("error", handleError);
+    window.removeEventListener("unhandledrejection", handleRejection);
+  };
+}
+
+// src/shared/appdata-accumulator.ts
+function decodeWorkerMessage(message) {
+  let payload = message;
+  if (typeof payload === "string") {
+    try {
+      payload = JSON.parse(payload);
+    } catch {
+      return null;
+    }
+  }
+  if (!payload || typeof payload !== "object") return null;
+  const record = payload;
+  if (record.type === "ub") {
+    const body = record.body;
+    if (!body || typeof body !== "object") return null;
+    if (typeof body.bridgeId !== "string" || !Array.isArray(body.updates)) return null;
+    const out = [];
+    for (const u of body.updates) {
+      if (!u || typeof u.moduleId !== "string") continue;
+      if (!u.moduleId.startsWith("page_")) continue;
+      out.push({ mode: "patch", bridgeId: body.bridgeId, moduleId: u.moduleId, data: u.data });
+    }
+    return out.length > 0 ? out : null;
+  }
+  if (typeof record.type === "string" && record.type.startsWith("page_")) {
+    const body = record.body;
+    if (!body || typeof body !== "object") return null;
+    if (typeof body.bridgeId !== "string" || typeof body.path !== "string") return null;
+    if (!body.data || typeof body.data !== "object") return null;
+    return [{
+      mode: "init",
+      bridgeId: body.bridgeId,
+      moduleId: record.type,
+      componentPath: body.path,
+      data: body.data
+    }];
+  }
+  return null;
+}
+function decodeOutgoingMessage(message) {
+  let payload = message;
+  if (typeof payload === "string") {
+    try {
+      payload = JSON.parse(payload);
+    } catch {
+      return null;
+    }
+  }
+  if (!payload || typeof payload !== "object") return null;
+  const r = payload;
+  if (typeof r.type !== "string") return null;
+  return {
+    type: r.type,
+    bridgeId: typeof r.body?.bridgeId === "string" ? r.body.bridgeId : void 0
+  };
+}
+var AppDataAccumulator = class {
+  cache = /* @__PURE__ */ new Map();
+  // Bridges in insertion order — drives the `bridges` array (stable tab order).
+  bridgeOrder = [];
+  // Page path per bridge: set from `page_*` init's body.path (the page route).
+  bridgePagePath = /* @__PURE__ */ new Map();
+  recordBridge(bridgeId) {
+    if (!this.bridgeOrder.includes(bridgeId)) this.bridgeOrder.push(bridgeId);
+  }
+  /**
+   * Apply one entry. Returns true if it was accepted (a mutation worth
+   * republishing), false if dropped (missing ids, or the R6 gate).
+   */
+  apply(input) {
+    if (!input.bridgeId || !input.moduleId) return false;
+    if (input.mode !== "init" && !this.bridgePagePath.has(input.bridgeId)) return false;
+    const key = `${input.bridgeId}/${input.moduleId}`;
+    const prev = this.cache.get(key);
+    const incoming = input.data && typeof input.data === "object" ? input.data : {};
+    const merged = input.mode === "init" ? { ...incoming } : { ...prev?.data ?? {}, ...incoming };
+    const componentPath = input.componentPath ?? prev?.componentPath;
+    const next = componentPath !== void 0 ? { componentPath, data: merged } : { data: merged };
+    this.cache.set(key, next);
+    this.recordBridge(input.bridgeId);
+    if (input.mode === "init" && input.moduleId.startsWith("page_") && input.componentPath) {
+      this.bridgePagePath.set(input.bridgeId, input.componentPath);
+    }
+    return true;
+  }
+  /** Evict every entry for a bridge (page teardown). */
+  clearBridge(bridgeId) {
+    const prefix = `${bridgeId}/`;
+    for (const key of [...this.cache.keys()]) {
+      if (key.startsWith(prefix)) this.cache.delete(key);
+    }
+    const idx = this.bridgeOrder.indexOf(bridgeId);
+    if (idx >= 0) this.bridgeOrder.splice(idx, 1);
+    this.bridgePagePath.delete(bridgeId);
+  }
+  /** The full cumulative snapshot for the panel. */
+  snapshot() {
+    const bridges = [];
+    for (const id of this.bridgeOrder) {
+      bridges.push({ id, pagePath: this.bridgePagePath.get(id) ?? null });
+    }
+    const entries = {};
+    for (const [key, entry] of this.cache) {
+      const slash = key.indexOf("/");
+      if (slash < 0) continue;
+      const bridgeId = key.slice(0, slash);
+      const moduleId = key.slice(slash + 1);
+      if (!entries[bridgeId]) entries[bridgeId] = {};
+      const displayKey = entry.componentPath ?? moduleId;
+      entries[bridgeId][displayKey] = entry.data;
+    }
+    return { bridges, entries };
+  }
+  /**
+   * The current reactive page state for a bridge: shallow-merge of `entry.data`
+   * across every cache entry whose key starts with `${bridgeId}/`, in insertion
+   * order (later entries win on key conflicts). `{}` when no entries match
+   * (unknown bridge / after clearBridge). Pure, no side effects.
+   */
+  pageData(bridgeId) {
+    const merged = {};
+    for (const [key, entry] of this.cache) {
+      const slash = key.indexOf("/");
+      if (slash < 0) continue;
+      if (key.slice(0, slash) !== bridgeId) continue;
+      Object.assign(merged, entry.data);
+    }
+    return merged;
+  }
+  /** Flat `key → data` map for the `__simulatorData.getAppdata()` mirror. */
+  flat() {
+    const data = {};
+    for (const [key, entry] of this.cache) data[key] = entry.data;
+    return data;
+  }
+  clear() {
+    this.cache.clear();
+    this.bridgeOrder.length = 0;
+    this.bridgePagePath.clear();
+  }
+};
+
+// src/preload/instrumentation/app-data.ts
+function createAppDataSource() {
+  const accumulator = new AppDataAccumulator();
+  let emit = null;
+  let installed = false;
+  let originalHook;
+  let originalDescriptor;
+  let OriginalWorker;
+  function publishSnapshot() {
+    setAppDataSnapshot(accumulator.flat());
+  }
+  function clearBridge(bridgeId) {
+    accumulator.clearBridge(bridgeId);
+    publishSnapshot();
+    emit?.();
+  }
+  function applyAppData(body) {
+    if (!accumulator.apply(body)) return;
+    publishSnapshot();
+    emit?.();
+  }
+  function instrumentPostMessage(worker) {
+    const orig = worker.postMessage.bind(worker);
+    worker.postMessage = function(msg, ...rest) {
+      const decoded = decodeOutgoingMessage(msg);
+      if (decoded?.type === "pageUnload" && decoded.bridgeId) {
+        clearBridge(decoded.bridgeId);
+      }
+      return orig(msg, ...rest);
+    };
+  }
+  function createInstrumentedWorker(Original) {
+    function InstrumentedWorker(scriptURL, options) {
+      const resolvedScriptURL = scriptURL instanceof URL ? scriptURL : new URL(scriptURL, window.location.href);
+      const worker = Reflect.construct(
+        Original,
+        [resolvedScriptURL, options],
+        new.target ?? InstrumentedWorker
+      );
+      instrumentPostMessage(worker);
+      worker.addEventListener("message", (event) => {
+        const entries = decodeWorkerMessage(event.data);
+        if (!entries) return;
+        for (const entry of entries) {
+          const hookBody = {
+            bridgeId: entry.bridgeId,
+            moduleId: entry.moduleId,
+            data: entry.data,
+            mode: entry.mode
+          };
+          if (entry.mode === "init") hookBody.componentPath = entry.componentPath;
+          window.__simulatorHook?.appData(hookBody);
+        }
+      });
+      return worker;
+    }
+    Object.setPrototypeOf(InstrumentedWorker, Original);
+    Object.defineProperty(InstrumentedWorker, "prototype", {
+      value: Original.prototype
+    });
+    return InstrumentedWorker;
+  }
+  return {
+    id: "appdata",
+    snapshot: () => accumulator.snapshot(),
+    start(onChange) {
+      if (installed) return;
+      installed = true;
+      emit = onChange;
+      originalHook = window.__simulatorHook;
+      originalDescriptor = Object.getOwnPropertyDescriptor(window, "Worker");
+      OriginalWorker = window.Worker;
+      window.__simulatorHook = {
+        appData: (body) => applyAppData(body)
+      };
+      Object.defineProperty(window, "Worker", {
+        configurable: true,
+        writable: true,
+        value: createInstrumentedWorker(OriginalWorker)
+      });
+    },
+    dispose() {
+      if (!installed) return;
+      installed = false;
+      if (originalDescriptor) {
+        Object.defineProperty(window, "Worker", originalDescriptor);
+      } else if (OriginalWorker) {
+        window.Worker = OriginalWorker;
+      }
+      if (originalHook) {
+        window.__simulatorHook = originalHook;
+      } else {
+        delete window.__simulatorHook;
+      }
+      originalDescriptor = void 0;
+      OriginalWorker = void 0;
+      originalHook = void 0;
+      accumulator.clear();
+      clearAppDataSnapshot();
+      emit = null;
+    }
+  };
+}
+
+// src/preload/shared/api-compat.ts
+function call(fn, payload) {
+  try {
+    fn?.(payload);
+  } catch {
+  }
+}
+function buildWindowInfo() {
+  const width = window.innerWidth || document.documentElement.clientWidth || 375;
+  const height = window.innerHeight || document.documentElement.clientHeight || 812;
+  const pixelRatio = window.devicePixelRatio || 2;
+  const statusBarHeight = 0;
+  return {
+    pixelRatio,
+    screenWidth: width,
+    screenHeight: height,
+    windowWidth: width,
+    windowHeight: height,
+    statusBarHeight,
+    safeArea: {
+      width,
+      height,
+      top: statusBarHeight,
+      bottom: height,
+      left: 0,
+      right: width
+    }
+  };
+}
+function makeStorageKey(key) {
+  return `dimina:${key}`;
+}
+function ensureWxApi(wx) {
+  if (typeof wx.canIUse !== "function") {
+    wx.canIUse = (_schema) => true;
+  }
+  if (typeof wx.getWindowInfo !== "function") {
+    wx.getWindowInfo = (opts = {}) => {
+      const info = buildWindowInfo();
+      call(opts.success, info);
+      call(opts.complete, void 0);
+      return info;
+    };
+  }
+  if (typeof wx.getSystemSetting !== "function") {
+    wx.getSystemSetting = (opts = {}) => {
+      const info = {
+        bluetoothEnabled: false,
+        locationEnabled: true,
+        wifiEnabled: true,
+        deviceOrientation: "portrait"
+      };
+      call(opts.success, info);
+      call(opts.complete, void 0);
+      return info;
+    };
+  }
+  if (typeof wx.getSystemInfoSync !== "function") {
+    wx.getSystemInfoSync = () => ({
+      brand: "simulator",
+      model: "web",
+      platform: "simulator",
+      system: "web",
+      language: "zh_CN",
+      SDKVersion: "3.0.0",
+      ...buildWindowInfo()
+    });
+  }
+  if (typeof wx.setStorageSync !== "function") {
+    wx.setStorageSync = (key, data) => {
+      const value = typeof data === "string" ? data : JSON.stringify(data);
+      localStorage.setItem(makeStorageKey(String(key)), value);
+    };
+  }
+  if (typeof wx.getStorageSync !== "function") {
+    wx.getStorageSync = (key) => {
+      const raw = localStorage.getItem(makeStorageKey(String(key)));
+      if (raw == null) return "";
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return raw;
+      }
+    };
+  }
+  if (typeof wx.removeStorageSync !== "function") {
+    wx.removeStorageSync = (key) => {
+      localStorage.removeItem(makeStorageKey(String(key)));
+    };
+  }
+  if (typeof wx.clearStorageSync !== "function") {
+    wx.clearStorageSync = () => {
+      const prefix = "dimina:";
+      const keys = [];
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key?.startsWith(prefix)) keys.push(key);
+      }
+      keys.forEach((key) => localStorage.removeItem(key));
+    };
+  }
+  if (typeof wx.getStorageInfoSync !== "function") {
+    wx.getStorageInfoSync = () => {
+      const prefix = "dimina:";
+      const keys = [];
+      let currentSize = 0;
+      for (let i = 0; i < localStorage.length; i++) {
+        const fullKey = localStorage.key(i);
+        if (!fullKey?.startsWith(prefix)) continue;
+        keys.push(fullKey.slice(prefix.length));
+        currentSize += (localStorage.getItem(fullKey) || "").length * 2;
+      }
+      return { keys, currentSize, limitSize: 10 * 1024 * 1024 };
+    };
+  }
+  if (typeof wx.request !== "function") {
+    wx.request = (opts) => {
+      const controller = new AbortController();
+      const method = (opts.method || "GET").toUpperCase();
+      let requestUrl = opts.url;
+      const init = {
+        method,
+        headers: { "Content-Type": "application/json", ...opts.header || {} },
+        signal: controller.signal
+      };
+      if (method === "GET" && opts.data && typeof opts.data === "object") {
+        const url = new URL(requestUrl, window.location.href);
+        Object.entries(opts.data).forEach(([key, value]) => {
+          url.searchParams.append(key, String(value));
+        });
+        requestUrl = url.toString();
+      } else if (opts.data != null) {
+        init.body = typeof opts.data === "string" ? opts.data : JSON.stringify(opts.data);
+      }
+      const timeoutId = Number(opts.timeout) > 0 ? window.setTimeout(() => controller.abort(), Number(opts.timeout)) : null;
+      fetch(requestUrl, init).then(async (response) => {
+        const headers = Object.fromEntries(response.headers.entries());
+        let data;
+        if (opts.dataType === "arraybuffer") data = await response.arrayBuffer();
+        else {
+          const text = await response.text();
+          if (opts.dataType === "text") data = text;
+          else {
+            try {
+              data = JSON.parse(text);
+            } catch {
+              data = text;
+            }
+          }
+        }
+        call(opts.success, { data, statusCode: response.status, header: headers, errMsg: "request:ok" });
+      }).catch((error) => {
+        call(opts.fail, { errMsg: `request:fail ${error instanceof Error ? error.message : String(error)}` });
+      }).finally(() => {
+        if (timeoutId != null) window.clearTimeout(timeoutId);
+        call(opts.complete, void 0);
+      });
+      return {
+        abort: () => controller.abort()
+      };
+    };
+  }
+}
+function setupApiCompatHook() {
+  const apply = () => {
+    const target = window;
+    if (!target.wx || typeof target.wx !== "object") {
+      target.wx = {};
+    }
+    const wx = target.wx;
+    ensureWxApi(wx);
+    return true;
+  };
+  if (apply()) return;
+  const timer = window.setInterval(() => {
+    if (apply()) window.clearInterval(timer);
+  }, 200);
+}
+
+// src/preload/runtime/native-host.ts
+var import_electron5 = require("electron");
+
+// src/shared/bridge-channels.ts
+var BRIDGE_CHANNELS = {
+  SPAWN: "dmb:spawn",
+  DISPOSE: "dmb:dispose",
+  PAGE_OPEN: "dmb:page:open",
+  PAGE_CLOSE: "dmb:page:close",
+  PAGE_LIFECYCLE: "dmb:page:lifecycle",
+  NAV_CALLBACK: "dmb:nav:callback",
+  SERVICE_INVOKE: "dmb:service:invoke",
+  SERVICE_PUBLISH: "dmb:service:publish",
+  RENDER_INVOKE: "dmb:render:invoke",
+  RENDER_PUBLISH: "dmb:render:publish",
+  TO_SERVICE: "dmb:to-service",
+  TO_RENDER: "dmb:to-render",
+  SIMULATOR_API: "dmb:simulator-api",
+  /** simulator → main: ack of an API_CALL request (carries success/fail args). */
+  API_RESPONSE: "dmb:api:response",
+  /**
+   * simulator webview preload → main (sendSync): "is native-host mode on?".
+   * The guest preload can't read the launch `process.env`, so it asks main
+   * (which can) at install time. Reply is `e.returnValue = boolean`.
+   */
+  NATIVE_HOST_ENABLED: "dmb:native-host-enabled",
+  /**
+   * simulator (DeviceShell) → main: the visible top-of-stack page bridgeId.
+   * Main has no z-order concept — the active page lives only in DeviceShell's
+   * ShellState — so devtools panels / automation that must target "the current
+   * page's render webContents" resolve it through this signal. Fire-and-forget.
+   */
+  ACTIVE_PAGE: "dmb:active-page",
+  /**
+   * simulator (DeviceShell) → main: the FULL ordered page stack (bottom→top)
+   * whenever it changes. Main has no stack of its own (it only learns the
+   * active bridgeId via ACTIVE_PAGE), so automation's `App.getPageStack` needs
+   * this to report multi-page stacks. Fire-and-forget.
+   */
+  PAGE_STACK: "dmb:page-stack"
+};
+
+// src/preload/runtime/native-host.ts
+function queryNativeHostConfig() {
+  try {
+    const res = import_electron5.ipcRenderer.sendSync(BRIDGE_CHANNELS.NATIVE_HOST_ENABLED);
+    return res && res.enabled ? res : null;
+  } catch {
+    return null;
+  }
+}
+function buildBridge2(cfg) {
+  return {
+    enabled: true,
+    spawn(opts) {
+      return import_electron5.ipcRenderer.invoke(BRIDGE_CHANNELS.SPAWN, opts);
+    },
+    dispose(bridgeId) {
+      const payload = { bridgeId };
+      import_electron5.ipcRenderer.send(BRIDGE_CHANNELS.DISPOSE, payload);
+    },
+    openPage(opts) {
+      return import_electron5.ipcRenderer.invoke(BRIDGE_CHANNELS.PAGE_OPEN, opts);
+    },
+    closePage(bridgeId) {
+      const payload = { bridgeId };
+      import_electron5.ipcRenderer.send(BRIDGE_CHANNELS.PAGE_CLOSE, payload);
+    },
+    notifyLifecycle(payload) {
+      import_electron5.ipcRenderer.send(BRIDGE_CHANNELS.PAGE_LIFECYCLE, payload);
+    },
+    notifyNavCallback(payload) {
+      import_electron5.ipcRenderer.send(BRIDGE_CHANNELS.NAV_CALLBACK, payload);
+    },
+    notifyApiResponse(payload) {
+      import_electron5.ipcRenderer.send(BRIDGE_CHANNELS.API_RESPONSE, payload);
+    },
+    notifyActivePage(payload) {
+      import_electron5.ipcRenderer.send(BRIDGE_CHANNELS.ACTIVE_PAGE, payload);
+    },
+    notifyPageStack(payload) {
+      import_electron5.ipcRenderer.send(BRIDGE_CHANNELS.PAGE_STACK, payload);
+    },
+    createRenderHostUrl(opts) {
+      const url = new URL(cfg.renderHostHtmlUrl);
+      url.searchParams.set("bridgeId", opts.bridgeId);
+      url.searchParams.set("appId", opts.appId);
+      url.searchParams.set("pagePath", opts.pagePath);
+      return url.toString();
+    },
+    renderPreloadUrl: cfg.renderPreloadUrl,
+    device: cfg.device,
+    onSimulatorEvent(channel, listener) {
+      const wrapped = (_event, payload) => {
+        ;
+        listener(payload);
+      };
+      import_electron5.ipcRenderer.on(channel, wrapped);
+      return () => import_electron5.ipcRenderer.removeListener(channel, wrapped);
+    }
+  };
+}
+function installNativeHostBridge() {
+  const cfg = queryNativeHostConfig();
+  if (!cfg) return () => {
+  };
+  return exposeOnMainWorld("__diminaNativeHost", buildBridge2(cfg));
+}
+
+// src/preload/windows/simulator.ts
+setupApiCompatHook();
+installSimulatorBridge();
+installCustomApisBridge();
+installTempFileBridge();
+installConsoleInstrumentation();
+installNativeHostBridge();
+createAppDataSource().start(() => {
+});
+//# sourceMappingURL=simulator.cjs.map