@dimina-kit/devtools 0.4.0-dev.20260702182435 → 0.4.0-dev.20260703051110

package/dist/main/index.bundle.js

@@ -173,55 +173,20 @@ function validate(channel, schema, args) {
 }
 
 // src/main/utils/logger.ts
-var LEVEL_PRIORITY = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3
-};
-var LEVEL_PREFIX = {
-  debug: "[DEBUG]",
-  info: "[INFO]",
-  warn: "[WARN]",
-  error: "[ERROR]"
-};
-var currentLevel = "debug";
-function shouldLog(level) {
-  return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[currentLevel];
-}
-function formatMessage(level, tag, message) {
-  const ts = (/* @__PURE__ */ new Date()).toISOString();
-  return `${ts} ${LEVEL_PREFIX[level]} [${tag}] ${message}`;
-}
-function createLogger(tag) {
-  return {
-    debug(message, ...args) {
-      if (shouldLog("debug")) console.debug(formatMessage("debug", tag, message), ...args);
-    },
-    info(message, ...args) {
-      if (shouldLog("info")) console.info(formatMessage("info", tag, message), ...args);
-    },
-    warn(message, ...args) {
-      if (shouldLog("warn")) console.warn(formatMessage("warn", tag, message), ...args);
-    },
-    error(message, ...args) {
-      if (shouldLog("error")) console.error(formatMessage("error", tag, message), ...args);
-    }
-  };
-}
+import { createLogger, setLogLevel } from "@dimina-kit/electron-deck/main";
 
 // src/main/utils/ipc-registry.ts
 var log = createLogger("ipc");
-function reportListenerError(channel, err) {
-  if (err instanceof IpcValidationError) {
-    log.warn(`schema reject on '${channel}' at [${err.paths.join(", ")}]`);
+function reportListenerError(channel, err2) {
+  if (err2 instanceof IpcValidationError) {
+    log.warn(`schema reject on '${channel}' at [${err2.paths.join(", ")}]`);
     return;
   }
-  if (err instanceof Error) {
-    log.error(`listener threw on '${channel}': ${err.message}`, err.stack);
+  if (err2 instanceof Error) {
+    log.error(`listener threw on '${channel}': ${err2.message}`, err2.stack);
     return;
   }
-  log.error(`listener threw on '${channel}'`, err);
+  log.error(`listener threw on '${channel}'`, err2);
 }
 function isThenable(v) {
   return v != null && (typeof v === "object" || typeof v === "function") && typeof v.then === "function";
@@ -284,13 +249,13 @@ var IpcRegistry = class {
           return;
         }
         event.returnValue = fn(event, ...args);
-      } catch (err) {
-        reportListenerError(channel, err);
-        const code = err?.code;
+      } catch (err2) {
+        reportListenerError(channel, err2);
+        const code = err2?.code;
         event.returnValue = {
           ok: false,
           code: typeof code === "string" ? code : "EUNKNOWN",
-          message: err instanceof Error ? err.message : String(err)
+          message: err2 instanceof Error ? err2.message : String(err2)
         };
       }
     };
@@ -307,10 +272,10 @@ var IpcRegistry = class {
       try {
         const ret = raw(event, ...args);
         if (isThenable(ret)) {
-          Promise.resolve(ret).catch((err) => reportListenerError(channel, err));
+          Promise.resolve(ret).catch((err2) => reportListenerError(channel, err2));
         }
-      } catch (err) {
-        reportListenerError(channel, err);
+      } catch (err2) {
+        reportListenerError(channel, err2);
       }
     };
     const guarded = policy ? (event, ...args) => {
@@ -555,9 +520,9 @@ var ReadFileSchema = z.tuple([PathArg]);
 var WriteFileSchema = z.tuple([PathArg, z.string()]);
 var ListFilesSchema = z.tuple([PathArg]);
 function makeError(code, message) {
-  const err = new Error(message);
-  err.code = code;
-  return err;
+  const err2 = new Error(message);
+  err2.code = code;
+  return err2;
 }
 function isWithin(parent, child) {
   if (child === parent) return true;
@@ -600,8 +565,8 @@ async function resolveWithinProjectRoot(abs, root) {
   let realTarget;
   try {
     realTarget = await fs2.realpath(lexical);
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
+  } catch (err2) {
+    if (err2.code !== "ENOENT") throw err2;
     const parent = path2.dirname(lexical);
     const realParent = await fs2.realpath(parent);
     if (!isWithin(realRoot, realParent)) {
@@ -648,8 +613,8 @@ async function assertWritableAncestor(lexical, root) {
     let realAncestor;
     try {
       realAncestor = await fs2.realpath(ancestor);
-    } catch (err) {
-      if (err.code !== "ENOENT") throw err;
+    } catch (err2) {
+      if (err2.code !== "ENOENT") throw err2;
       const next = path2.dirname(ancestor);
       if (next === ancestor) {
         throw makeError("EACCES", `Path escapes project root: ${lexical}`);
@@ -714,9 +679,9 @@ async function deleteWithin(root, rel) {
   let safe;
   try {
     safe = await resolveWithinProjectRoot(joinRel(root, rel), root);
-  } catch (err) {
-    if (err.code === "ENOENT") return;
-    throw err;
+  } catch (err2) {
+    if (err2.code === "ENOENT") return;
+    throw err2;
   }
   await fs2.rm(safe, { recursive: true, force: true });
 }
@@ -733,8 +698,8 @@ function resolveWithinProjectRootSync(abs, root) {
   let realTarget;
   try {
     realTarget = nodeFs.realpathSync(lexical);
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
+  } catch (err2) {
+    if (err2.code !== "ENOENT") throw err2;
     const parent = path2.dirname(lexical);
     const realParent = nodeFs.realpathSync(parent);
     if (!isWithin(realRoot, realParent)) {
@@ -754,8 +719,8 @@ function assertWritableAncestorSync(lexical, root) {
     let realAncestor;
     try {
       realAncestor = nodeFs.realpathSync(ancestor);
-    } catch (err) {
-      if (err.code !== "ENOENT") throw err;
+    } catch (err2) {
+      if (err2.code !== "ENOENT") throw err2;
       const next = path2.dirname(ancestor);
       if (next === ancestor) {
         throw makeError("EACCES", `Path escapes project root: ${lexical}`);
@@ -800,6 +765,25 @@ function writeFileSync(root, p, content) {
     nodeFs.closeSync(fd);
   }
 }
+async function readDirEntriesSafe(dir) {
+  try {
+    return await fs2.readdir(dir, { withFileTypes: true });
+  } catch (err2) {
+    const code = err2.code;
+    if (code === "EACCES" || code === "ENOENT" || code === "ENOTDIR") return null;
+    throw err2;
+  }
+}
+function collectListEntry(entry, dir, safeRoot, out, queue) {
+  const full = path2.join(dir, entry.name);
+  if (entry.isDirectory()) {
+    if (!SKIP_DIRS.has(entry.name)) queue.push(full);
+    return;
+  }
+  if (entry.isFile()) {
+    out.push(path2.relative(safeRoot, full).split(path2.sep).join("/"));
+  }
+}
 async function listFiles(root, rootArg) {
   const safeRoot = await resolveWithinProjectRoot(rootArg, root);
   const out = [];
@@ -807,24 +791,11 @@ async function listFiles(root, rootArg) {
   while (queue.length > 0) {
     if (out.length >= LIST_FILE_LIMIT) break;
     const dir = queue.shift();
-    let entries;
-    try {
-      entries = await fs2.readdir(dir, { withFileTypes: true });
-    } catch (err) {
-      const code = err.code;
-      if (code === "EACCES" || code === "ENOENT" || code === "ENOTDIR") continue;
-      throw err;
-    }
-    for (const e of entries) {
+    const entries = await readDirEntriesSafe(dir);
+    if (entries === null) continue;
+    for (const entry of entries) {
       if (out.length >= LIST_FILE_LIMIT) break;
-      const full = path2.join(dir, e.name);
-      if (e.isDirectory()) {
-        if (SKIP_DIRS.has(e.name)) continue;
-        queue.push(full);
-        continue;
-      }
-      if (!e.isFile()) continue;
-      out.push(path2.relative(safeRoot, full).split(path2.sep).join("/"));
+      collectListEntry(entry, dir, safeRoot, out, queue);
     }
   }
   return out;
@@ -1050,6 +1021,37 @@ function registerAppLifecycle() {
   });
 }
 
+// src/main/app/native-overview.ts
+async function resolveNativeStorageOverview(context, appId) {
+  try {
+    const info = await context.storageApi?.invoke(appId, "getStorageInfo", {});
+    if (info && typeof info === "object") {
+      const keys = info.keys;
+      if (Array.isArray(keys)) {
+        return {
+          storageKeys: keys.filter((key) => typeof key === "string"),
+          storageCount: keys.length
+        };
+      }
+    }
+  } catch {
+  }
+  return { storageKeys: [], storageCount: 0 };
+}
+function resolveNativeAppDataKeys(context, appId) {
+  try {
+    const snapshot = context.appData?.snapshot?.(appId);
+    if (snapshot && typeof snapshot === "object") {
+      const entries = snapshot.entries;
+      if (entries && typeof entries === "object") {
+        return Object.keys(entries);
+      }
+    }
+  } catch {
+  }
+  return [];
+}
+
 // src/main/services/workbench-context.ts
 import {
   createConnectionRegistry,
@@ -1150,8 +1152,8 @@ function createSafeAreaController(options = {}) {
   const attached = /* @__PURE__ */ new Map();
   function override(wc, device, isTabPage2) {
     if (wc.isDestroyed()) return;
-    void wc.debugger.sendCommand("Emulation.setSafeAreaInsetsOverride", { insets: guestInsets(device, isTabPage2) }).catch((err) => {
-      console.warn("[safe-area] setSafeAreaInsetsOverride failed:", err instanceof Error ? err.message : err);
+    void wc.debugger.sendCommand("Emulation.setSafeAreaInsetsOverride", { insets: guestInsets(device, isTabPage2) }).catch((err2) => {
+      console.warn("[safe-area] setSafeAreaInsetsOverride failed:", err2 instanceof Error ? err2.message : err2);
     });
   }
   return {
@@ -1162,8 +1164,8 @@ function createSafeAreaController(options = {}) {
       }
       try {
         wc.debugger.attach("1.3");
-      } catch (err) {
-        console.warn("[safe-area] debugger.attach failed; env(safe-area-inset-*) stays 0:", err instanceof Error ? err.message : err);
+      } catch (err2) {
+        console.warn("[safe-area] debugger.attach failed; env(safe-area-inset-*) stays 0:", err2 instanceof Error ? err2.message : err2);
         return;
       }
       attached.set(wc, isTabPage2);
@@ -1403,8 +1405,8 @@ function createWorkbenchView(ctx, reconciler) {
     }
     ctx.windows.mainWindow.contentView.addChildView(view);
     const loadUrl = `${url}index.html?theme=${workbenchThemeScheme()}`;
-    await view.webContents.loadURL(loadUrl).catch((err) => {
-      console.error("[workbench] attachWorkbench \u2014 loadURL failed", err);
+    await view.webContents.loadURL(loadUrl).catch((err2) => {
+      console.error("[workbench] attachWorkbench \u2014 loadURL failed", err2);
     });
   }
   function setWorkbenchSource(url) {
@@ -1439,7 +1441,7 @@ function createWorkbenchView(ctx, reconciler) {
         return true
       } catch (e) { return false }
     })()`;
-    return workbenchView.webContents.executeJavaScript(script, true).then((ok) => ok === true).catch(() => false);
+    return workbenchView.webContents.executeJavaScript(script, true).then((ok2) => ok2 === true).catch(() => false);
   }
   function openFileInWorkbench(relPath, line, column) {
     if (!workbenchView || workbenchView.webContents.isDestroyed()) return false;
@@ -1476,6 +1478,84 @@ function createWorkbenchView(ctx, reconciler) {
 // src/main/services/views/native-simulator-devtools-host.ts
 import { WebContentsView as WebContentsView3 } from "electron";
 
+// src/shared/open-in-editor-resource-path.ts
+function decodePathname(pathname) {
+  return pathname.split("/").map((segment) => {
+    try {
+      return decodeURIComponent(segment);
+    } catch {
+      return segment;
+    }
+  }).join("/");
+}
+function normalizeSlashPath(value) {
+  return decodePathname(value.replace(/\\/g, "/")).replace(/\/+/g, "/");
+}
+function safeRelativePath(segments) {
+  if (segments.length === 0 || segments.some((segment) => !segment || segment === "." || segment === "..")) {
+    return null;
+  }
+  return segments.join("/");
+}
+function excludeBuildChunk(rel) {
+  if (!rel) return rel;
+  const baseName = rel.split("/").pop();
+  return baseName === "common.js" || baseName === "vendors.js" || baseName === "runtime.js" || baseName === "taro.js" || baseName === "babelHelpers.js" ? null : rel;
+}
+function isOutsideKnownRoot(normalizedRaw) {
+  return /^\/(?:Volumes|Users|home|private|tmp|var|opt|Applications)\//.test(normalizedRaw);
+}
+function resolveFilesystemRawPath(normalizedRaw, projectRoot) {
+  if (!projectRoot) return void 0;
+  if (normalizedRaw !== projectRoot && !normalizedRaw.startsWith(`${projectRoot}/`)) return void 0;
+  const relative = normalizedRaw.slice(projectRoot.length).replace(/^\/+/, "");
+  return excludeBuildChunk(safeRelativePath(relative.split("/").filter(Boolean)));
+}
+function parseResourceUrl(raw, base) {
+  try {
+    return raw.startsWith("/") && !raw.startsWith("//") ? new URL(raw, base.origin) : new URL(raw);
+  } catch {
+    return null;
+  }
+}
+function resolveFileProtocolPath(resource, projectRoot) {
+  const filePath = normalizeSlashPath(resource.pathname);
+  if (!projectRoot || filePath !== projectRoot && !filePath.startsWith(`${projectRoot}/`)) return null;
+  return excludeBuildChunk(safeRelativePath(
+    filePath.slice(projectRoot.length).replace(/^\/+/, "").split("/").filter(Boolean)
+  ));
+}
+function resolveHttpProtocolPath(resource, base, context) {
+  if (resource.protocol !== "http:" && resource.protocol !== "https:") return null;
+  if (resource.origin !== base.origin) return null;
+  let segments = decodePathname(resource.pathname).split("/").filter(Boolean);
+  if (context.appId && segments[0] === context.appId) {
+    segments = segments.slice(1);
+    if (context.outputRoot && segments[0] === context.outputRoot) segments = segments.slice(1);
+  }
+  return excludeBuildChunk(safeRelativePath(segments));
+}
+function projectAwareResourcePath(resourceUrl, context) {
+  let base;
+  try {
+    base = new URL(context.resourceBaseUrl);
+  } catch {
+    return null;
+  }
+  const projectRoot = normalizeSlashPath(context.projectRoot).replace(/\/$/, "");
+  const raw = resourceUrl.trim();
+  if (!raw) return null;
+  const normalizedRaw = normalizeSlashPath(raw);
+  const filesystemRelative = resolveFilesystemRawPath(normalizedRaw, projectRoot);
+  if (filesystemRelative !== void 0) return filesystemRelative;
+  if (isOutsideKnownRoot(normalizedRaw)) return null;
+  if (!raw.startsWith("/") && !/^[a-z][a-z0-9+.-]*:/i.test(raw)) return null;
+  const resource = parseResourceUrl(raw, base);
+  if (!resource) return null;
+  if (resource.protocol === "file:") return resolveFileProtocolPath(resource, projectRoot);
+  return resolveHttpProtocolPath(resource, base, context);
+}
+
 // src/shared/open-in-editor.ts
 var OPEN_IN_EDITOR_SCHEME = "dimina-open-in-editor";
 function decodeOpenInEditorUrl(raw) {
@@ -1531,70 +1611,6 @@ function resourceUrlToProjectRelativePath(resourceUrl, expectedOriginOrContext)
   if (segments.length < 2) return null;
   return segments.slice(1).join("/");
 }
-function decodePathname(pathname) {
-  return pathname.split("/").map((segment) => {
-    try {
-      return decodeURIComponent(segment);
-    } catch {
-      return segment;
-    }
-  }).join("/");
-}
-function normalizeSlashPath(value) {
-  return decodePathname(value.replace(/\\/g, "/")).replace(/\/+/g, "/");
-}
-function safeRelativePath(segments) {
-  if (segments.length === 0 || segments.some((segment) => !segment || segment === "." || segment === "..")) {
-    return null;
-  }
-  return segments.join("/");
-}
-function projectAwareResourcePath(resourceUrl, context) {
-  let base;
-  try {
-    base = new URL(context.resourceBaseUrl);
-  } catch {
-    return null;
-  }
-  const projectRoot = normalizeSlashPath(context.projectRoot).replace(/\/$/, "");
-  const raw = resourceUrl.trim();
-  if (!raw) return null;
-  const excludeBuildChunk = (rel) => {
-    if (!rel) return rel;
-    const base2 = rel.split("/").pop();
-    return base2 === "common.js" || base2 === "vendors.js" || base2 === "runtime.js" || base2 === "taro.js" || base2 === "babelHelpers.js" ? null : rel;
-  };
-  const normalizedRaw = normalizeSlashPath(raw);
-  if (projectRoot && (normalizedRaw === projectRoot || normalizedRaw.startsWith(`${projectRoot}/`))) {
-    const relative = normalizedRaw.slice(projectRoot.length).replace(/^\/+/, "");
-    return excludeBuildChunk(safeRelativePath(relative.split("/").filter(Boolean)));
-  }
-  if (/^\/(?:Volumes|Users|home|private|tmp|var|opt|Applications)\//.test(normalizedRaw)) {
-    return null;
-  }
-  if (!raw.startsWith("/") && !/^[a-z][a-z0-9+.-]*:/i.test(raw)) return null;
-  let resource;
-  try {
-    resource = raw.startsWith("/") && !raw.startsWith("//") ? new URL(raw, base.origin) : new URL(raw);
-  } catch {
-    return null;
-  }
-  if (resource.protocol === "file:") {
-    const filePath = normalizeSlashPath(resource.pathname);
-    if (!projectRoot || filePath !== projectRoot && !filePath.startsWith(`${projectRoot}/`)) return null;
-    return excludeBuildChunk(safeRelativePath(
-      filePath.slice(projectRoot.length).replace(/^\/+/, "").split("/").filter(Boolean)
-    ));
-  }
-  if (resource.protocol !== "http:" && resource.protocol !== "https:") return null;
-  if (resource.origin !== base.origin) return null;
-  let segments = decodePathname(resource.pathname).split("/").filter(Boolean);
-  if (context.appId && segments[0] === context.appId) {
-    segments = segments.slice(1);
-    if (context.outputRoot && segments[0] === context.outputRoot) segments = segments.slice(1);
-  }
-  return excludeBuildChunk(safeRelativePath(segments));
-}
 function projectSourceContextFromServiceHostUrl(serviceHostUrl, activeProjectRoot) {
   let url;
   try {
@@ -1632,10 +1648,16 @@ function buildDevtoolsProjectSourceLinksScript(context) {
         }
 
         const cfg = ${config}
-        const diminaProjectSourcePath = ${projectAwareResourcePath.toString()}
         const decodePathname = ${decodePathname.toString()}
         const normalizeSlashPath = ${normalizeSlashPath.toString()}
         const safeRelativePath = ${safeRelativePath.toString()}
+        const excludeBuildChunk = ${excludeBuildChunk.toString()}
+        const isOutsideKnownRoot = ${isOutsideKnownRoot.toString()}
+        const resolveFilesystemRawPath = ${resolveFilesystemRawPath.toString()}
+        const parseResourceUrl = ${parseResourceUrl.toString()}
+        const resolveFileProtocolPath = ${resolveFileProtocolPath.toString()}
+        const resolveHttpProtocolPath = ${resolveHttpProtocolPath.toString()}
+        const diminaProjectSourcePath = ${projectAwareResourcePath.toString()}
         const observedRoots = new Set()
         const observers = []
         const clickBindings = []
@@ -2243,9 +2265,9 @@ function installElementsForward(deps) {
         });
       }
       replyResult(cmd, result);
-    }).catch((err) => {
+    }).catch((err2) => {
       if (disposed) return;
-      replyError(cmd, err instanceof Error ? err.message : String(err));
+      replyError(cmd, err2 instanceof Error ? err2.message : String(err2));
     });
   }
   function handleOutbound(batch) {
@@ -2325,18 +2347,15 @@ function mapConsoleApiType(type) {
   return "log";
 }
 var BIGINT_LITERAL = /^-?\d+n$/;
-function remoteObjectToValue(ro) {
-  if (!ro) return ro;
-  if ("value" in ro) return ro.value;
-  if (typeof ro.unserializableValue === "string") {
-    const u = ro.unserializableValue;
-    if (u === "Infinity") return Infinity;
-    if (u === "-Infinity") return -Infinity;
-    if (u === "NaN") return NaN;
-    if (u === "-0") return -0;
-    if (BIGINT_LITERAL.test(u)) return u;
-    return u;
-  }
+function unserializableToValue(u) {
+  if (u === "Infinity") return Infinity;
+  if (u === "-Infinity") return -Infinity;
+  if (u === "NaN") return NaN;
+  if (u === "-0") return -0;
+  if (BIGINT_LITERAL.test(u)) return u;
+  return u;
+}
+function typeFallbackToValue(ro) {
   switch (ro.type) {
     case "undefined":
       return void 0;
@@ -2351,6 +2370,14 @@ function remoteObjectToValue(ro) {
       return ro.description ?? "[Unknown]";
   }
 }
+function remoteObjectToValue(ro) {
+  if (!ro) return ro;
+  if ("value" in ro) return ro.value;
+  if (typeof ro.unserializableValue === "string") {
+    return unserializableToValue(ro.unserializableValue);
+  }
+  return typeFallbackToValue(ro);
+}
 function needsDeepFetch(ro) {
   if (!ro) return false;
   if ("value" in ro) return false;
@@ -2627,8 +2654,8 @@ function createDevtoolsHost(ctx, reconciler, deps) {
         emit: (entry) => ctx.consoleForwarder?.emit(entry)
       }).stop;
       return true;
-    } catch (err) {
-      console.warn("[devtools-host] point-at-service-wc failed; retry will rebuild:", err);
+    } catch (err2) {
+      console.warn("[devtools-host] point-at-service-wc failed; retry will rebuild:", err2);
       if (nativeDevtoolsSourceWc?.id === next.id) {
         nativeDevtoolsSourceWc = null;
       }
@@ -2822,8 +2849,8 @@ function createHostToolbarPortChannel(opts) {
   function invokeReadyHandler(handler) {
     try {
       handler();
-    } catch (err) {
-      console.error("[host-toolbar] onReady handler threw:", err);
+    } catch (err2) {
+      console.error("[host-toolbar] onReady handler threw:", err2);
     }
   }
   function fireReadyHandlers() {
@@ -3228,8 +3255,8 @@ async function handleCustomApiBridgeRequest(apis, req) {
   try {
     const result = req.op === "list" ? apis.list() : await apis.invoke(req.name, req.params);
     return { id: req.id, result };
-  } catch (err) {
-    return { id: req.id, error: err instanceof Error ? err.message : String(err) };
+  } catch (err2) {
+    return { id: req.id, error: err2 instanceof Error ? err2.message : String(err2) };
   }
 }
 function createSimulatorApiRegistry() {
@@ -3286,8 +3313,8 @@ function registerMiniappSessionConfigurator(fn) {
   for (const partition of configuredPartitions) {
     try {
       fn(electron.session.fromPartition(partition), partition);
-    } catch (err) {
-      console.warn("[miniapp-partition] configurator failed for", partition, err);
+    } catch (err2) {
+      console.warn("[miniapp-partition] configurator failed for", partition, err2);
     }
   }
   return () => {
@@ -3303,8 +3330,8 @@ function configureMiniappSession(partition) {
   for (const fn of configurators) {
     try {
       fn(sess, partition);
-    } catch (err) {
-      console.warn("[miniapp-partition] configurator failed for", partition, err);
+    } catch (err2) {
+      console.warn("[miniapp-partition] configurator failed for", partition, err2);
     }
   }
   return sess;
@@ -3457,7 +3484,7 @@ function createNativeSimulatorView(ctx, reconciler, deps) {
     }
     try {
       if (!nativeSimulatorView.webContents.isDestroyed()) {
-        ctx.bridge?.disposeSessionsForSimulator?.(nativeSimulatorView.webContents.id)?.catch((err) => console.warn(`[view-manager] dispose sessions (${label}) failed:`, err));
+        ctx.bridge?.disposeSessionsForSimulator?.(nativeSimulatorView.webContents.id)?.catch((err2) => console.warn(`[view-manager] dispose sessions (${label}) failed:`, err2));
         nativeSimulatorView.webContents.close();
       }
     } catch {
@@ -3597,8 +3624,8 @@ function createNativeSimulatorView(ctx, reconciler, deps) {
         e.preventDefault();
       }
     });
-    void simWc.loadURL(simulatorUrl).catch((err) => {
-      console.error("[workbench] attachNativeSimulator \u2014 loadURL failed", err);
+    void simWc.loadURL(simulatorUrl).catch((err2) => {
+      console.error("[workbench] attachNativeSimulator \u2014 loadURL failed", err2);
     });
     simulatorWebContentsId = simWc.id;
     ctx.networkForward?.attachSimulator(simWc);
@@ -3840,8 +3867,8 @@ function validateProjectDir(dirPath) {
           const resolvedRoot = path10.resolve(dirPath, cfg.miniprogramRoot);
           return `\u8BE5\u76EE\u5F55\u7F3A\u5C11 app.json\uFF0Cproject.config.json \u4E2D\u6307\u5B9A\u4E86 miniprogramRoot: "${cfg.miniprogramRoot}"\uFF0C\u8BF7\u5BFC\u5165 ${resolvedRoot}`;
         }
-      } catch (err) {
-        log2.warn("Failed to parse project.config.json", err);
+      } catch (err2) {
+        log2.warn("Failed to parse project.config.json", err2);
       }
     }
     return "\u8BE5\u76EE\u5F55\u7F3A\u5C11 app.json\uFF0C\u8BF7\u9009\u62E9\u5305\u542B\u5C0F\u7A0B\u5E8F\u6E90\u7801\u7684\u76EE\u5F55";
@@ -3857,8 +3884,8 @@ function addProject(dirPath) {
       const cfg = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
       if (cfg.projectname) name = cfg.projectname;
     }
-  } catch (err) {
-    log2.warn("Failed to read project name from config", err);
+  } catch (err2) {
+    log2.warn("Failed to read project name from config", err2);
   }
   const project = { name, path: dirPath, lastOpened: null };
   const idx = projects.findIndex((p) => p.path === dirPath);
@@ -4008,8 +4035,8 @@ function createWorkspaceService(ctx) {
   function bestEffort(label, fn) {
     try {
       fn();
-    } catch (err) {
-      console.warn(`[workspace] ${label} failed (non-fatal):`, err);
+    } catch (err2) {
+      console.warn(`[workspace] ${label} failed (non-fatal):`, err2);
     }
   }
   async function disposeSession() {
@@ -4023,8 +4050,8 @@ function createWorkspaceService(ctx) {
           (_, reject) => setTimeout(() => reject(new Error("session close timed out")), 5e3)
         )
       ]);
-    } catch (err) {
-      console.error("[workspace] session close failed:", err);
+    } catch (err2) {
+      console.error("[workspace] session close failed:", err2);
     }
   }
   async function runOpenTeardown(mySeq) {
@@ -4065,16 +4092,16 @@ function createWorkspaceService(ctx) {
         fileTypes: ctx.fileTypes,
         watch: compile.watch,
         onRebuild: () => sendStatus("ready", "\u7F16\u8BD1\u5B8C\u6210\uFF0C\u5DF2\u91CD\u542F", true),
-        onBuildError: (err) => sendStatus("error", String(err)),
+        onBuildError: (err2) => sendStatus("error", String(err2)),
         onLog: (entry) => {
           if (sessionGeneration !== logGeneration) return;
           ctx.notify.compileLog({ stream: entry.stream, text: entry.text, at: Date.now() });
         }
       });
       return { session: session5 };
-    } catch (err) {
+    } catch (err2) {
       clearSimulatorServicewechatReferer();
-      return { error: String(err) };
+      return { error: String(err2) };
     }
   }
   async function rejectInvalidAppId(session5) {
@@ -4112,8 +4139,8 @@ function createWorkspaceService(ctx) {
       if (ctx.onBeforeOpenProject) {
         try {
           await ctx.onBeforeOpenProject(projectPath);
-        } catch (err) {
-          const error = err instanceof Error ? err.message : String(err);
+        } catch (err2) {
+          const error = err2 instanceof Error ? err2.message : String(err2);
           sendStatus("error", error);
           return { success: false, error };
         }
@@ -4607,51 +4634,60 @@ import path14 from "path";
 import fs7 from "node:fs";
 import path13 from "node:path";
 var DEFAULT_TEMPLATE_ID = "blank";
-async function createProject(input, ctx) {
-  const name = (input.name ?? "").trim();
+function resolveName(rawName) {
+  const name = (rawName ?? "").trim();
   if (name.length === 0) {
     throw new Error("Project name cannot be empty");
   }
-  const target = input.path;
+  return name;
+}
+function validateTargetPath(target) {
   if (!target || typeof target !== "string") {
     throw new Error("Project path is required");
   }
-  if (fs7.existsSync(target)) {
-    const stat = fs7.statSync(target);
-    if (!stat.isDirectory()) {
-      throw new Error(`Project path exists and is not a directory: ${target}`);
-    }
-    const entries = fs7.readdirSync(target);
-    if (entries.length > 0) {
-      throw new Error(
-        `Project path is not empty (refusing to overwrite): ${target}`
-      );
-    }
+  if (!fs7.existsSync(target)) return;
+  const stat = fs7.statSync(target);
+  if (!stat.isDirectory()) {
+    throw new Error(`Project path exists and is not a directory: ${target}`);
   }
-  const templateId = input.templateId ?? DEFAULT_TEMPLATE_ID;
-  const template = ctx.templates.find((t) => t.id === templateId);
+  const entries = fs7.readdirSync(target);
+  if (entries.length > 0) {
+    throw new Error(
+      `Project path is not empty (refusing to overwrite): ${target}`
+    );
+  }
+}
+function resolveTemplate(templates, templateId) {
+  const id = templateId ?? DEFAULT_TEMPLATE_ID;
+  const template = templates.find((t) => t.id === id);
   if (!template) {
-    throw new Error(`Template not found: ${templateId}`);
+    throw new Error(`Template not found: ${id}`);
   }
   if (!template.source && !template.generate) {
     throw new Error(
-      `Template '${templateId}' has neither a source directory nor a generate function`
+      `Template '${id}' has neither a source directory nor a generate function`
     );
   }
+  return template;
+}
+async function materializeTemplate(target, template, name) {
   fs7.mkdirSync(target, { recursive: true });
   if (template.generate) {
     await template.generate(target, { name });
-  } else if (template.source) {
-    if (!fs7.existsSync(template.source.path)) {
-      throw new Error(
-        `Template source missing on disk: ${template.source.path}`
-      );
-    }
-    fs7.cpSync(template.source.path, target, {
-      recursive: true,
-      force: true
-    });
+    return;
+  }
+  if (!template.source) return;
+  if (!fs7.existsSync(template.source.path)) {
+    throw new Error(
+      `Template source missing on disk: ${template.source.path}`
+    );
   }
+  fs7.cpSync(template.source.path, target, {
+    recursive: true,
+    force: true
+  });
+}
+function writeProjectConfig(target, name) {
   const cfgPath = path13.join(target, "project.config.json");
   let cfg = {};
   if (fs7.existsSync(cfgPath)) {
@@ -4663,6 +4699,14 @@ async function createProject(input, ctx) {
   }
   cfg.projectname = name;
   fs7.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+}
+async function createProject(input, ctx) {
+  const name = resolveName(input.name);
+  const target = input.path;
+  validateTargetPath(target);
+  const template = resolveTemplate(ctx.templates, input.templateId);
+  await materializeTemplate(target, template, name);
+  writeProjectConfig(target, name);
   const created = await ctx.projectsProvider.addProject(target);
   return created;
 }
@@ -4726,15 +4770,15 @@ function registerProjectsIpc(ctx) {
         templates: ctx.projectTemplates ?? [],
         projectsProvider: ctx.projectsProvider
       });
-    } catch (err) {
+    } catch (err2) {
       await dialog.showMessageBox(ctx.windows.mainWindow, {
         type: "error",
         title: "\u521B\u5EFA\u9879\u76EE\u5931\u8D25",
         message: "\u65E0\u6CD5\u521B\u5EFA\u9879\u76EE",
-        detail: err instanceof Error ? err.message : String(err),
+        detail: err2 instanceof Error ? err2.message : String(err2),
         buttons: ["\u786E\u5B9A"]
       });
-      throw err;
+      throw err2;
     }
     try {
       const settings = loadWorkbenchSettings();
@@ -4742,8 +4786,8 @@ function registerProjectsIpc(ctx) {
       if (newBase && settings.lastCreateBaseDir !== newBase) {
         saveWorkbenchSettings({ ...settings, lastCreateBaseDir: newBase });
       }
-    } catch (err) {
-      console.warn("[projects:create] failed to persist lastCreateBaseDir", err);
+    } catch (err2) {
+      console.warn("[projects:create] failed to persist lastCreateBaseDir", err2);
     }
     return project;
   }).handle(ProjectsChannel.GetCreateDefaults, () => {
@@ -4984,7 +5028,7 @@ async function startDiminaResourceServer(rootDir) {
     baseUrl: `http://127.0.0.1:${address.port}/`,
     close() {
       return new Promise((resolve, reject) => {
-        server.close((err) => err ? reject(err) : resolve());
+        server.close((err2) => err2 ? reject(err2) : resolve());
       });
     }
   };
@@ -6081,27 +6125,33 @@ function summarizeBridgeMsg(payload) {
   return parts.length > 0 ? parts.join(" ") : void 0;
 }
 var API_CALL_TIMEOUT_MS = 5e3;
+function findAppSessionByAppId(state, appId) {
+  let match;
+  for (const ap of state.appSessions.values()) if (ap.appId === appId) match = ap;
+  return match;
+}
+function resolveFallbackAppSession(state) {
+  let last;
+  const distinctAppIds = /* @__PURE__ */ new Set();
+  for (const ap of state.appSessions.values()) {
+    last = ap;
+    distinctAppIds.add(ap.appId);
+  }
+  return distinctAppIds.size <= 1 ? last : void 0;
+}
 function resolveCurrentApp(state, ctx, appId) {
   if (appId) {
-    let match;
-    for (const ap of state.appSessions.values()) if (ap.appId === appId) match = ap;
+    const match = findAppSessionByAppId(state, appId);
     if (match) return match;
   }
   const appInfo = ctx.workspace?.getSession?.()?.appInfo;
   const activeAppId = appInfo?.appId;
   if (activeAppId) {
-    let match;
-    for (const ap of state.appSessions.values()) if (ap.appId === activeAppId) match = ap;
+    const match = findAppSessionByAppId(state, activeAppId);
     if (match) return match;
   }
   if (ctx.workspace?.isClosing?.()) return void 0;
-  let last;
-  const distinctAppIds = /* @__PURE__ */ new Set();
-  for (const ap of state.appSessions.values()) {
-    last = ap;
-    distinctAppIds.add(ap.appId);
-  }
-  return distinctAppIds.size <= 1 ? last : void 0;
+  return resolveFallbackAppSession(state);
 }
 function installBridgeRouter(ctx) {
   const state = {
@@ -6841,99 +6891,108 @@ var APP_LIFECYCLE_UNREGISTER = {
   offAppHide: "onAppHide",
   offError: "onError"
 };
-async function handleSimulatorApi(state, ap, page, body, ctx) {
-  const name = String(body.name ?? "");
-  const params = normalizeParams(body.params);
-  if (NAV_BAR_API_NAMES.has(name)) {
-    if (!ap.simulatorWc.isDestroyed()) {
-      ap.simulatorWc.send(SIMULATOR_EVENTS.NAV_BAR, {
-        bridgeId: page.bridgeId,
-        name,
-        params
-      });
-    }
-    const successResult = { errMsg: `${name}:ok` };
-    sendCallback(ap, params.success, successResult);
-    sendCallback(ap, params.complete, successResult);
-    return;
-  }
-  if (NAV_ACTION_NAMES.has(name)) {
-    const payload = {
-      appSessionId: ap.appSessionId,
+function handleNavBarApi(ap, page, name, params) {
+  if (!ap.simulatorWc.isDestroyed()) {
+    ap.simulatorWc.send(SIMULATOR_EVENTS.NAV_BAR, {
       bridgeId: page.bridgeId,
       name,
-      params,
-      callbacks: extractCallbacks(params)
-    };
-    if (!ap.simulatorWc.isDestroyed()) {
-      ap.simulatorWc.send(SIMULATOR_EVENTS.NAV_ACTION, payload);
-    } else {
-      const fail = { errMsg: `${name}:fail simulator window destroyed` };
-      sendCallback(ap, params.fail, fail);
-      sendCallback(ap, params.complete, fail);
-    }
-    return;
+      params
+    });
   }
-  if (TAB_ACTION_NAMES.has(name)) {
-    const payload = {
-      appSessionId: ap.appSessionId,
-      bridgeId: page.bridgeId,
-      name,
-      params,
-      callbacks: extractCallbacks(params)
-    };
-    if (!ap.simulatorWc.isDestroyed()) {
-      ap.simulatorWc.send(SIMULATOR_EVENTS.TAB_ACTION, payload);
-    } else {
-      const fail = { errMsg: `${name}:fail simulator window destroyed` };
-      sendCallback(ap, params.fail, fail);
-      sendCallback(ap, params.complete, fail);
-    }
+  const successResult = { errMsg: `${name}:ok` };
+  sendCallback(ap, params.success, successResult);
+  sendCallback(ap, params.complete, successResult);
+}
+function sendActionOrFail(ap, eventName, payload, name, params) {
+  if (!ap.simulatorWc.isDestroyed()) {
+    ap.simulatorWc.send(eventName, payload);
     return;
   }
+  const fail = { errMsg: `${name}:fail simulator window destroyed` };
+  sendCallback(ap, params.fail, fail);
+  sendCallback(ap, params.complete, fail);
+}
+function handleNavActionApi(ap, page, name, params) {
+  const payload = {
+    appSessionId: ap.appSessionId,
+    bridgeId: page.bridgeId,
+    name,
+    params,
+    callbacks: extractCallbacks(params)
+  };
+  sendActionOrFail(ap, SIMULATOR_EVENTS.NAV_ACTION, payload, name, params);
+}
+function handleTabActionApi(ap, page, name, params) {
+  const payload = {
+    appSessionId: ap.appSessionId,
+    bridgeId: page.bridgeId,
+    name,
+    params,
+    callbacks: extractCallbacks(params)
+  };
+  sendActionOrFail(ap, SIMULATOR_EVENTS.TAB_ACTION, payload, name, params);
+}
+function handleAppLifecycleToggle(state, ap, name, params) {
   const lifecycleRegister = APP_LIFECYCLE_REGISTER[name];
   if (lifecycleRegister) {
     state.appLifecycle.register(ap.appSessionId, lifecycleRegister, params.success);
-    return;
+    return true;
   }
   const lifecycleUnregister = APP_LIFECYCLE_UNREGISTER[name];
   if (lifecycleUnregister) {
     state.appLifecycle.unregister(ap.appSessionId, lifecycleUnregister, params.success);
+    return true;
+  }
+  return false;
+}
+function handlePageScrollApi(ap, page, params) {
+  const renderWc = page.renderWc;
+  if (renderWc && !renderWc.isDestroyed()) {
+    void renderWc.executeJavaScript(buildPageScrollScript(params)).catch(() => {
+    });
+  }
+  const successResult = { errMsg: "pageScrollTo:ok" };
+  sendCallback(ap, params.success, successResult);
+  sendCallback(ap, params.complete, successResult);
+}
+async function invokeSimulatorApiAndCallback(ap, name, params, invoke) {
+  try {
+    const result = await invoke();
+    sendCallback(ap, params.success, result);
+    sendCallback(ap, params.complete, result);
+  } catch (error) {
+    const failResult = { errMsg: `${name}:fail ${error instanceof Error ? error.message : String(error)}` };
+    sendCallback(ap, params.fail, failResult);
+    sendCallback(ap, params.complete, failResult);
+  }
+}
+async function handleSimulatorApi(state, ap, page, body, ctx) {
+  const name = String(body.name ?? "");
+  const params = normalizeParams(body.params);
+  if (NAV_BAR_API_NAMES.has(name)) {
+    handleNavBarApi(ap, page, name, params);
+    return;
+  }
+  if (NAV_ACTION_NAMES.has(name)) {
+    handleNavActionApi(ap, page, name, params);
     return;
   }
+  if (TAB_ACTION_NAMES.has(name)) {
+    handleTabActionApi(ap, page, name, params);
+    return;
+  }
+  if (handleAppLifecycleToggle(state, ap, name, params)) return;
   if (name === "pageScrollTo") {
-    const renderWc = page.renderWc;
-    if (renderWc && !renderWc.isDestroyed()) {
-      void renderWc.executeJavaScript(buildPageScrollScript(params)).catch(() => {
-      });
-    }
-    const successResult = { errMsg: "pageScrollTo:ok" };
-    sendCallback(ap, params.success, successResult);
-    sendCallback(ap, params.complete, successResult);
+    handlePageScrollApi(ap, page, params);
     return;
   }
   if (ctx.storageApi && STORAGE_API_NAMES.has(name)) {
-    try {
-      const result = await ctx.storageApi.invoke(ap.appId, name, params);
-      sendCallback(ap, params.success, result);
-      sendCallback(ap, params.complete, result);
-    } catch (error) {
-      const failResult = { errMsg: `${name}:fail ${error instanceof Error ? error.message : String(error)}` };
-      sendCallback(ap, params.fail, failResult);
-      sendCallback(ap, params.complete, failResult);
-    }
+    const storageApi = ctx.storageApi;
+    await invokeSimulatorApiAndCallback(ap, name, params, () => storageApi.invoke(ap.appId, name, params));
     return;
   }
   if (ctx.simulatorApis.has(name)) {
-    try {
-      const result = await ctx.simulatorApis.invoke(name, params);
-      sendCallback(ap, params.success, result);
-      sendCallback(ap, params.complete, result);
-    } catch (error) {
-      const failResult = { errMsg: `${name}:fail ${error instanceof Error ? error.message : String(error)}` };
-      sendCallback(ap, params.fail, failResult);
-      sendCallback(ap, params.complete, failResult);
-    }
+    await invokeSimulatorApiAndCallback(ap, name, params, () => ctx.simulatorApis.invoke(name, params));
     return;
   }
   forwardApiCallToSimulator(state, ap, page, name, params);
@@ -7152,20 +7211,14 @@ function disposePageSession(state, ap, page) {
   ap.pages.delete(page.bridgeId);
   state.pageSessions.delete(page.bridgeId);
 }
-async function disposeAppSession(state, appSessionId, opts = {}) {
-  const ap = state.appSessions.get(appSessionId);
-  if (!ap) return;
-  state.appSessions.delete(appSessionId);
-  const registryHandle = ap.registryHandle;
-  ap.registryHandle = null;
-  void registryHandle?.dispose();
-  state.appLifecycle.dispose(appSessionId);
-  state.evictAppDataBridges(ap);
+function drainPendingApiCallsForSession(state, appSessionId) {
   for (const [requestId, pending] of state.pendingApiCalls) {
     if (pending.appSessionId !== appSessionId) continue;
     clearTimeout(pending.timer);
     state.pendingApiCalls.delete(requestId);
   }
+}
+function closeSessionPages(state, ap) {
   for (const page of ap.pages.values()) {
     if (page.renderWc && !page.renderWc.isDestroyed()) {
       state.wcIdToBridgeId.delete(page.renderWc.id);
@@ -7176,8 +7229,8 @@ async function disposeAppSession(state, appSessionId, opts = {}) {
     }
     state.pageSessions.delete(page.bridgeId);
   }
-  ap.pages.clear();
-  ap.listenerBag.dispose();
+}
+async function releaseServiceWindow(state, ap, opts) {
   if (ap.poolEntryId !== null && state.pool && !opts.serviceAlreadyClosed) {
     state.connections.reset(ap.serviceWc.id);
     if (ap.onServiceBoot && !ap.serviceWindow.isDestroyed()) {
@@ -7191,6 +7244,8 @@ async function disposeAppSession(state, appSessionId, opts = {}) {
   } else if (!opts.serviceAlreadyClosed && !ap.serviceWindow.isDestroyed()) {
     ap.serviceWindow.close();
   }
+}
+function unbindSessionFromSharedMaps(state, ap, appSessionId) {
   if (state.serviceWcIdToAppSessionId.get(ap.serviceWc.id) === appSessionId) {
     state.serviceWcIdToAppSessionId.delete(ap.serviceWc.id);
   }
@@ -7199,6 +7254,22 @@ async function disposeAppSession(state, appSessionId, opts = {}) {
     hosted.delete(appSessionId);
     if (hosted.size === 0) state.simulatorWcIdToAppSessionIds.delete(ap.simulatorWc.id);
   }
+}
+async function disposeAppSession(state, appSessionId, opts = {}) {
+  const ap = state.appSessions.get(appSessionId);
+  if (!ap) return;
+  state.appSessions.delete(appSessionId);
+  const registryHandle = ap.registryHandle;
+  ap.registryHandle = null;
+  void registryHandle?.dispose();
+  state.appLifecycle.dispose(appSessionId);
+  state.evictAppDataBridges(ap);
+  drainPendingApiCallsForSession(state, appSessionId);
+  closeSessionPages(state, ap);
+  ap.pages.clear();
+  ap.listenerBag.dispose();
+  await releaseServiceWindow(state, ap, opts);
+  unbindSessionFromSharedMaps(state, ap, appSessionId);
   if (ap.resourceServer) {
     await ap.resourceServer.close().catch((error) => {
       console.warn("[bridge-router] resource server close failed:", error);
@@ -7513,89 +7584,98 @@ appHandlers["App.getPageStack"] = async (ctx) => {
   }
   return { pageStack };
 };
-appHandlers["App.callWxMethod"] = async (ctx, params) => {
-  const method = params.method;
-  const args = params.args || [];
-  if (ctx.bridge?.isNativeHost()) {
-    const serviceWc = ctx.bridge.getServiceWc();
-    if (!serviceWc) throw new Error("Service host not connected");
-    if (NAV_METHODS.has(method) || method === "navigateBack") {
-      const arg = method === "navigateBack" ? args[0] ?? { delta: 1 } : args[0] ?? {};
-      const since = ctx.bridge.getActiveBridgeId();
-      await serviceWc.executeJavaScript(`wx.${method}(${JSON.stringify(arg)})`);
-      const timeoutMs = method === "navigateBack" ? 1500 : 2e3;
-      await waitForActivePage(ctx.bridge, {
-        since,
-        timeoutMs,
-        onTimeout: () => console.warn(`[automation] ${method}: activePage signal not seen within ${timeoutMs}ms \u2014 proceeding on timeout floor`)
-      });
-      return { result: void 0 };
-    }
-    const argsStr2 = args.map((a) => JSON.stringify(a)).join(", ");
-    const result2 = await serviceWc.executeJavaScript(`
-      new Promise((resolve, reject) => {
+async function runNativeHostNav(bridge, serviceWc, method, args) {
+  const arg = method === "navigateBack" ? args[0] ?? { delta: 1 } : args[0] ?? {};
+  const since = bridge.getActiveBridgeId();
+  await serviceWc.executeJavaScript(`wx.${method}(${JSON.stringify(arg)})`);
+  const timeoutMs = method === "navigateBack" ? 1500 : 2e3;
+  await waitForActivePage(bridge, {
+    since,
+    timeoutMs,
+    onTimeout: () => console.warn(`[automation] ${method}: activePage signal not seen within ${timeoutMs}ms \u2014 proceeding on timeout floor`)
+  });
+  return { result: void 0 };
+}
+async function runNativeHostGeneric(serviceWc, method, args) {
+  const argsStr = args.map((a) => JSON.stringify(a)).join(", ");
+  const result = await serviceWc.executeJavaScript(`
+    new Promise((resolve, reject) => {
+      try {
+        if (typeof wx === 'undefined' || typeof wx[${JSON.stringify(method)}] !== 'function') {
+          reject(new Error('wx.' + ${JSON.stringify(method)} + ' is not a function in service host'))
+          return
+        }
+        resolve(wx.${method}(${argsStr}))
+      } catch (e) { reject(e && e.message ? e.message : String(e)) }
+    })
+  `);
+  return { result };
+}
+async function runNativeHostWxMethod(bridge, method, args) {
+  const serviceWc = bridge.getServiceWc();
+  if (!serviceWc) throw new Error("Service host not connected");
+  if (NAV_METHODS.has(method) || method === "navigateBack") {
+    return runNativeHostNav(bridge, serviceWc, method, args);
+  }
+  return runNativeHostGeneric(serviceWc, method, args);
+}
+async function clickNavTarget(ctx, cleanUrl) {
+  return evalInSim(ctx, `(() => {
+    const iframes = Array.from(document.querySelectorAll('iframe'))
+    const visible = iframes.filter((f) => {
+      const cs = window.getComputedStyle(f)
+      if (cs.display === 'none' || cs.visibility === 'hidden') return false
+      const rect = f.getBoundingClientRect()
+      return rect.width > 0 && rect.height > 0
+    })
+    const target = visible[visible.length - 1] || iframes[iframes.length - 1]
+    if (!target || !target.contentDocument) return false
+    const path = ${JSON.stringify(cleanUrl)}
+    const el = Array.from(target.contentDocument.querySelectorAll('[data-path]'))
+      .find((e) => e.getAttribute('data-path') === path)
+    if (el) { el.click(); return true }
+    return false
+  })()`).catch(() => false);
+}
+async function invokeNavViaWx(ctx, method, cleanUrl) {
+  const apiName = JSON.stringify(method);
+  const urlJson = JSON.stringify(cleanUrl);
+  await evalInSim(
+    ctx,
+    `(() => {
+      const iframes = Array.from(document.querySelectorAll('iframe'))
+      for (const f of iframes) {
         try {
-          if (typeof wx === 'undefined' || typeof wx[${JSON.stringify(method)}] !== 'function') {
-            reject(new Error('wx.' + ${JSON.stringify(method)} + ' is not a function in service host'))
+          if (f.contentWindow && f.contentWindow.wx && typeof f.contentWindow.wx[${apiName}] === 'function') {
+            f.contentWindow.wx[${apiName}]({ url: ${urlJson} })
             return
           }
-          resolve(wx.${method}(${argsStr2}))
-        } catch (e) { reject(e && e.message ? e.message : String(e)) }
-      })
-    `);
-    return { result: result2 };
-  }
-  if (["navigateTo", "redirectTo", "reLaunch", "switchTab"].includes(method)) {
-    const opts = args[0];
-    const url = opts?.url;
-    if (url) {
-      const cleanUrl = url.startsWith("/") ? url : `/${url}`;
-      const clicked = await evalInSim(ctx, `(() => {
-        const iframes = Array.from(document.querySelectorAll('iframe'))
-        const visible = iframes.filter((f) => {
-          const cs = window.getComputedStyle(f)
-          if (cs.display === 'none' || cs.visibility === 'hidden') return false
-          const rect = f.getBoundingClientRect()
-          return rect.width > 0 && rect.height > 0
-        })
-        const target = visible[visible.length - 1] || iframes[iframes.length - 1]
-        if (!target || !target.contentDocument) return false
-        const path = ${JSON.stringify(cleanUrl)}
-        const el = Array.from(target.contentDocument.querySelectorAll('[data-path]'))
-          .find((e) => e.getAttribute('data-path') === path)
-        if (el) { el.click(); return true }
-        return false
-      })()`).catch(() => false);
-      if (!clicked) {
-        const apiName = JSON.stringify(method);
-        const urlJson = JSON.stringify(cleanUrl);
-        await evalInSim(
-          ctx,
-          `(() => {
-            const iframes = Array.from(document.querySelectorAll('iframe'))
-            for (const f of iframes) {
-              try {
-                if (f.contentWindow && f.contentWindow.wx && typeof f.contentWindow.wx[${apiName}] === 'function') {
-                  f.contentWindow.wx[${apiName}]({ url: ${urlJson} })
-                  return
-                }
-              } catch (_) {}
-            }
-            if (typeof wx !== 'undefined' && wx && typeof wx[${apiName}] === 'function') {
-              wx[${apiName}]({ url: ${urlJson} })
-            }
-          })()`
-        );
+        } catch (_) {}
       }
-      await new Promise((r) => setTimeout(r, 2e3));
-    }
-    return { result: void 0 };
-  }
-  if (method === "navigateBack") {
-    await evalInSim(ctx, "history.back()");
-    await new Promise((r) => setTimeout(r, 1500));
-    return { result: void 0 };
+      if (typeof wx !== 'undefined' && wx && typeof wx[${apiName}] === 'function') {
+        wx[${apiName}]({ url: ${urlJson} })
+      }
+    })()`
+  );
+}
+async function runSimulatorNav(ctx, method, args) {
+  const opts = args[0];
+  const url = opts?.url;
+  if (!url) return { result: void 0 };
+  const cleanUrl = url.startsWith("/") ? url : `/${url}`;
+  const clicked = await clickNavTarget(ctx, cleanUrl);
+  if (!clicked) {
+    await invokeNavViaWx(ctx, method, cleanUrl);
   }
+  await new Promise((r) => setTimeout(r, 2e3));
+  return { result: void 0 };
+}
+async function runSimulatorNavigateBack(ctx) {
+  await evalInSim(ctx, "history.back()");
+  await new Promise((r) => setTimeout(r, 1500));
+  return { result: void 0 };
+}
+async function runSimulatorGeneric(ctx, method, args) {
   const argsStr = args.map((a) => JSON.stringify(a)).join(", ");
   const result = await evalInSim(ctx, `
     new Promise((resolve, reject) => {
@@ -7608,6 +7688,21 @@ appHandlers["App.callWxMethod"] = async (ctx, params) => {
     })
   `);
   return { result };
+}
+appHandlers["App.callWxMethod"] = async (ctx, params) => {
+  const method = params.method;
+  const args = params.args || [];
+  const bridge = ctx.bridge;
+  if (bridge?.isNativeHost()) {
+    return runNativeHostWxMethod(bridge, method, args);
+  }
+  if (NAV_METHODS.has(method)) {
+    return runSimulatorNav(ctx, method, args);
+  }
+  if (method === "navigateBack") {
+    return runSimulatorNavigateBack(ctx);
+  }
+  return runSimulatorGeneric(ctx, method, args);
 };
 appHandlers["App.callFunction"] = async (ctx, params) => {
   const fnDecl = params.functionDeclaration;
@@ -7870,7 +7965,7 @@ async function startAutomationServer(ctx, port = 0) {
   const clients = /* @__PURE__ */ new Set();
   await new Promise((resolve, reject) => {
     wss.once("listening", () => resolve());
-    wss.once("error", (err) => reject(err));
+    wss.once("error", (err2) => reject(err2));
   });
   const addr = wss.address();
   const resolvedPort = typeof addr === "object" && addr ? addr.port : port;
@@ -7975,8 +8070,8 @@ async function startAutomationServer(ctx, port = 0) {
         try {
           const result = await handler(ctx, params);
           response = { id, result };
-        } catch (err) {
-          response = { id, error: { message: err.message || String(err) } };
+        } catch (err2) {
+          response = { id, error: { message: err2.message || String(err2) } };
         }
       }
       if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(response));
@@ -8513,6 +8608,96 @@ function registerContextTools(server) {
 
 // src/main/services/mcp/tools/simulator-tools.ts
 import { z as z5 } from "zod";
+function ok(text) {
+  return { content: [{ type: "text", text }] };
+}
+function err(msg) {
+  return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
+}
+async function clickAt(c, x, y) {
+  await c.Input.dispatchMouseEvent({ type: "mousePressed", x, y, button: "left", clickCount: 1 });
+  await c.Input.dispatchMouseEvent({ type: "mouseReleased", x, y, button: "left", clickCount: 1 });
+}
+async function tapCoord(c, x, y) {
+  if (typeof x !== "number" || typeof y !== "number") return err("tap_coord requires x and y");
+  await clickAt(c, x, y);
+  return ok(`Tapped at (${x}, ${y})`);
+}
+function buildTapSelectorExpression(selector, index) {
+  return `(() => {
+    const payload = ${JSON.stringify({ selector, index })}
+    try {
+      const matches = Array.from(document.querySelectorAll(payload.selector))
+      if (matches.length === 0) {
+        return { ok: false, reason: 'no_match', message: \`selector matched no elements: \${payload.selector}\` }
+      }
+      if (payload.index < 0 || payload.index >= matches.length) {
+        return { ok: false, reason: 'out_of_range', message: \`nth \${payload.index} out of range (matches: \${matches.length})\` }
+      }
+      const element = matches[payload.index]
+      element.scrollIntoView({ block: 'center', inline: 'center' })
+      const rect = element.getBoundingClientRect()
+      if (rect.width === 0 || rect.height === 0) {
+        return { ok: false, reason: 'not_visible', message: \`selector matched an element, but it is not visible or rendered (zero rect): \${payload.selector}[\${payload.index}]\` }
+      }
+      return {
+        ok: true,
+        selector: payload.selector,
+        index: payload.index,
+        x: rect.left + rect.width / 2,
+        y: rect.top + rect.height / 2,
+        rect: { left: rect.left, top: rect.top, width: rect.width, height: rect.height },
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      return { ok: false, reason: 'selector_error', message: \`invalid selector: \${payload.selector} (\${message})\` }
+    }
+  })()`;
+}
+async function tapSelector(c, selector, nth) {
+  if (!selector) return err("tap_selector requires selector");
+  const index = nth ?? 0;
+  const expression = buildTapSelectorExpression(selector, index);
+  const result = await c.Runtime.evaluate({ expression, returnByValue: true, awaitPromise: true });
+  const value = result.result?.value;
+  if (!value) return err(`selector evaluation returned no result: ${selector}[${index}]`);
+  if (!value.ok) return err(value.message);
+  await clickAt(c, value.x, value.y);
+  return ok(`Tapped selector ${value.selector}[${value.index}] at (${value.x}, ${value.y}) within rect (${value.rect.left}, ${value.rect.top}, ${value.rect.width} x ${value.rect.height})`);
+}
+async function typeText(c, selector, nth, text) {
+  if (!selector || typeof text !== "string") return err("type requires selector and text");
+  const { root } = await c.DOM.getDocument({ depth: 0 });
+  const { nodeIds } = await c.DOM.querySelectorAll({ nodeId: root.nodeId, selector });
+  if (!nodeIds || nodeIds.length === 0) return err(`selector matched no elements: ${selector}`);
+  const index = nth ?? 0;
+  if (index < 0 || index >= nodeIds.length) return err(`nth ${index} out of range (matches: ${nodeIds.length})`);
+  await c.DOM.focus({ nodeId: nodeIds[index] });
+  try {
+    await c.Input.insertText({ text });
+  } catch {
+    for (const ch of text) {
+      await c.Input.dispatchKeyEvent({ type: "char", text: ch });
+    }
+  }
+  return ok(`Typed ${text.length} char(s) into ${selector}[${index}]`);
+}
+async function scrollAt(c, x, y, deltaX, deltaY) {
+  if (typeof x !== "number" || typeof y !== "number" || typeof deltaX !== "number" || typeof deltaY !== "number") {
+    return err("scroll requires x, y, deltaX, deltaY");
+  }
+  await c.Input.dispatchMouseEvent({ type: "mouseWheel", x, y, deltaX, deltaY });
+  return ok(`Scrolled at (${x}, ${y}) by (${deltaX}, ${deltaY})`);
+}
+async function dispatchKey(c, key) {
+  if (!key) return err("key requires key");
+  const isSingleChar = key.length === 1;
+  const down = { type: "keyDown", key, code: key };
+  if (isSingleChar) down.text = key;
+  await c.Input.dispatchKeyEvent(down);
+  await c.Input.dispatchKeyEvent({ type: "keyUp", key, code: key });
+  return ok(`Dispatched key ${key}`);
+}
 function registerSimulatorTools(server) {
   server.tool("simulator_navigate", "Navigate the simulator to a URL, or reload the current page", {
     url: z5.string().optional().describe("URL to navigate to"),
@@ -8542,94 +8727,20 @@ function registerSimulatorTools(server) {
     deltaY: z5.number().optional().describe("Vertical wheel delta for `scroll`")
   }, async ({ action, x, y, selector, nth, text, key, deltaX, deltaY }) => {
     const c = getClient("simulator");
-    const err = (msg) => ({ content: [{ type: "text", text: `Error: ${msg}` }], isError: true });
-    const clickAt = async (cx, cy) => {
-      await c.Input.dispatchMouseEvent({ type: "mousePressed", x: cx, y: cy, button: "left", clickCount: 1 });
-      await c.Input.dispatchMouseEvent({ type: "mouseReleased", x: cx, y: cy, button: "left", clickCount: 1 });
-    };
-    if (action === "tap_coord") {
-      if (typeof x !== "number" || typeof y !== "number") return err("tap_coord requires x and y");
-      await clickAt(x, y);
-      return { content: [{ type: "text", text: `Tapped at (${x}, ${y})` }] };
-    }
-    if (action === "tap_selector") {
-      if (!selector) return err("tap_selector requires selector");
-      const index = nth ?? 0;
-      const expression = `(() => {
-        const payload = ${JSON.stringify({ selector, index })}
-        try {
-          const matches = Array.from(document.querySelectorAll(payload.selector))
-          if (matches.length === 0) {
-            return { ok: false, reason: 'no_match', message: \`selector matched no elements: \${payload.selector}\` }
-          }
-          if (payload.index < 0 || payload.index >= matches.length) {
-            return { ok: false, reason: 'out_of_range', message: \`nth \${payload.index} out of range (matches: \${matches.length})\` }
-          }
-          const element = matches[payload.index]
-          element.scrollIntoView({ block: 'center', inline: 'center' })
-          const rect = element.getBoundingClientRect()
-          if (rect.width === 0 || rect.height === 0) {
-            return { ok: false, reason: 'not_visible', message: \`selector matched an element, but it is not visible or rendered (zero rect): \${payload.selector}[\${payload.index}]\` }
-          }
-          return {
-            ok: true,
-            selector: payload.selector,
-            index: payload.index,
-            x: rect.left + rect.width / 2,
-            y: rect.top + rect.height / 2,
-            rect: { left: rect.left, top: rect.top, width: rect.width, height: rect.height },
-          }
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error)
-          return { ok: false, reason: 'selector_error', message: \`invalid selector: \${payload.selector} (\${message})\` }
-        }
-      })()`;
-      const result = await c.Runtime.evaluate({ expression, returnByValue: true, awaitPromise: true });
-      const value = result.result?.value;
-      if (!value) return err(`selector evaluation returned no result: ${selector}[${index}]`);
-      if (!value.ok) return err(value.message);
-      await clickAt(value.x, value.y);
-      return {
-        content: [{
-          type: "text",
-          text: `Tapped selector ${value.selector}[${value.index}] at (${value.x}, ${value.y}) within rect (${value.rect.left}, ${value.rect.top}, ${value.rect.width} x ${value.rect.height})`
-        }]
-      };
-    }
-    if (action === "type") {
-      if (!selector || typeof text !== "string") return err("type requires selector and text");
-      const { root } = await c.DOM.getDocument({ depth: 0 });
-      const { nodeIds } = await c.DOM.querySelectorAll({ nodeId: root.nodeId, selector });
-      if (!nodeIds || nodeIds.length === 0) return err(`selector matched no elements: ${selector}`);
-      const index = nth ?? 0;
-      if (index < 0 || index >= nodeIds.length) return err(`nth ${index} out of range (matches: ${nodeIds.length})`);
-      await c.DOM.focus({ nodeId: nodeIds[index] });
-      try {
-        await c.Input.insertText({ text });
-      } catch {
-        for (const ch of text) {
-          await c.Input.dispatchKeyEvent({ type: "char", text: ch });
-        }
-      }
-      return { content: [{ type: "text", text: `Typed ${text.length} char(s) into ${selector}[${index}]` }] };
-    }
-    if (action === "scroll") {
-      if (typeof x !== "number" || typeof y !== "number" || typeof deltaX !== "number" || typeof deltaY !== "number") {
-        return err("scroll requires x, y, deltaX, deltaY");
-      }
-      await c.Input.dispatchMouseEvent({ type: "mouseWheel", x, y, deltaX, deltaY });
-      return { content: [{ type: "text", text: `Scrolled at (${x}, ${y}) by (${deltaX}, ${deltaY})` }] };
-    }
-    if (action === "key") {
-      if (!key) return err("key requires key");
-      const isSingleChar = key.length === 1;
-      const down = { type: "keyDown", key, code: key };
-      if (isSingleChar) down.text = key;
-      await c.Input.dispatchKeyEvent(down);
-      await c.Input.dispatchKeyEvent({ type: "keyUp", key, code: key });
-      return { content: [{ type: "text", text: `Dispatched key ${key}` }] };
+    switch (action) {
+      case "tap_coord":
+        return tapCoord(c, x, y);
+      case "tap_selector":
+        return tapSelector(c, selector, nth);
+      case "type":
+        return typeText(c, selector, nth, text);
+      case "scroll":
+        return scrollAt(c, x, y, deltaX, deltaY);
+      case "key":
+        return dispatchKey(c, key);
+      default:
+        return err(`unknown action: ${String(action)}`);
     }
-    return err(`unknown action: ${action}`);
   });
 }
 
@@ -8684,13 +8795,13 @@ function startMcpServer(resolvedCdpPort, mcpPort) {
       res.writeHead(404).end();
     }
   });
-  httpServer.on("error", (err) => {
-    if (err.code === "EADDRINUSE") {
+  httpServer.on("error", (err2) => {
+    if (err2.code === "EADDRINUSE") {
       console.warn(`[MCP] Port ${mcpPort} already in use \u2014 MCP server not started`);
       recordMcpFailed("port-in-use");
     } else {
-      console.error("[MCP] Server error:", err);
-      recordMcpFailed(err.message);
+      console.error("[MCP] Server error:", err2);
+      recordMcpFailed(err2.message);
     }
   });
   httpServer.listen(mcpPort, "127.0.0.1", () => {
@@ -8706,6 +8817,28 @@ function startMcpServer(resolvedCdpPort, mcpPort) {
 
 // src/main/services/network-forward/index.ts
 import { DisposableRegistry as DisposableRegistry7, toDisposable as toDisposable5 } from "@dimina-kit/electron-deck/main";
+
+// src/main/services/network-forward/dispatch-batch.ts
+function packDispatchBatch(queue, maxSingleChars, maxBatchChars) {
+  const batch = [];
+  const chunked = [];
+  let batchChars = 0;
+  let i = 0;
+  for (; i < queue.length; i++) {
+    const msg = queue[i];
+    if (msg.length > maxSingleChars) {
+      if (batch.length > 0) break;
+      chunked.push(msg);
+      continue;
+    }
+    if (batch.length > 0 && batchChars + msg.length > maxBatchChars) break;
+    batch.push(msg);
+    batchChars += msg.length;
+  }
+  return { batch, chunked, remaining: queue.slice(i) };
+}
+
+// src/main/services/network-forward/index.ts
 var REWRITE_REQUEST_ID_METHODS = /* @__PURE__ */ new Set([
   "Network.requestWillBeSent",
   "Network.requestWillBeSentExtraInfo",
@@ -8922,21 +9055,8 @@ function createNetworkForwarder(bridge) {
       return;
     }
     if (sink === "idle") beginProbing();
-    const batch = [];
-    let batchChars = 0;
-    let i = 0;
-    for (; i < dispatchQueue.length; i++) {
-      const msg = dispatchQueue[i];
-      if (msg.length > MAX_SINGLE_DISPATCH_CHARS2) {
-        if (batch.length > 0) break;
-        dispatchChunked(wc, msg);
-        continue;
-      }
-      if (batch.length > 0 && batchChars + msg.length > MAX_BATCH_CHARS) break;
-      batch.push(msg);
-      batchChars += msg.length;
-    }
-    const remaining = dispatchQueue.slice(i);
+    const { batch, chunked, remaining } = packDispatchBatch(dispatchQueue, MAX_SINGLE_DISPATCH_CHARS2, MAX_BATCH_CHARS);
+    for (const msg of chunked) dispatchChunked(wc, msg);
     if (batch.length === 0) {
       dispatchQueue = remaining;
       if (dispatchQueue.length > 0) scheduleFlush();
@@ -8952,8 +9072,8 @@ function createNetworkForwarder(bridge) {
     }
     dispatchQueue = remaining;
     if (remaining.length > 0) scheduleFlush();
-    wc.executeJavaScript(script, true).then((ok) => {
-      if (ok === true) {
+    wc.executeJavaScript(script, true).then((ok2) => {
+      if (ok2 === true) {
         if (sink !== "ready") markReady();
         return;
       }
@@ -9048,8 +9168,8 @@ function createNetworkForwarder(bridge) {
       if (!wc.debugger.isAttached()) {
         wc.debugger.attach("1.3");
       }
-    } catch (err) {
-      console.warn("[network-forward] debugger.attach failed; simulator network not captured:", err instanceof Error ? err.message : err);
+    } catch (err2) {
+      console.warn("[network-forward] debugger.attach failed; simulator network not captured:", err2 instanceof Error ? err2.message : err2);
       return;
     }
     simWc = wc;
@@ -9145,8 +9265,8 @@ function createNetworkForwarder(bridge) {
         }
       });
     }
-    void wc.debugger.sendCommand("Network.enable").catch((err) => {
-      console.warn("[network-forward] Network.enable failed:", err instanceof Error ? err.message : err);
+    void wc.debugger.sendCommand("Network.enable").catch((err2) => {
+      console.warn("[network-forward] Network.enable failed:", err2 instanceof Error ? err2.message : err2);
     });
   }
   function maybeFallback(record) {
@@ -9316,41 +9436,46 @@ function setupSimulatorWxml(host, options) {
 }
 
 // src/shared/appdata-accumulator.ts
-function decodeWorkerMessage(message) {
-  let payload = message;
-  if (typeof payload === "string") {
-    try {
-      payload = JSON.parse(payload);
-    } catch {
-      return null;
-    }
+function parseMessagePayload(message) {
+  if (typeof message !== "string") return message;
+  try {
+    return JSON.parse(message);
+  } catch {
+    return null;
   }
+}
+function decodeUpdateBatchBody(rawBody) {
+  const body = rawBody;
+  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;
+}
+function decodePageInitBody(moduleId, rawBody) {
+  const body = rawBody;
+  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,
+    componentPath: body.path,
+    data: body.data
+  }];
+}
+function decodeWorkerMessage(message) {
+  const payload = parseMessagePayload(message);
   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 (record.type === "ub") return decodeUpdateBatchBody(record.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 decodePageInitBody(record.type, record.body);
   }
   return null;
 }
@@ -9804,38 +9929,51 @@ var EXT_MIME = {
   ".pdf": "application/pdf",
   ".zip": "application/zip"
 };
+function isPng(head) {
+  return head.length >= 8 && head[0] === 137 && head[1] === 80 && head[2] === 78 && head[3] === 71 && head[4] === 13 && head[5] === 10 && head[6] === 26 && head[7] === 10;
+}
+function isJpeg(head) {
+  return head.length >= 3 && head[0] === 255 && head[1] === 216 && head[2] === 255;
+}
+function isGif(head) {
+  return head.length >= 6 && head[0] === 71 && head[1] === 73 && head[2] === 70 && head[3] === 56 && (head[4] === 55 || head[4] === 57) && head[5] === 97;
+}
+function isWebp(head) {
+  return head.length >= 12 && head[0] === 82 && head[1] === 73 && head[2] === 70 && head[3] === 70 && head[8] === 87 && head[9] === 69 && head[10] === 66 && head[11] === 80;
+}
+function isMp4(head) {
+  return head.length >= 12 && head[4] === 102 && head[5] === 116 && head[6] === 121 && head[7] === 112;
+}
+function isPdf(head) {
+  return head.length >= 4 && head[0] === 37 && head[1] === 80 && head[2] === 68 && head[3] === 70;
+}
+function isBmp(head) {
+  return head.length >= 2 && head[0] === 66 && head[1] === 77;
+}
+function isZip(head) {
+  return head.length >= 4 && head[0] === 80 && head[1] === 75 && head[2] === 3 && head[3] === 4;
+}
+function isId3Mp3(head) {
+  return head.length >= 3 && head[0] === 73 && head[1] === 68 && head[2] === 51;
+}
+function isOgg(head) {
+  return head.length >= 4 && head[0] === 79 && head[1] === 103 && head[2] === 103 && head[3] === 83;
+}
+var MAGIC_SNIFFERS = [
+  { mime: "image/png", match: isPng },
+  { mime: "image/jpeg", match: isJpeg },
+  { mime: "image/gif", match: isGif },
+  { mime: "image/webp", match: isWebp },
+  { mime: "video/mp4", match: isMp4 },
+  { mime: "application/pdf", match: isPdf },
+  { mime: "image/bmp", match: isBmp },
+  { mime: "application/zip", match: isZip },
+  { mime: "audio/mpeg", match: isId3Mp3 },
+  { mime: "audio/ogg", match: isOgg }
+];
 function sniffMime(head) {
-  if (head.length >= 8 && head[0] === 137 && head[1] === 80 && head[2] === 78 && head[3] === 71 && head[4] === 13 && head[5] === 10 && head[6] === 26 && head[7] === 10) {
-    return "image/png";
-  }
-  if (head.length >= 3 && head[0] === 255 && head[1] === 216 && head[2] === 255) {
-    return "image/jpeg";
-  }
-  if (head.length >= 6 && head[0] === 71 && head[1] === 73 && head[2] === 70 && head[3] === 56 && (head[4] === 55 || head[4] === 57) && head[5] === 97) {
-    return "image/gif";
-  }
-  if (head.length >= 12 && head[0] === 82 && head[1] === 73 && head[2] === 70 && head[3] === 70 && head[8] === 87 && head[9] === 69 && head[10] === 66 && head[11] === 80) {
-    return "image/webp";
-  }
-  if (head.length >= 12 && head[4] === 102 && head[5] === 116 && head[6] === 121 && head[7] === 112) {
-    return "video/mp4";
-  }
-  if (head.length >= 4 && head[0] === 37 && head[1] === 80 && head[2] === 68 && head[3] === 70) {
-    return "application/pdf";
-  }
-  if (head.length >= 2 && head[0] === 66 && head[1] === 77) {
-    return "image/bmp";
-  }
-  if (head.length >= 4 && head[0] === 80 && head[1] === 75 && head[2] === 3 && head[3] === 4) {
-    return "application/zip";
-  }
-  if (head.length >= 3 && head[0] === 73 && head[1] === 68 && head[2] === 51) {
-    return "audio/mpeg";
-  }
-  if (head.length >= 4 && head[0] === 79 && head[1] === 103 && head[2] === 103 && head[3] === 83) {
-    return "audio/ogg";
-  }
-  return null;
+  const hit = MAGIC_SNIFFERS.find((sniffer) => sniffer.match(head));
+  return hit ? hit.mime : null;
 }
 function extMime(realPath) {
   const ext = path20.extname(realPath).toLowerCase();
@@ -9852,6 +9990,44 @@ function detectMime(realPath, head) {
 function etagOf(mtimeMs, size) {
   return `W/"${Math.floor(mtimeMs)}-${size}"`;
 }
+function resolveRange(range, totalSize) {
+  const { start, end } = range;
+  if (!Number.isFinite(start) || !Number.isFinite(end)) {
+    throw new RangeError(`invalid range: ${start}-${end}`);
+  }
+  if (start < 0) throw new RangeError(`range start out of bounds: ${start}`);
+  if (start > end) throw new RangeError(`range start > end: ${start} > ${end}`);
+  if (start >= totalSize) {
+    throw new RangeError(`range start beyond file size: ${start} >= ${totalSize}`);
+  }
+  const clampedEnd = Math.min(end, totalSize - 1);
+  return { sliceStart: start, sliceLen: clampedEnd - start + 1 };
+}
+async function readHeadBytes(handle, totalSize) {
+  const head = Buffer.alloc(Math.min(12, totalSize));
+  if (head.length > 0) {
+    await handle.read(head, 0, head.length, 0);
+  }
+  return head;
+}
+async function readFullBody(handle, head, totalSize) {
+  const bytes = Buffer.alloc(totalSize);
+  if (totalSize === 0) return bytes;
+  if (totalSize <= head.length) {
+    head.copy(bytes, 0, 0, totalSize);
+    return bytes;
+  }
+  head.copy(bytes, 0, 0, head.length);
+  await handle.read(bytes, head.length, totalSize - head.length, head.length);
+  return bytes;
+}
+async function readRangeBody(handle, sliceStart, sliceLen) {
+  const bytes = Buffer.alloc(sliceLen);
+  if (sliceLen > 0) {
+    await handle.read(bytes, 0, sliceLen, sliceStart);
+  }
+  return bytes;
+}
 async function readDiskFile(realPath, opts) {
   const handle = await fs9.open(realPath, "r");
   try {
@@ -9859,43 +10035,9 @@ async function readDiskFile(realPath, opts) {
     const totalSize = st.size;
     const mtimeMs = st.mtimeMs;
     const range = opts?.range;
-    let sliceStart = 0;
-    let sliceLen = totalSize;
-    if (range) {
-      const { start, end } = range;
-      if (!Number.isFinite(start) || !Number.isFinite(end)) {
-        throw new RangeError(`invalid range: ${start}-${end}`);
-      }
-      if (start < 0) throw new RangeError(`range start out of bounds: ${start}`);
-      if (start > end) throw new RangeError(`range start > end: ${start} > ${end}`);
-      if (start >= totalSize) {
-        throw new RangeError(`range start beyond file size: ${start} >= ${totalSize}`);
-      }
-      const clampedEnd = Math.min(end, totalSize - 1);
-      sliceStart = start;
-      sliceLen = clampedEnd - start + 1;
-    }
-    const head = Buffer.alloc(Math.min(12, totalSize));
-    if (head.length > 0) {
-      await handle.read(head, 0, head.length, 0);
-    }
-    let bytes;
-    if (!range) {
-      bytes = Buffer.alloc(totalSize);
-      if (totalSize > 0) {
-        if (totalSize <= head.length) {
-          head.copy(bytes, 0, 0, totalSize);
-        } else {
-          head.copy(bytes, 0, 0, head.length);
-          await handle.read(bytes, head.length, totalSize - head.length, head.length);
-        }
-      }
-    } else {
-      bytes = Buffer.alloc(sliceLen);
-      if (sliceLen > 0) {
-        await handle.read(bytes, 0, sliceLen, sliceStart);
-      }
-    }
+    const { sliceStart, sliceLen } = range ? resolveRange(range, totalSize) : { sliceStart: 0, sliceLen: totalSize };
+    const head = await readHeadBytes(handle, totalSize);
+    const bytes = range ? await readRangeBody(handle, sliceStart, sliceLen) : await readFullBody(handle, head, totalSize);
     return {
       bytes,
       mime: detectMime(realPath, head),
@@ -10069,12 +10211,12 @@ async function enforceSandbox(realPath) {
         throw new Error("sandbox: realPath escapes the user-data base via symlink");
       }
       break;
-    } catch (err) {
-      if (err.code === "ENOENT") {
+    } catch (err2) {
+      if (err2.code === "ENOENT") {
         probe = path21.dirname(probe);
         continue;
       }
-      throw err;
+      throw err2;
     }
   }
   return normalized;
@@ -10330,8 +10472,8 @@ function serveStaticFile(res, root, pathname) {
       res.end("Forbidden");
       return;
     }
-    nodeFs2.stat(realFile, (err, stat) => {
-      if (err || !stat.isFile()) {
+    nodeFs2.stat(realFile, (err2, stat) => {
+      if (err2 || !stat.isFile()) {
         res.writeHead(404);
         res.end("Not Found");
         return;
@@ -10412,6 +10554,56 @@ function fsErrorStatus(e) {
   if (code === "ENOENT") return 404;
   return 500;
 }
+async function fsStat(ctx) {
+  const st = await statWithin(ctx.projectRoot, ctx.rel);
+  jsonRes(ctx.res, 200, { type: st.isDirectory() ? 2 : 1, size: st.size, ctime: st.ctimeMs, mtime: st.mtimeMs });
+}
+async function fsReaddir(ctx) {
+  const entries = await readdirWithin(ctx.projectRoot, ctx.rel);
+  jsonRes(ctx.res, 200, entries.map((e) => [e.name, e.isDirectory() ? 2 : 1]));
+}
+async function fsRead(ctx) {
+  const buf = await readFileBufferWithin(ctx.projectRoot, ctx.rel);
+  ctx.res.writeHead(200, { "Content-Type": "application/octet-stream", "Content-Length": buf.length });
+  ctx.res.end(buf);
+}
+async function fsWrite(ctx) {
+  let buf;
+  try {
+    buf = await readBody(ctx.req);
+  } catch (e) {
+    if (e instanceof BodyTooLargeError) return jsonRes(ctx.res, 413, { error: e.message });
+    throw e;
+  }
+  await writeFileWithin(ctx.projectRoot, ctx.rel, buf);
+  ctx.res.writeHead(204);
+  ctx.res.end();
+}
+async function fsMkdir(ctx) {
+  await mkdirWithin(ctx.projectRoot, ctx.rel);
+  ctx.res.writeHead(204);
+  ctx.res.end();
+}
+async function fsDelete(ctx) {
+  await deleteWithin(ctx.projectRoot, ctx.rel);
+  ctx.res.writeHead(204);
+  ctx.res.end();
+}
+async function fsRename(ctx) {
+  const toRel = (ctx.url.searchParams.get("to") ?? "").replace(/^\/+/, "");
+  await renameWithin(ctx.projectRoot, ctx.rel, toRel);
+  ctx.res.writeHead(204);
+  ctx.res.end();
+}
+var FS_ACTIONS = {
+  stat: fsStat,
+  readdir: fsReaddir,
+  read: fsRead,
+  write: fsWrite,
+  mkdir: fsMkdir,
+  delete: fsDelete,
+  rename: fsRename
+};
 async function handleFsRequest(req, res, projectRoot, url) {
   const action = url.pathname.slice("/__fs/".length);
   const rel = (url.searchParams.get("p") ?? "").replace(/^\/+/, "") || ".";
@@ -10421,51 +10613,12 @@ async function handleFsRequest(req, res, projectRoot, url) {
       return jsonRes(res, rejectStatus, { error: "mutating fs action requires a non-GET same-origin request" });
     }
   }
+  const handler = FS_ACTIONS[action];
+  if (!handler) return jsonRes(res, 404, { error: "unknown fs action: " + action });
   try {
-    if (action === "stat") {
-      const st = await statWithin(projectRoot, rel);
-      return jsonRes(res, 200, { type: st.isDirectory() ? 2 : 1, size: st.size, ctime: st.ctimeMs, mtime: st.mtimeMs });
-    }
-    if (action === "readdir") {
-      const entries = await readdirWithin(projectRoot, rel);
-      return jsonRes(res, 200, entries.map((e) => [e.name, e.isDirectory() ? 2 : 1]));
-    }
-    if (action === "read") {
-      const buf = await readFileBufferWithin(projectRoot, rel);
-      res.writeHead(200, { "Content-Type": "application/octet-stream", "Content-Length": buf.length });
-      return void res.end(buf);
-    }
-    if (action === "write") {
-      let buf;
-      try {
-        buf = await readBody(req);
-      } catch (e) {
-        if (e instanceof BodyTooLargeError) return jsonRes(res, 413, { error: e.message });
-        throw e;
-      }
-      await writeFileWithin(projectRoot, rel, buf);
-      res.writeHead(204);
-      return void res.end();
-    }
-    if (action === "mkdir") {
-      await mkdirWithin(projectRoot, rel);
-      res.writeHead(204);
-      return void res.end();
-    }
-    if (action === "delete") {
-      await deleteWithin(projectRoot, rel);
-      res.writeHead(204);
-      return void res.end();
-    }
-    if (action === "rename") {
-      const toRel = (url.searchParams.get("to") ?? "").replace(/^\/+/, "");
-      await renameWithin(projectRoot, rel, toRel);
-      res.writeHead(204);
-      return void res.end();
-    }
-    return jsonRes(res, 404, { error: "unknown fs action: " + action });
+    await handler({ req, res, projectRoot, rel, url });
   } catch (e) {
-    return jsonRes(res, fsErrorStatus(e), { error: String(e.message), code: e.code });
+    jsonRes(res, fsErrorStatus(e), { error: String(e.message), code: e.code });
   }
 }
 async function listFilesRecursive(dir, base = "") {
@@ -10598,8 +10751,8 @@ var UpdateManager = class {
         return { hasUpdate: true, info };
       }
       return { hasUpdate: false };
-    } catch (err) {
-      console.warn("[UpdateManager] check failed:", err);
+    } catch (err2) {
+      console.warn("[UpdateManager] check failed:", err2);
       return { hasUpdate: false };
     }
   }
@@ -10613,9 +10766,9 @@ var UpdateManager = class {
       });
       this.downloadedPath = filePath;
       return { success: true, filePath };
-    } catch (err) {
-      console.warn("[UpdateManager] download failed:", err);
-      return { success: false, error: String(err) };
+    } catch (err2) {
+      console.warn("[UpdateManager] download failed:", err2);
+      return { success: false, error: String(err2) };
     }
   }
   install() {
@@ -10719,8 +10872,8 @@ function resolveModules(config) {
 }
 async function disposeContext(ctx) {
   await ctx.workspace.closeProject();
-  await ctx.registry.dispose().catch((err) => {
-    console.warn("[workbench] dispose registry encountered errors:", err);
+  await ctx.registry.dispose().catch((err2) => {
+    console.warn("[workbench] dispose registry encountered errors:", err2);
   });
 }
 function createConfiguredMainWindow(config, rendererDir2) {
@@ -10936,27 +11089,10 @@ async function createDevtoolsRuntime(config = {}) {
         appDataKeys: []
       };
       if (appId) {
-        try {
-          const info = await context.storageApi?.invoke(appId, "getStorageInfo", {});
-          if (info && typeof info === "object") {
-            const keys = info.keys;
-            if (Array.isArray(keys)) {
-              overview.storageKeys = keys.filter((key) => typeof key === "string");
-              overview.storageCount = keys.length;
-            }
-          }
-        } catch {
-        }
-        try {
-          const snapshot = context.appData?.snapshot?.(appId);
-          if (snapshot && typeof snapshot === "object") {
-            const entries = snapshot.entries;
-            if (entries && typeof entries === "object") {
-              overview.appDataKeys = Object.keys(entries);
-            }
-          }
-        } catch {
-        }
+        const storage2 = await resolveNativeStorageOverview(context, appId);
+        overview.storageKeys = storage2.storageKeys;
+        overview.storageCount = storage2.storageCount;
+        overview.appDataKeys = resolveNativeAppDataKeys(context, appId);
       }
       return overview;
     });
@@ -11084,7 +11220,7 @@ function launch(config = {}) {
 }
 
 // src/main/index.ts
-launch().catch((err) => {
-  console.error("[devtools] fatal: launch() failed during boot", err);
+launch().catch((err2) => {
+  console.error("[devtools] fatal: launch() failed during boot", err2);
   app16.exit(1);
 });