@dimina-kit/devtools 0.3.1 → 0.3.2-dev.20260522085907

package/dist/preload/windows/simulator.js

@@ -1,7 +1,30 @@
 "use strict";
 
-// src/preload/runtime/bridge.ts
+// src/preload/shared/expose.ts
 var import_electron = require("electron");
+function exposeOnMainWorld(key, value) {
+  let fellBack = false;
+  try {
+    import_electron.contextBridge.exposeInMainWorld(key, value);
+  } catch {
+    ;
+    window[key] = value;
+    fellBack = true;
+  }
+  return () => {
+    if (!fellBack) 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/runtime/bridge.ts
 var state = {
   appdata: { gen: 0, ready: true, data: {} },
   storage: { gen: 0, ready: false, namespace: null, data: {} },
@@ -43,10 +66,6 @@ function clone(value) {
     return value;
   }
 }
-function getPageIframe() {
-  const iframes = document.querySelectorAll(".dimina-native-webview__window");
-  return iframes.length > 0 ? iframes[iframes.length - 1] : null;
-}
 function ensureOverlay(doc) {
   if (highlightOverlay && highlightOverlay.ownerDocument === doc) return highlightOverlay;
   highlightOverlay = doc.createElement("div");
@@ -57,7 +76,7 @@ function ensureOverlay(doc) {
 }
 function highlightElement(sid) {
   if (!sid) return null;
-  const iframe = getPageIframe();
+  const iframe = getActivePageIframe();
   if (!iframe?.contentDocument) return null;
   const doc = iframe.contentDocument;
   const el = findElementBySid(doc, sid);
@@ -151,44 +170,82 @@ function installSimulatorBridge() {
   if (!exposedApi) {
     exposedApi = buildApi();
   }
-  try {
-    import_electron.contextBridge.exposeInMainWorld("__simulatorData", {
-      ...exposedApi,
-      getAppdata: () => clone(state.appdata.data),
-      getAppdataSnapshot: () => clone(state.appdata),
-      getStorageSnapshot: () => clone(state.storage),
-      getWxml: () => clone(state.wxml.data),
-      getWxmlSnapshot: () => clone(state.wxml)
-    });
-  } catch {
-    ;
-    window.__simulatorData = exposedApi;
-  }
+  const dispose = exposeOnMainWorld("__simulatorData", exposedApi);
   return () => {
     resetBridgeState();
-    const windowRef = window;
-    if (windowRef.__simulatorData === exposedApi) {
-      delete windowRef.__simulatorData;
-    }
+    dispose();
   };
 }
 
+// src/preload/runtime/custom-apis.ts
+var import_electron2 = require("electron");
+
 // src/shared/ipc-channels.ts
 var SimulatorChannel = {
   Attach: "simulator:attach",
   Detach: "simulator:detach",
   Resize: "simulator:resize",
   SetVisible: "simulator:setVisible",
-  Console: "simulator:console",
-  Wxml: "simulator:wxml",
-  AppData: "simulator:appdata",
-  AppDataAll: "simulator:appdata-all"
+  Console: "simulator:console"
+};
+var SimulatorCustomApiBridgeChannel = {
+  Request: "simulator:custom-apis:bridge-request",
+  Response: "simulator:custom-apis:bridge-response"
+};
+var MiniappSnapshotChannel = {
+  Push: "miniapp-snapshot:push",
+  Pull: "miniapp-snapshot:pull"
 };
 
+// src/preload/runtime/custom-apis.ts
+function buildBridge() {
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  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
+      });
+      import_electron2.ipcRenderer.sendToHost(SimulatorCustomApiBridgeChannel.Request, req);
+    });
+  };
+  return {
+    list: () => send({ id: nextId++, op: "list" }),
+    invoke: (name, params) => send({ id: nextId++, op: "invoke", name, params })
+  };
+}
+function installCustomApisBridge() {
+  const bridge = buildBridge();
+  return exposeOnMainWorld("__diminaCustomApis", bridge);
+}
+
 // src/preload/runtime/host.ts
-var import_electron2 = require("electron");
+var import_electron3 = require("electron");
 function sendToHost(channel, data) {
-  import_electron2.ipcRenderer.sendToHost(channel, data);
+  import_electron3.ipcRenderer.sendToHost(channel, data);
+}
+function onHostMessage(channel, handler) {
+  let active = true;
+  const wrapped = (_event, ...args) => {
+    if (!active) return;
+    handler(...args);
+  };
+  import_electron3.ipcRenderer.on(channel, wrapped);
+  return () => {
+    active = false;
+    import_electron3.ipcRenderer.removeListener(channel, wrapped);
+  };
 }
 function safeSerialize(val) {
   if (val === null || val === void 0) return val;
@@ -258,27 +315,7 @@ function installConsoleInstrumentation() {
   };
 }
 
-// src/preload/instrumentation/disposable.ts
-function createDisposableSet() {
-  const disposables2 = [];
-  return {
-    add: (fn) => disposables2.push(fn),
-    disposeAll: () => {
-      disposables2.forEach((fn) => fn());
-      disposables2.length = 0;
-    }
-  };
-}
-
 // src/preload/instrumentation/app-data.ts
-var appDataCache = /* @__PURE__ */ new Map();
-function publishSnapshot() {
-  const data = {};
-  for (const [key, value] of appDataCache) {
-    data[key] = value;
-  }
-  setAppDataSnapshot(data);
-}
 function decodeWorkerMessage(message) {
   let payload = message;
   if (typeof payload === "string") {
@@ -288,78 +325,199 @@ function decodeWorkerMessage(message) {
       return null;
     }
   }
+  if (!payload || typeof payload !== "object") return null;
   const record = payload;
-  if (record?.type !== "u" || !record.body) return null;
-  return record.body;
-}
-function createInstrumentedWorker(OriginalWorker) {
-  function InstrumentedWorker(scriptURL, options) {
-    const resolvedScriptURL = scriptURL instanceof URL ? scriptURL : new URL(scriptURL, window.location.href);
-    const worker = Reflect.construct(
-      OriginalWorker,
-      [resolvedScriptURL, options],
-      new.target ?? InstrumentedWorker
-    );
-    worker.addEventListener("message", (event) => {
-      const body = decodeWorkerMessage(event.data);
-      if (!body) return;
-      window.__simulatorHook?.appData({
-        bridgeId: body.bridgeId,
-        moduleId: body.moduleId,
-        data: body.data
-      });
-    });
-    return worker;
+  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;
   }
-  Object.setPrototypeOf(InstrumentedWorker, OriginalWorker);
-  Object.defineProperty(InstrumentedWorker, "prototype", {
-    value: OriginalWorker.prototype
-  });
-  return InstrumentedWorker;
-}
-function installAppDataInstrumentation() {
-  const disposables2 = createDisposableSet();
-  const originalHook = window.__simulatorHook;
-  const originalDescriptor = Object.getOwnPropertyDescriptor(window, "Worker");
-  const OriginalWorker = window.Worker;
-  window.__simulatorHook = {
-    appData: (body) => {
-      const record = body;
-      if (record?.bridgeId && record?.moduleId) {
-        const key = `${record.bridgeId}/${record.moduleId}`;
-        appDataCache.set(key, record.data);
-        publishSnapshot();
-      }
-      sendToHost(SimulatorChannel.AppData, body);
+  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
   };
-  Object.defineProperty(window, "Worker", {
-    configurable: true,
-    writable: true,
-    value: createInstrumentedWorker(OriginalWorker)
-  });
-  publishSnapshot();
-  disposables2.add(() => {
-    if (originalDescriptor) {
-      Object.defineProperty(window, "Worker", originalDescriptor);
-    } else {
-      window.Worker = OriginalWorker;
+}
+function createAppDataSource() {
+  const appDataCache = /* @__PURE__ */ new Map();
+  const bridgeOrder = [];
+  const bridgePagePath = /* @__PURE__ */ new Map();
+  let emit = null;
+  let installed = false;
+  let originalHook;
+  let originalDescriptor;
+  let OriginalWorker;
+  function recordBridge(bridgeId) {
+    if (!bridgeOrder.includes(bridgeId)) bridgeOrder.push(bridgeId);
+  }
+  function buildSnapshot() {
+    const bridges = [];
+    for (const id of bridgeOrder) {
+      bridges.push({ id, pagePath: bridgePagePath.get(id) ?? null });
     }
-  });
-  disposables2.add(() => {
-    if (originalHook) {
-      window.__simulatorHook = originalHook;
-    } else {
-      delete window.__simulatorHook;
+    const entries = {};
+    for (const [key, entry] of appDataCache) {
+      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;
     }
-  });
-  disposables2.add(() => {
-    appDataCache.clear();
-    clearAppDataSnapshot();
+    return { bridges, entries };
+  }
+  function publishSnapshot() {
+    const data = {};
+    for (const [key, entry] of appDataCache) {
+      data[key] = entry.data;
+    }
+    setAppDataSnapshot(data);
+  }
+  function clearBridge(bridgeId) {
+    const prefix = `${bridgeId}/`;
+    for (const key of [...appDataCache.keys()]) {
+      if (key.startsWith(prefix)) appDataCache.delete(key);
+    }
+    const idx = bridgeOrder.indexOf(bridgeId);
+    if (idx >= 0) bridgeOrder.splice(idx, 1);
+    bridgePagePath.delete(bridgeId);
     publishSnapshot();
-  });
-  return () => {
-    disposables2.disposeAll();
+    emit?.();
+  }
+  function applyAppData(body) {
+    const record = body;
+    if (!record?.bridgeId || !record?.moduleId) return;
+    if (record.mode !== "init" && !bridgePagePath.has(record.bridgeId)) return;
+    const key = `${record.bridgeId}/${record.moduleId}`;
+    const prev = appDataCache.get(key);
+    const incoming = record.data && typeof record.data === "object" ? record.data : {};
+    const merged = record.mode === "init" ? { ...incoming } : { ...prev?.data ?? {}, ...incoming };
+    const componentPath = record.componentPath ?? prev?.componentPath;
+    const next = componentPath !== void 0 ? { componentPath, data: merged } : { data: merged };
+    appDataCache.set(key, next);
+    recordBridge(record.bridgeId);
+    if (record.mode === "init" && record.moduleId.startsWith("page_") && record.componentPath) {
+      bridgePagePath.set(record.bridgeId, record.componentPath);
+    }
+    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: () => buildSnapshot(),
+    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;
+      appDataCache.clear();
+      bridgeOrder.length = 0;
+      bridgePagePath.clear();
+      clearAppDataSnapshot();
+      emit = null;
+    }
   };
 }
 
@@ -570,10 +728,6 @@ function walkInstance(instance, depth) {
 }
 
 // src/preload/instrumentation/wxml.ts
-function findActivePageIframe() {
-  const iframes = document.querySelectorAll(".dimina-native-webview__window");
-  return iframes.length > 0 ? iframes[iframes.length - 1] : null;
-}
 function getVueAppFromIframe(iframe) {
   try {
     const doc = iframe.contentDocument;
@@ -589,181 +743,253 @@ function getVueAppFromIframe(iframe) {
     return null;
   }
 }
-var wxmlTimer;
-var currentObserver = null;
-var currentIframe = null;
-var topObserver = null;
-var retryTimer;
-var retryTimeout;
-var navigationWaitTimer;
-var navigationWaitTimeout;
-var disposables = createDisposableSet();
-function clearTimers() {
-  if (wxmlTimer) clearTimeout(wxmlTimer);
-  if (retryTimer) clearInterval(retryTimer);
-  if (retryTimeout) clearTimeout(retryTimeout);
-  if (navigationWaitTimer) clearInterval(navigationWaitTimer);
-  if (navigationWaitTimeout) clearTimeout(navigationWaitTimeout);
-  wxmlTimer = void 0;
-  retryTimer = void 0;
-  retryTimeout = void 0;
-  navigationWaitTimer = void 0;
-  navigationWaitTimeout = void 0;
-}
-function publishTree(tree) {
-  if (tree) {
-    const normalized = Array.isArray(tree) ? { tagName: "#fragment", attrs: {}, children: tree } : tree;
-    setWxmlSnapshot(normalized, true);
-    sendToHost(SimulatorChannel.Wxml, normalized);
-    return;
-  }
-  clearWxmlSnapshot();
-  unhighlightElement();
-}
-function sendWxmlTree() {
-  const iframe = findActivePageIframe();
-  if (!iframe) {
-    publishTree(null);
-    return;
-  }
+function computeWxmlTree() {
+  const iframe = getActivePageIframe();
+  if (!iframe) return null;
   const instance = getVueAppFromIframe(iframe);
-  if (!instance) {
-    publishTree(null);
-    return;
-  }
+  if (!instance) return null;
   const tree = walkInstance(instance, 0);
-  if (!tree) {
-    publishTree(null);
-    return;
-  }
-  publishTree(tree);
+  if (!tree) return null;
+  return Array.isArray(tree) ? { tagName: "#fragment", attrs: {}, children: tree } : tree;
 }
-function observeIframe(iframe) {
-  if (iframe === currentIframe) return;
-  if (currentObserver) {
-    currentObserver.disconnect();
-    currentObserver = null;
-  }
-  if (navigationWaitTimer) {
-    clearInterval(navigationWaitTimer);
+function createWxmlSource() {
+  let tree = null;
+  let emit = null;
+  let wxmlTimer;
+  let currentObserver = null;
+  let currentIframe = null;
+  let topObserver = null;
+  let retryTimer;
+  let retryTimeout;
+  let navigationWaitTimer;
+  let navigationWaitTimeout;
+  function clearTimers() {
+    if (wxmlTimer) clearTimeout(wxmlTimer);
+    if (retryTimer) clearInterval(retryTimer);
+    if (retryTimeout) clearTimeout(retryTimeout);
+    if (navigationWaitTimer) clearInterval(navigationWaitTimer);
+    if (navigationWaitTimeout) clearTimeout(navigationWaitTimeout);
+    wxmlTimer = void 0;
+    retryTimer = void 0;
+    retryTimeout = void 0;
     navigationWaitTimer = void 0;
-  }
-  if (navigationWaitTimeout) {
-    clearTimeout(navigationWaitTimeout);
     navigationWaitTimeout = void 0;
   }
-  currentIframe = iframe;
-  const doc = iframe.contentDocument;
-  if (!doc?.body) {
-    publishTree(null);
-    return;
-  }
-  sendWxmlTree();
-  currentObserver = new MutationObserver(() => {
-    clearTimeout(wxmlTimer);
-    wxmlTimer = setTimeout(sendWxmlTree, WXML_DEBOUNCE_MS);
-  });
-  currentObserver.observe(doc.body, { childList: true, subtree: true });
-}
-function tryAttach() {
-  const iframe = findActivePageIframe();
-  if (!iframe) return false;
-  const instance = getVueAppFromIframe(iframe);
-  if (!instance) return false;
-  observeIframe(iframe);
-  return true;
-}
-function scheduleAttach() {
-  if (retryTimer) clearInterval(retryTimer);
-  if (retryTimeout) clearTimeout(retryTimeout);
-  retryTimer = setInterval(() => {
-    if (tryAttach() && retryTimer) {
-      clearInterval(retryTimer);
-      retryTimer = void 0;
+  function refresh() {
+    tree = computeWxmlTree();
+    if (tree) {
+      setWxmlSnapshot(tree, true);
+    } else {
+      clearWxmlSnapshot();
+      unhighlightElement();
     }
-  }, WXML_RETRY_INTERVAL_MS);
-  retryTimeout = setTimeout(() => {
-    if (retryTimer) clearInterval(retryTimer);
-    retryTimer = void 0;
-  }, WXML_RETRY_TIMEOUT_MS);
-}
-function observeTopLevel() {
-  if (topObserver) return;
-  topObserver = new MutationObserver(() => {
-    const iframe = findActivePageIframe();
-    if (!iframe) {
-      publishTree(null);
+    emit?.();
+  }
+  function observeIframe(iframe) {
+    if (iframe === currentIframe) return;
+    if (currentObserver) {
+      currentObserver.disconnect();
+      currentObserver = null;
+    }
+    if (navigationWaitTimer) {
+      clearInterval(navigationWaitTimer);
+      navigationWaitTimer = void 0;
+    }
+    if (navigationWaitTimeout) {
+      clearTimeout(navigationWaitTimeout);
+      navigationWaitTimeout = void 0;
+    }
+    currentIframe = iframe;
+    const doc = iframe.contentDocument;
+    if (!doc?.body) {
+      refresh();
       return;
     }
-    if (iframe !== currentIframe) {
-      if (navigationWaitTimer) {
-        clearInterval(navigationWaitTimer);
-        navigationWaitTimer = void 0;
+    refresh();
+    currentObserver = new MutationObserver(() => {
+      clearTimeout(wxmlTimer);
+      wxmlTimer = setTimeout(refresh, WXML_DEBOUNCE_MS);
+    });
+    currentObserver.observe(doc.body, { childList: true, subtree: true });
+  }
+  function tryAttach() {
+    const iframe = getActivePageIframe();
+    if (!iframe) return false;
+    const instance = getVueAppFromIframe(iframe);
+    if (!instance) return false;
+    observeIframe(iframe);
+    return true;
+  }
+  function scheduleAttach() {
+    if (retryTimer) clearInterval(retryTimer);
+    if (retryTimeout) clearTimeout(retryTimeout);
+    retryTimer = setInterval(() => {
+      if (tryAttach() && retryTimer) {
+        clearInterval(retryTimer);
+        retryTimer = void 0;
       }
-      if (navigationWaitTimeout) {
-        clearTimeout(navigationWaitTimeout);
-        navigationWaitTimeout = void 0;
+    }, WXML_RETRY_INTERVAL_MS);
+    retryTimeout = setTimeout(() => {
+      if (retryTimer) clearInterval(retryTimer);
+      retryTimer = void 0;
+    }, WXML_RETRY_TIMEOUT_MS);
+  }
+  function observeTopLevel() {
+    if (topObserver) return;
+    topObserver = new MutationObserver(() => {
+      const iframe = getActivePageIframe();
+      if (!iframe) {
+        refresh();
+        return;
       }
-      navigationWaitTimer = setInterval(() => {
-        if (getVueAppFromIframe(iframe)) {
+      if (iframe !== currentIframe) {
+        if (navigationWaitTimer) {
+          clearInterval(navigationWaitTimer);
+          navigationWaitTimer = void 0;
+        }
+        if (navigationWaitTimeout) {
+          clearTimeout(navigationWaitTimeout);
+          navigationWaitTimeout = void 0;
+        }
+        navigationWaitTimer = setInterval(() => {
+          if (getVueAppFromIframe(iframe)) {
+            if (navigationWaitTimer) {
+              clearInterval(navigationWaitTimer);
+              navigationWaitTimer = void 0;
+            }
+            if (navigationWaitTimeout) {
+              clearTimeout(navigationWaitTimeout);
+              navigationWaitTimeout = void 0;
+            }
+            observeIframe(iframe);
+          }
+        }, NAVIGATION_POLL_INTERVAL_MS);
+        navigationWaitTimeout = setTimeout(() => {
           if (navigationWaitTimer) {
             clearInterval(navigationWaitTimer);
             navigationWaitTimer = void 0;
           }
-          if (navigationWaitTimeout) {
-            clearTimeout(navigationWaitTimeout);
-            navigationWaitTimeout = void 0;
-          }
-          observeIframe(iframe);
-        }
-      }, NAVIGATION_POLL_INTERVAL_MS);
-      navigationWaitTimeout = setTimeout(() => {
-        if (navigationWaitTimer) {
-          clearInterval(navigationWaitTimer);
-          navigationWaitTimer = void 0;
+          navigationWaitTimeout = void 0;
+        }, NAVIGATION_TIMEOUT_MS);
+      }
+    });
+    if (document.body) {
+      topObserver.observe(document.body, { childList: true, subtree: true });
+    } else {
+      document.addEventListener("DOMContentLoaded", () => {
+        if (document.body && topObserver) {
+          topObserver.observe(document.body, { childList: true, subtree: true });
         }
-        navigationWaitTimeout = void 0;
-      }, NAVIGATION_TIMEOUT_MS);
+      }, { once: true });
     }
-  });
-  if (document.body) {
-    topObserver.observe(document.body, { childList: true, subtree: true });
-  } else {
-    document.addEventListener("DOMContentLoaded", () => {
-      if (document.body && topObserver) {
-        topObserver.observe(document.body, { childList: true, subtree: true });
+  }
+  return {
+    id: "wxml",
+    snapshot: () => tree,
+    start(onChange) {
+      emit = onChange;
+      if (!tryAttach()) {
+        scheduleAttach();
       }
-    }, { once: true });
+      observeTopLevel();
+    },
+    dispose() {
+      if (currentObserver) {
+        currentObserver.disconnect();
+        currentObserver = null;
+      }
+      if (topObserver) {
+        topObserver.disconnect();
+        topObserver = null;
+      }
+      currentIframe = null;
+      clearTimers();
+      clearWxmlSnapshot();
+      unhighlightElement();
+      tree = null;
+      emit = null;
+    }
+  };
+}
+
+// src/preload/miniapp-snapshot/host.ts
+var import_electron4 = require("electron");
+var ACCESSOR_KEY = "__miniappSnapshot";
+function exposeApi(api) {
+  try {
+    import_electron4.contextBridge.exposeInMainWorld(ACCESSOR_KEY, api);
+  } catch {
+    ;
+    window.__miniappSnapshot = api;
   }
+  return () => {
+    const windowRef = window;
+    if (windowRef[ACCESSOR_KEY] === api) {
+      delete windowRef[ACCESSOR_KEY];
+    }
+  };
 }
-function installWxmlInstrumentation() {
-  if (!tryAttach()) {
-    scheduleAttach();
+function createMiniappSnapshotHost() {
+  const sources = [];
+  const byId = /* @__PURE__ */ new Map();
+  let installed = false;
+  let disposed = false;
+  let seq = 0;
+  function publish(source) {
+    if (disposed) return;
+    seq += 1;
+    const envelope = {
+      id: source.id,
+      seq,
+      ts: Date.now(),
+      data: source.snapshot()
+    };
+    sendToHost(MiniappSnapshotChannel.Push, envelope);
   }
-  observeTopLevel();
-  disposables.add(() => {
-    if (currentObserver) {
-      currentObserver.disconnect();
-      currentObserver = null;
+  function register(source) {
+    if (installed) {
+      throw new Error("MiniappSnapshotHost: register() called after install()");
     }
-  });
-  disposables.add(() => {
-    if (topObserver) {
-      topObserver.disconnect();
-      topObserver = null;
+    if (byId.has(source.id)) {
+      throw new Error(`MiniappSnapshotHost: duplicate source id "${source.id}"`);
     }
-  });
-  disposables.add(() => {
-    currentIframe = null;
-    clearTimers();
-  });
-  disposables.add(() => {
-    clearWxmlSnapshot();
-    unhighlightElement();
-  });
-  return () => {
-    disposables.disposeAll();
-  };
+    const erased = source;
+    byId.set(source.id, erased);
+    sources.push(erased);
+  }
+  function install() {
+    if (installed) {
+      throw new Error("MiniappSnapshotHost: install() called twice");
+    }
+    installed = true;
+    for (const source of sources) {
+      source.start(() => publish(source));
+      publish(source);
+    }
+    const disposePull = onHostMessage(MiniappSnapshotChannel.Pull, (...args) => {
+      const payload = args[0];
+      const id = payload?.id;
+      if (typeof id !== "string") return;
+      const source = byId.get(id);
+      if (!source) return;
+      publish(source);
+    });
+    const api = {
+      get: (id) => byId.get(id)?.snapshot(),
+      ids: () => sources.map((source) => source.id)
+    };
+    const disposeApi = exposeApi(api);
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      disposePull();
+      disposeApi();
+      for (const source of sources) {
+        source.dispose();
+      }
+    };
+  }
+  return { register, install };
 }
 
 // src/preload/shared/api-compat.ts
@@ -948,7 +1174,10 @@ function setupApiCompatHook() {
 // src/preload/windows/simulator.ts
 setupApiCompatHook();
 installSimulatorBridge();
+installCustomApisBridge();
 installConsoleInstrumentation();
-installAppDataInstrumentation();
-installWxmlInstrumentation();
+var snapshotHost = createMiniappSnapshotHost();
+snapshotHost.register(createAppDataSource());
+snapshotHost.register(createWxmlSource());
+snapshotHost.install();
 //# sourceMappingURL=simulator.js.map