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

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) => {
@@ -428,6 +393,9 @@ var ProjectChannel = {
   CaptureThumbnail: "project:captureThumbnail",
   GetThumbnail: "project:getThumbnail"
 };
+var SessionChannel = {
+  RuntimeStatus: "session:runtimeStatus"
+};
 var ProjectFsChannel = {
   GetRoot: "project:fs:getRoot",
   ReadFile: "project:fs:readFile",
@@ -555,9 +523,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 +568,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 +616,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 +682,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 +701,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 +722,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 +768,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 +794,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 +1024,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,
@@ -1103,6 +1108,9 @@ function createRendererNotifier(ctx) {
     projectStatus(payload) {
       sendToMain(ProjectChannel.Status, payload);
     },
+    sessionRuntimeStatus(payload) {
+      sendToMain(SessionChannel.RuntimeStatus, payload);
+    },
     compileLog(payload) {
       sendToMain(ProjectChannel.CompileLog, payload);
     },
@@ -1150,8 +1158,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 +1170,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 +1411,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 +1447,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 +1484,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 +1617,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 +1654,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 +2271,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 +2353,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 +2376,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 +2660,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 +2855,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 +3261,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 +3319,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 +3336,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 +3490,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 +3630,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 +3873,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 +3890,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);
@@ -3900,7 +3933,8 @@ function getProjectPages(dirPath) {
       pages: appJson.pages || [],
       entryPagePath: appJson.entryPagePath || appJson.pages?.[0] || ""
     };
-  } catch {
+  } catch (err2) {
+    log2.warn(`Failed to read project pages from ${appJsonPath}`, err2);
     return { pages: [], entryPagePath: "" };
   }
 }
@@ -4002,14 +4036,14 @@ function createWorkspaceService(ctx) {
   let lastClosedProjectPath = "";
   let logGeneration = 0;
   const opLock = createOpLock();
-  function sendStatus(status2, message, hotReload) {
-    ctx.notify.projectStatus(hotReload ? { status: status2, message, hotReload: true } : { status: status2, message });
+  function sendStatus(status2, message, hotReload, pages, watcherDead) {
+    ctx.notify.projectStatus({ status: status2, message, ...hotReload ? { hotReload: true } : {}, ...pages ? { pages } : {}, ...watcherDead ? { watcher: "dead" } : {} });
   }
   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 +4057,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) {
@@ -4064,17 +4098,22 @@ function createWorkspaceService(ctx) {
         sourcemap: true,
         fileTypes: ctx.fileTypes,
         watch: compile.watch,
-        onRebuild: () => sendStatus("ready", "\u7F16\u8BD1\u5B8C\u6210\uFF0C\u5DF2\u91CD\u542F", true),
-        onBuildError: (err) => sendStatus("error", String(err)),
+        onRebuild: () => {
+          const { pages } = getProjectPages(projectPath);
+          sendStatus("ready", "\u7F16\u8BD1\u5B8C\u6210\uFF0C\u5DF2\u91CD\u542F", true, pages.length ? pages : void 0);
+        },
+        onBuildError: (err2) => sendStatus("error", String(err2)),
+        // Watcher died mid-session (EMFILE, permission loss, …): non-fatal, so 'ready' stays but `watcher: 'dead'` flags that saves no longer auto-rebuild.
+        onWatcherError: () => sendStatus("ready", "\u6587\u4EF6\u76D1\u542C\u5DF2\u505C\u6B62\uFF0C\u4FDD\u5B58\u4E0D\u518D\u89E6\u53D1\u81EA\u52A8\u7F16\u8BD1", false, void 0, true),
         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 +4151,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 +4646,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 +4711,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 +4782,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 +4798,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, () => {
@@ -4913,11 +4969,30 @@ import { app as app12, ipcMain as ipcMain3, protocol as protocol2, session as el
 import path17 from "node:path";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 
+// src/shared/request-core.ts
+var DEFAULT_REQUEST_TIMEOUT_MS = 6e4;
+var MAX_TIMEOUT_MS = 2147483647;
+function resolveTimeoutBudgetMs(timeout) {
+  const t = Number(timeout);
+  return Number.isFinite(t) && t > 0 && t <= MAX_TIMEOUT_MS ? t : DEFAULT_REQUEST_TIMEOUT_MS;
+}
+
 // src/shared/simulator-api-metadata.ts
 var PERSISTENT_SIMULATOR_APIS = /* @__PURE__ */ new Set(["audioListen"]);
 function isPersistentSimulatorApi(name) {
   return PERSISTENT_SIMULATOR_APIS.has(name);
 }
+var NETWORK_BUDGET_SIMULATOR_APIS = /* @__PURE__ */ new Set([
+  "request",
+  "downloadFile",
+  "uploadFile"
+]);
+var API_CALL_WATCHDOG_MS = 5e3;
+function apiCallWatchdogMs(name, params) {
+  if (!NETWORK_BUDGET_SIMULATOR_APIS.has(name)) return API_CALL_WATCHDOG_MS;
+  const budget = resolveTimeoutBudgetMs(params?.timeout);
+  return Math.min(budget + API_CALL_WATCHDOG_MS, MAX_TIMEOUT_MS);
+}
 
 // src/main/ipc/session-listener-bag.ts
 function createSessionListenerBag() {
@@ -4984,7 +5059,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());
       });
     }
   };
@@ -5084,10 +5159,13 @@ function buildServiceHostSpawnUrl(opts) {
   }
   return url.toString();
 }
-function navigateServiceHost(win, url) {
+function navigateServiceHost(win, url, opts) {
   const loaded = Promise.resolve(win.loadURL(url)).then(
     () => void 0,
-    () => void 0
+    (err2) => {
+      opts?.onLoadFailed?.(err2);
+      return void 0;
+    }
   );
   if (!app10.isPackaged && process.env.NODE_ENV !== "test") {
     const w = win;
@@ -5126,7 +5204,7 @@ function serviceHostSpec(appId, projectPath) {
 }
 function createServiceHostWindow(opts) {
   const win = constructServiceHostWindow({ appId: opts.appId, partition: miniappPartition(opts.appId, opts.projectPath) });
-  void navigateServiceHost(win, buildServiceHostSpawnUrl(opts));
+  void navigateServiceHost(win, buildServiceHostSpawnUrl(opts), { onLoadFailed: opts.onLoadFailed });
   return win;
 }
 
@@ -5443,9 +5521,49 @@ function buildForwardScript(level, args) {
   return `(()=>{try{const a=JSON.parse(${JSON.stringify(argsJson)});console[${JSON.stringify(method)}]('[\u89C6\u56FE]',...a)}catch(_){}})()
 //# sourceURL=${RENDER_FORWARD_SOURCE_URL}`;
 }
-function createConsoleForwarder(bridge) {
+var DIAGNOSTIC_CONSOLE_CALL = {
+  error: "console.error",
+  warn: "console.warn",
+  info: "console.info"
+};
+function buildDiagnosticScript(severity, message) {
+  const call = DIAGNOSTIC_CONSOLE_CALL[severity];
+  const argsJson = JSON.stringify([`[dimina-kit] ${message}`]);
+  return `(()=>{try{const a=JSON.parse(${JSON.stringify(argsJson)});${call}(...a)}catch(_){}})()
+//# sourceURL=${RENDER_FORWARD_SOURCE_URL}`;
+}
+function createConsoleForwarder(bridge, diagnostics) {
   const sinks = /* @__PURE__ */ new Set();
   const registry = new DisposableRegistry4();
+  const pendingBySession = /* @__PURE__ */ new Map();
+  const pendingGlobal = [];
+  const readySessions = /* @__PURE__ */ new Set();
+  function injectDiagnostic(wc, d) {
+    wc.executeJavaScript(buildDiagnosticScript(d.severity, d.message), true).catch(() => {
+    });
+  }
+  function handleDiagnostic(d) {
+    if (d.appSessionId) {
+      const wc2 = readySessions.has(d.appSessionId) && bridge.getServiceWcForBridge ? bridge.getServiceWcForBridge(d.appSessionId) : null;
+      if (wc2 && !wc2.isDestroyed()) {
+        injectDiagnostic(wc2, d);
+        return;
+      }
+      const bucket = pendingBySession.get(d.appSessionId);
+      if (bucket) bucket.push(d);
+      else pendingBySession.set(d.appSessionId, [d]);
+      return;
+    }
+    const wc = bridge.getServiceWc();
+    if (wc && !wc.isDestroyed()) {
+      injectDiagnostic(wc, d);
+      return;
+    }
+    pendingGlobal.push(d);
+  }
+  if (diagnostics) {
+    registry.add(diagnostics.subscribe(handleDiagnostic, { replay: true }));
+  }
   function forwardRenderToServiceHost(entry) {
     let wc = null;
     if (entry.bridgeId && bridge.getServiceWcForBridge) {
@@ -5482,13 +5600,84 @@ function createConsoleForwarder(bridge) {
         sinks.delete(sink);
       }));
     },
+    notifyServiceHostReady(appSessionId) {
+      readySessions.add(appSessionId);
+      const wc = bridge.getServiceWcForBridge ? bridge.getServiceWcForBridge(appSessionId) : null;
+      if (!wc) return;
+      const sessionEntries = pendingBySession.get(appSessionId);
+      if (sessionEntries) {
+        for (const d of sessionEntries) injectDiagnostic(wc, d);
+        pendingBySession.delete(appSessionId);
+      }
+      if (pendingGlobal.length) {
+        for (const d of pendingGlobal) injectDiagnostic(wc, d);
+        pendingGlobal.length = 0;
+      }
+    },
     dispose() {
       sinks.clear();
+      pendingBySession.clear();
+      pendingGlobal.length = 0;
+      readySessions.clear();
       return registry.disposeAll();
     }
   };
 }
 
+// src/main/services/diagnostics/index.ts
+var DEFAULT_BUFFER_CAP = 200;
+var CONSOLE_METHOD = {
+  error: "error",
+  warn: "warn",
+  info: "info"
+};
+function createDiagnosticsBus(opts) {
+  const bufferCap = opts?.bufferCap && opts.bufferCap > 0 ? opts.bufferCap : DEFAULT_BUFFER_CAP;
+  const buffer = [];
+  const sinks = /* @__PURE__ */ new Set();
+  let disposed = false;
+  return {
+    report(d) {
+      if (disposed) return;
+      const entry = { ...d, ts: Date.now() };
+      buffer.push(entry);
+      if (buffer.length > bufferCap) buffer.shift();
+      console[CONSOLE_METHOD[entry.severity]](`[dimina-kit:${entry.code}] ${entry.message}`);
+      for (const sink of sinks) {
+        try {
+          sink(entry);
+        } catch {
+        }
+      }
+    },
+    subscribe(sink, subOpts) {
+      const replay = subOpts?.replay ?? true;
+      if (replay) {
+        for (const entry of buffer) {
+          try {
+            sink(entry);
+          } catch {
+          }
+        }
+      }
+      sinks.add(sink);
+      let released = false;
+      return {
+        dispose() {
+          if (released) return;
+          released = true;
+          sinks.delete(sink);
+        }
+      };
+    },
+    dispose() {
+      disposed = true;
+      sinks.clear();
+      buffer.length = 0;
+    }
+  };
+}
+
 // src/main/services/simulator-storage/index.ts
 import { app as app11, webContents as wcStatic } from "electron";
 import { DisposableRegistry as DisposableRegistry5 } from "@dimina-kit/electron-deck/main";
@@ -6059,6 +6248,7 @@ function rewriteSourceMappingUrl(source, scriptUrl) {
 //# sourceMappingURL=${absolute}`;
 }
 var STACK_ID = "stack_0";
+var LAUNCH_TIMEOUT_MS = 2e4;
 var PREWARM_MAX_POOL_SIZE = 4;
 function resolvePrewarmPoolSize() {
   if (process.env.DIMINA_PREWARM_DISABLE === "1") return 0;
@@ -6080,28 +6270,33 @@ function summarizeBridgeMsg(payload) {
   const parts = [type, bridgeId ? `bridge=${bridgeId}` : void 0].filter(Boolean);
   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 = {
@@ -6244,13 +6439,20 @@ function installBridgeRouter(ctx) {
     ;
     globalThis.__diminaResourceCensus = () => bridgeHandle.census?.();
   }
-  const consoleForwarder = createConsoleForwarder(bridgeHandle);
+  const ownsDiagnosticsBus = ctx.diagnostics === void 0;
+  const diagnosticsBus = ctx.diagnostics ?? createDiagnosticsBus();
+  ctx.diagnostics = diagnosticsBus;
+  const consoleForwarder = createConsoleForwarder(bridgeHandle, diagnosticsBus);
   ctx.consoleForwarder = consoleForwarder;
   ctx.guestConsole = consoleForwarder;
   ctx.registry.add(() => {
     void consoleForwarder.dispose();
     ctx.consoleForwarder = void 0;
     ctx.guestConsole = void 0;
+    if (ownsDiagnosticsBus) {
+      diagnosticsBus.dispose();
+      ctx.diagnostics = void 0;
+    }
   });
   const onActivePage = (event, payload) => {
     const ap = state.appSessions.get(payload.appSessionId);
@@ -6410,6 +6612,39 @@ function installBridgeRouter(ctx) {
     );
   });
 }
+function clearLaunchTimer(ap) {
+  if (ap.launchTimer === null) return;
+  clearTimeout(ap.launchTimer);
+  ap.launchTimer = null;
+}
+function startLaunchTimer(state, ctx, ap) {
+  ap.launchTimer = setTimeout(() => {
+    ap.launchTimer = null;
+    if (ap.running) return;
+    if (state.appSessions.get(ap.appSessionId) !== ap) return;
+    const reason = `Service host did not report readiness within ${LAUNCH_TIMEOUT_MS}ms`;
+    ctx.diagnostics?.report({
+      severity: "error",
+      code: "launch-timeout",
+      message: reason,
+      appSessionId: ap.appSessionId
+    });
+    pushRuntimeStatus(ctx, ap, { phase: "launch-failed", code: "timeout", reason });
+  }, LAUNCH_TIMEOUT_MS);
+}
+function markSessionRunning(ctx, ap, page) {
+  if (!page.isRoot || ap.running) return;
+  ap.running = true;
+  clearLaunchTimer(ap);
+  pushRuntimeStatus(ctx, ap, { phase: "running" });
+}
+function pushRuntimeStatus(ctx, session5, status2) {
+  ctx.notify?.sessionRuntimeStatus?.({
+    appId: session5.appId,
+    ...status2,
+    ...session5.pageFallback ? { pageFallback: session5.pageFallback } : {}
+  });
+}
 async function handleSpawn(state, ctx, event, opts) {
   const appId = opts.appId;
   if (!appId) throw new Error("[bridge-router] spawn requires appId");
@@ -6435,20 +6670,48 @@ async function handleSpawn(state, ctx, event, opts) {
     ...selectedDevice ? deviceInfoToHostEnv(selectedDevice) : {}
   });
   const appConfig = await loadAppConfig(
-    resourceServer ? resourceServer.baseUrl : `${resourceBaseUrl}${appId}/${root}/`
+    resourceServer ? resourceServer.baseUrl : `${resourceBaseUrl}${appId}/${root}/`,
+    ({ url, error }) => {
+      ctx.diagnostics?.report({
+        severity: "error",
+        code: "app-config-unreachable",
+        message: `app-config.json unreachable at ${url}: ${String(error)}`,
+        appSessionId
+      });
+    }
   );
   const manifest = buildAppManifest(appConfig, pagePath);
-  const rootWindowConfig = resolvePageWindowConfig(appConfig, pagePath);
-  const isTab = isTabPage(appConfig, pagePath);
+  const { resolvedPagePath, pageFallbackApplied } = resolveRootPagePath(manifest, pagePath);
+  if (pageFallbackApplied) {
+    reportPageNotFound(ctx, appSessionId, pagePath, resolvedPagePath);
+  }
+  const rootWindowConfig = resolvePageWindowConfig(appConfig, resolvedPagePath);
+  const isTab = isTabPage(appConfig, resolvedPagePath);
   const usedPool = state.pool !== null;
   let poolEntryId = null;
   let serviceWindow;
-  if (state.pool) {
-    const acquired = await state.pool.acquire(serviceHostSpec());
+  const reportServiceHostNavigationFailed = (spawnUrl, err2) => {
+    const message = `Failed to navigate service host to ${spawnUrl}: ${String(err2)}`;
+    ctx.diagnostics?.report({
+      severity: "error",
+      code: "service-host-navigation-failed",
+      message,
+      appSessionId
+    });
+    const ap = state.appSessions.get(appSessionId);
+    if (ap) clearLaunchTimer(ap);
+    pushRuntimeStatus(
+      ctx,
+      ap ?? { appId, pageFallback: pageFallbackApplied ? { requested: pagePath, resolved: resolvedPagePath } : null },
+      { phase: "launch-failed", code: "service-host-navigation-failed", reason: message }
+    );
+  };
+  if (state.pool) {
+    const acquired = await state.pool.acquire(serviceHostSpec());
     serviceWindow = acquired.win;
     poolEntryId = acquired.entryId;
   } else {
-    serviceWindow = createServiceHostWindow({
+    const freshWindowOptions = {
       bridgeId,
       appId,
       // Same (appId, projectPath) pair the simulator WCV uses, so this project's
@@ -6458,12 +6721,16 @@ async function handleSpawn(state, ctx, event, opts) {
       // awaits above would otherwise give the service host a different path than
       // the simulator WCV was built with, splitting the partition.
       projectPath: workspaceProjectPath || void 0,
-      pagePath,
+      pagePath: resolvedPagePath,
       pkgRoot,
       root,
       resourceBaseUrl,
       hostEnvSnapshot: hostEnv,
       apiNamespaces
+    };
+    serviceWindow = createServiceHostWindow({
+      ...freshWindowOptions,
+      onLoadFailed: (err2) => reportServiceHostNavigationFailed(buildServiceHostSpawnUrl(freshWindowOptions), err2)
     });
   }
   const appSession = {
@@ -6487,12 +6754,15 @@ async function handleSpawn(state, ctx, event, opts) {
     poolEntryId,
     onServiceBoot: null,
     listenerBag: createSessionListenerBag(),
-    registryHandle: null
+    registryHandle: null,
+    running: false,
+    launchTimer: null,
+    pageFallback: pageFallbackApplied ? { requested: pagePath, resolved: resolvedPagePath } : null
   };
   const rootPage = {
     bridgeId,
     appSessionId,
-    pagePath,
+    pagePath: resolvedPagePath,
     query: opts.query ?? {},
     isRoot: true,
     isTab,
@@ -6537,28 +6807,43 @@ async function handleSpawn(state, ctx, event, opts) {
     };
     appSession.onServiceBoot = bootOnServiceLoad;
     serviceWindow.webContents.on("did-finish-load", bootOnServiceLoad);
-    void navigateServiceHost(
-      serviceWindow,
-      buildServiceHostSpawnUrl({
-        bridgeId,
-        appId,
-        pagePath,
-        pkgRoot,
-        root,
-        resourceBaseUrl,
-        hostEnvSnapshot: hostEnv,
-        apiNamespaces
-      })
-    );
+    const spawnUrl = buildServiceHostSpawnUrl({
+      bridgeId,
+      appId,
+      pagePath: resolvedPagePath,
+      pkgRoot,
+      root,
+      resourceBaseUrl,
+      hostEnvSnapshot: hostEnv,
+      apiNamespaces
+    });
+    void navigateServiceHost(serviceWindow, spawnUrl, {
+      onLoadFailed: (err2) => reportServiceHostNavigationFailed(spawnUrl, err2)
+    });
   } else {
     serviceWindow.webContents.once("did-finish-load", () => {
       void bootServiceHost(state, appSession, ctx);
     });
   }
+  const onServiceCrashed = () => {
+    clearLaunchTimer(appSession);
+    ctx.diagnostics?.report({
+      severity: "error",
+      code: "service-host-crashed",
+      message: `Service host renderer process gone for appSessionId=${appSessionId}`,
+      appSessionId
+    });
+    pushRuntimeStatus(ctx, appSession, { phase: "crashed", code: "service-host-crashed" });
+  };
+  appSession.listenerBag.on(serviceWindow.webContents, "render-process-gone", onServiceCrashed);
+  pushRuntimeStatus(ctx, appSession, { phase: "launching" });
+  startLaunchTimer(state, ctx, appSession);
   return {
     appSessionId,
     bridgeId,
     pagePath,
+    resolvedPagePath,
+    pageFallbackApplied,
     serviceWcId: serviceWindow.webContents.id,
     resourceBaseUrl,
     manifest,
@@ -6572,6 +6857,9 @@ async function handlePageOpen(state, event, opts) {
     throw new Error("[bridge-router] PAGE_OPEN rejected: caller not bound to app session");
   }
   const pagePath = normalizePagePath(opts.pagePath);
+  if (ap.manifest.source === "app-config" && !ap.manifest.pages.includes(pagePath)) {
+    throw new Error(`[bridge-router] PAGE_OPEN rejected: page-not-found "${pagePath}" is not in the compiled manifest`);
+  }
   const bridgeId = opts.bridgeId || newBridgeId();
   const windowConfig = resolvePageWindowConfig(ap.appConfig, pagePath);
   const isTab = isTabPage(ap.appConfig, pagePath);
@@ -6631,15 +6919,18 @@ function handleNavCallback(state, sender, payload) {
 }
 async function bootServiceHost(state, ap, ctx) {
   if (state.appSessions.get(ap.appSessionId) !== ap) return;
+  ctx.consoleForwarder?.notifyServiceHostReady?.(ap.appSessionId);
   ap.logicInjected = await injectLogicBundle(ap);
   if (!ap.logicInjected) {
-    reportLogicLoadFailure(ap, ctx);
+    const reason = reportLogicLoadFailure(ap, ctx);
+    clearLaunchTimer(ap);
+    pushRuntimeStatus(ctx, ap, { phase: "launch-failed", code: "logic-bundle-unreachable", reason });
     return;
   }
   const rootPage = ap.pages.get(ap.appSessionId);
   const rootMissing = !!rootPage && !pageInManifest(ap, rootPage.pagePath);
   if (rootMissing) {
-    reportPageNotFound(ap, ctx, rootPage.pagePath);
+    reportPageNotFound(ctx, ap.appSessionId, rootPage.pagePath);
   } else if (rootPage) {
     forwardToService(ap, makeLoadResource(ap, rootPage, "service"));
   }
@@ -6673,16 +6964,30 @@ async function injectLogicBundle(ap) {
 }
 function reportLogicLoadFailure(ap, ctx) {
   const hint = ap.appId === "unknown" ? ' appId could not be resolved (it fell back to "unknown") \u2014 the mini-program likely failed to compile or its project manifest/app config is missing.' : "";
-  const message = `[dimina-kit] Failed to load the mini-program logic bundle from ${logicBundleUrl(ap)}. The service runtime has no registered modules, so no page can mount.` + hint + ` Verify the project compiled successfully and that the resource server serves "${ap.appId}/${ap.root}/".`;
-  console.error(message);
+  const shortReason = `[dimina-kit] Failed to load the mini-program logic bundle from ${logicBundleUrl(ap)}.`;
+  const message = `${shortReason} The service runtime has no registered modules, so no page can mount.` + hint + ` Verify the project compiled successfully and that the resource server serves "${ap.appId}/${ap.root}/".`;
+  ctx.diagnostics?.report({
+    severity: "error",
+    code: "logic-bundle-unreachable",
+    message,
+    appSessionId: ap.appSessionId
+  });
   ctx.guestConsole?.emit({ source: "service", level: "error", args: [message] });
+  return shortReason;
 }
 function pageInManifest(ap, pagePath) {
+  if (ap.manifest.source !== "app-config") return true;
   return ap.manifest.pages.includes(normalizePagePath(pagePath));
 }
-function reportPageNotFound(ap, ctx, pagePath) {
-  const message = `Page[${pagePath}] not found. May be caused by: 1. Forgetting to add page route in app.json. 2. Invoking Page() in async task.`;
-  console.error(`[bridge-router] ${message}`);
+function reportPageNotFound(ctx, appSessionId, pagePath, fallbackTo) {
+  const base = `Page[${pagePath}] not found. May be caused by: 1. Forgetting to add page route in app.json. 2. Invoking Page() in async task.`;
+  const message = fallbackTo ? `${base} Falling back to "${fallbackTo}".` : base;
+  ctx.diagnostics?.report({
+    severity: "error",
+    code: "page-not-found",
+    message,
+    appSessionId
+  });
   ctx.guestConsole?.emit({ source: "service", level: "error", args: [message] });
 }
 function maybeSendResourceLoaded(ap, page) {
@@ -6739,6 +7044,11 @@ function routeFromRender(state, ap, page, msg, ctx) {
     handleContainerMsg(ap, page, msg, ctx, state);
   }
 }
+function reportServiceUncaughtError(ctx, ap, body) {
+  const severity = body.level === "error" ? "error" : body.level === "warn" ? "warn" : "info";
+  const message = Array.isArray(body.args) ? body.args.map((a) => String(a)).join(" ") : String(body.args ?? "");
+  ctx.diagnostics?.report({ severity, code: "service-uncaught-error", message, appSessionId: ap.appSessionId });
+}
 function handleContainerMsg(ap, page, msg, ctx, state) {
   switch (msg.type) {
     case "serviceResourceLoaded":
@@ -6757,22 +7067,31 @@ function handleContainerMsg(ap, page, msg, ctx, state) {
         ap.simulatorWc.send(SIMULATOR_EVENTS.DOM_READY, { bridgeId: page.bridgeId });
       }
       state.emitRenderEvent({ kind: "domReady", appId: ap.appId, bridgeId: page.bridgeId });
+      markSessionRunning(ctx, ap, page);
       break;
     case "invokeAPI":
       void handleSimulatorApi(state, ap, page, msg.body, ctx);
       break;
     case "serviceHostError": {
-      console.warn("[bridge-router] service host error:", msg.body);
       const errBody = msg.body;
       const errArg = errBody?.message ?? msg.body;
+      ctx.diagnostics?.report({
+        severity: "error",
+        code: "service-host-error",
+        message: String(errArg),
+        appSessionId: ap.appSessionId
+      });
       for (const id of state.appLifecycle.listeners(ap.appSessionId, "onError")) {
         sendCallback(ap, id, errArg);
       }
       break;
     }
-    case "consoleLog":
+    case "consoleLog": {
       ctx.guestConsole?.emit(msg.body);
+      const body = msg.body;
+      if (body?.source === "service") reportServiceUncaughtError(ctx, ap, body);
       break;
+    }
     case "storageChanged":
       ctx.onServiceStorageChanged?.(ap.appId, msg.body);
       break;
@@ -6841,99 +7160,136 @@ 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);
-    }
+      params
+    });
+  }
+  const successResult = { errMsg: `${name}:ok` };
+  sendCallback(ap, params.success, successResult);
+  sendCallback(ap, params.complete, successResult);
+}
+function failActionCallback(ap, params, errMsg) {
+  const fail = { errMsg };
+  sendCallback(ap, params.fail, fail);
+  sendCallback(ap, params.complete, fail);
+}
+function sendActionOrFail(ap, eventName, payload, name, params) {
+  if (!ap.simulatorWc.isDestroyed()) {
+    ap.simulatorWc.send(eventName, payload);
     return;
   }
-  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);
+  failActionCallback(ap, params, `${name}:fail simulator window destroyed`);
+}
+function extractNavTargetPagePath(params) {
+  const raw = params.url;
+  if (typeof raw !== "string" || !raw) return void 0;
+  return normalizePagePath(raw.split("?")[0] ?? raw);
+}
+function checkNavTarget(ap, name, targetPagePath) {
+  if (ap.manifest.source !== "app-config") return { ok: true };
+  if (!ap.manifest.pages.includes(targetPagePath)) {
+    return { ok: false, errMsg: `${name}:fail page "${targetPagePath}" is not found`, reportNotFound: true };
+  }
+  if (name === "switchTab") {
+    const inTabBar = ap.manifest.tabBar?.list.some((item) => normalizePagePath(item.pagePath) === targetPagePath) ?? false;
+    if (!inTabBar) return { ok: false, errMsg: "switchTab:fail can not switch to no-tabBar page" };
+  }
+  return { ok: true };
+}
+function handleNavActionApi(ap, ctx, page, name, params) {
+  const targetPagePath = extractNavTargetPagePath(params);
+  if (targetPagePath !== void 0) {
+    const verdict = checkNavTarget(ap, name, targetPagePath);
+    if (!verdict.ok) {
+      if (verdict.reportNotFound) reportPageNotFound(ctx, ap.appSessionId, targetPagePath);
+      failActionCallback(ap, params, verdict.errMsg);
+      return;
     }
-    return;
   }
+  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, ctx, 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);
@@ -6957,7 +7313,7 @@ function forwardApiCallToSimulator(state, ap, page, name, params) {
     const fail = { errMsg: `${pending.name}:fail no handler (timeout)` };
     sendCallback(target, pending.callbacks.fail, fail);
     sendCallback(target, pending.callbacks.complete, fail);
-  }, API_CALL_TIMEOUT_MS);
+  }, apiCallWatchdogMs(name, params));
   state.pendingApiCalls.set(requestId, {
     appSessionId: ap.appSessionId,
     callbacks,
@@ -7006,7 +7362,12 @@ function handleApiResponse(state, sender, payload) {
     sendCallback(ap, pending.callbacks.success, payload.result);
     sendCallback(ap, pending.callbacks.complete, payload.result ?? { errMsg: `${pending.name}:ok` });
   } else {
-    const fail = { errMsg: payload.errMsg ?? `${pending.name}:fail` };
+    const result = payload.result && typeof payload.result === "object" && !Array.isArray(payload.result) ? payload.result : void 0;
+    const resultErrMsg = typeof result?.errMsg === "string" ? result.errMsg : void 0;
+    const fail = {
+      ...result,
+      errMsg: payload.errMsg || resultErrMsg || `${pending.name}:fail`
+    };
     sendCallback(ap, pending.callbacks.fail, fail);
     sendCallback(ap, pending.callbacks.complete, fail);
   }
@@ -7152,20 +7513,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 +7531,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 +7546,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,31 +7556,68 @@ 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);
+  clearLaunchTimer(ap);
+  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);
     });
   }
 }
-async function loadAppConfig(resourceBase) {
+async function loadAppConfig(resourceBase, onUnreachable) {
   const cfgUrl = new URL("app-config.json", resourceBase.endsWith("/") ? resourceBase : `${resourceBase}/`).toString();
   try {
     const res = await fetch(cfgUrl);
     if (!res.ok) {
+      const error = new Error(`app-config.json fetch ${res.status} at ${cfgUrl}`);
       console.warn(`[bridge-router] no app-config.json at ${cfgUrl} (${res.status})`);
+      onUnreachable?.({ url: cfgUrl, error });
       return {};
     }
     return await res.json();
   } catch (error) {
     console.warn("[bridge-router] failed to fetch/parse app-config.json:", error);
+    onUnreachable?.({ url: cfgUrl, error });
     return {};
   }
 }
 function buildAppManifest(appConfig, fallbackEntry) {
   const entry = appConfig.app?.entryPagePath || fallbackEntry;
-  const pages = appConfig.app?.pages?.length ? appConfig.app.pages : [entry];
+  const hasCompiledPages = !!appConfig.app?.pages?.length;
+  const pages = hasCompiledPages ? appConfig.app.pages : [entry];
   const tabBar = appConfig.app?.tabBar && Array.isArray(appConfig.app.tabBar.list) && appConfig.app.tabBar.list.length > 0 ? appConfig.app.tabBar : void 0;
-  return { entryPagePath: normalizePagePath(entry), pages: pages.map(normalizePagePath), tabBar };
+  return {
+    entryPagePath: normalizePagePath(entry),
+    pages: pages.map(normalizePagePath),
+    tabBar,
+    // 'app-config' means `pages` above is the real compiled list mount gates
+    // can trust; 'fallback' means app-config.json was unreachable and `pages`
+    // is just the single requested page — nothing to validate membership
+    // against, so every gate keyed on this source lets it through unchanged.
+    source: hasCompiledPages ? "app-config" : "fallback"
+  };
+}
+function resolveRootPagePath(manifest, requestedPagePath) {
+  if (manifest.source !== "app-config" || manifest.pages.includes(requestedPagePath)) {
+    return { resolvedPagePath: requestedPagePath, pageFallbackApplied: false };
+  }
+  const resolvedPagePath = manifest.pages.includes(manifest.entryPagePath) ? manifest.entryPagePath : manifest.pages[0];
+  return { resolvedPagePath, pageFallbackApplied: true };
 }
 function resolvePageWindowConfig(appConfig, pagePath) {
   const normalized = normalizePagePath(pagePath);
@@ -7513,89 +7907,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 +8011,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 +8288,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 +8393,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 +8931,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 +9050,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 +9118,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 +9140,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",
@@ -8838,6 +9294,7 @@ function createNetworkForwarder(bridge) {
   let sink = "idle";
   let probeConsoleBuffer = [];
   let readyTimeoutTimer = null;
+  let probeDeadline = null;
   let dispatchQueue = [];
   let flushScheduled = false;
   let readyRetryTimer = null;
@@ -8848,6 +9305,7 @@ function createNetworkForwarder(bridge) {
   function beginProbing() {
     if (sink === "probing") return;
     sink = "probing";
+    probeDeadline = Date.now() + DEVTOOLS_READY_TIMEOUT_MS;
     if (readyTimeoutTimer) clearTimeout(readyTimeoutTimer);
     readyTimeoutTimer = setTimeout(() => {
       readyTimeoutTimer = null;
@@ -8856,6 +9314,7 @@ function createNetworkForwarder(bridge) {
   }
   function markReady() {
     sink = "ready";
+    probeDeadline = null;
     if (readyTimeoutTimer) {
       clearTimeout(readyTimeoutTimer);
       readyTimeoutTimer = null;
@@ -8868,6 +9327,7 @@ function createNetworkForwarder(bridge) {
   }
   function degradeToConsole() {
     sink = "degraded";
+    probeDeadline = null;
     dispatchQueue = [];
     if (readyTimeoutTimer) {
       clearTimeout(readyTimeoutTimer);
@@ -8922,21 +9382,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 +9399,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;
       }
@@ -8985,9 +9432,17 @@ function createNetworkForwarder(bridge) {
   }
   function scheduleReadyRetry() {
     if (readyRetryTimer || sink === "ready" || sink === "degraded") return;
+    if (probeDeadline !== null && Date.now() >= probeDeadline) {
+      degradeToConsole();
+      return;
+    }
     readyRetryTimer = setTimeout(() => {
       readyRetryTimer = null;
       if (sink === "degraded") return;
+      if (probeDeadline !== null && Date.now() >= probeDeadline) {
+        degradeToConsole();
+        return;
+      }
       if (dispatchQueue.length > 0) scheduleFlush();
     }, READY_RETRY_MS);
   }
@@ -9026,6 +9481,7 @@ function createNetworkForwarder(bridge) {
     dispatchQueue = [];
     probeConsoleBuffer = [];
     sink = "idle";
+    probeDeadline = null;
     if (readyRetryTimer) {
       clearTimeout(readyRetryTimer);
       readyRetryTimer = null;
@@ -9048,8 +9504,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 +9601,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) {
@@ -9176,6 +9632,7 @@ function createNetworkForwarder(bridge) {
       clearTimeout(readyRetryTimer);
       readyRetryTimer = null;
     }
+    probeDeadline = null;
     probeConsoleBuffer = [];
     if (!devtoolsWc) {
       sink = "idle";
@@ -9199,6 +9656,7 @@ function createNetworkForwarder(bridge) {
         }
       });
     }
+    sink = "idle";
     beginProbing();
     if (dispatchQueue.length > 0) scheduleFlush();
   }
@@ -9316,41 +9774,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 +10267,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 +10328,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 +10373,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 +10549,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;
@@ -10246,6 +10726,11 @@ function setupSimulatorTempFiles(simSession) {
 // src/main/services/views/simulator-session-policy.ts
 import { session as session3 } from "electron";
 import { toDisposable as toDisposable7 } from "@dimina-kit/electron-deck/main";
+var CORS_OVERRIDE_HEADERS = /* @__PURE__ */ new Set([
+  "access-control-allow-origin",
+  "access-control-allow-headers",
+  "access-control-allow-methods"
+]);
 function applySimulatorWebRequestPolicy(simulatorSession) {
   simulatorSession.webRequest.onBeforeSendHeaders((details, callback) => {
     const forcedReferer = getSimulatorServicewechatReferer();
@@ -10256,6 +10741,9 @@ function applySimulatorWebRequestPolicy(simulatorSession) {
   });
   simulatorSession.webRequest.onHeadersReceived((details, callback) => {
     const headers = details.responseHeaders ?? {};
+    for (const key of Object.keys(headers)) {
+      if (CORS_OVERRIDE_HEADERS.has(key.toLowerCase())) delete headers[key];
+    }
     headers["access-control-allow-origin"] = ["*"];
     headers["access-control-allow-headers"] = ["*"];
     headers["access-control-allow-methods"] = ["*"];
@@ -10330,8 +10818,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 +10900,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 +10959,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 +11097,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 +11112,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 +11218,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 +11435,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 +11566,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);
 });