@dimina-kit/devtools 0.4.0-dev.20260618090552 → 0.4.0-dev.20260624084417

package/dist/main/index.bundle.js

@@ -410,11 +410,11 @@ var ProjectsChannel = {
   List: "projects:list",
   Add: "projects:add",
   Remove: "projects:remove",
-  /** Phase 3: merged + sanitized template catalog for the create-project dialog. */
+  /** Merged + sanitized template catalog for the create-project dialog. */
   ListTemplates: "projects:listTemplates",
-  /** Phase 3: host-supplied create-project dialog hook (returns input or null). */
+  /** Host-supplied create-project dialog hook (returns input or null). */
   OpenCreateDialog: "projects:openCreateDialog",
-  /** Phase 3: server-side scaffold + register (delegates to create-project-service). */
+  /** Server-side scaffold + register (delegates to create-project-service). */
   Create: "projects:create",
   /** Default values used to pre-fill the create-project dialog (baseDir). */
   GetCreateDefaults: "projects:getCreateDefaults"
@@ -762,7 +762,7 @@ function registerProjectFsIpc(ctx) {
 
 // src/main/app/app.ts
 import { app as app15, BrowserWindow as BrowserWindow8, nativeImage, session as session4 } from "electron";
-import fs10 from "fs";
+import fs11 from "fs";
 import path21 from "path";
 
 // src/main/utils/paths.ts
@@ -1052,6 +1052,7 @@ function createRendererNotifier(ctx) {
 
 // src/main/services/views/view-manager.ts
 import { ipcMain as ipcMain2, nativeTheme as nativeTheme3, shell as shell2, WebContentsView as WebContentsView2, webContents } from "electron";
+import fs4 from "node:fs";
 import path7 from "path";
 
 // src/shared/open-in-editor.ts
@@ -1078,8 +1079,11 @@ function decodeOpenInEditorUrl(raw) {
   }
   return out;
 }
-function resourceUrlToProjectRelativePath(resourceUrl, expectedOrigin) {
+function resourceUrlToProjectRelativePath(resourceUrl, expectedOriginOrContext) {
   if (typeof resourceUrl !== "string" || !resourceUrl) return null;
+  if (expectedOriginOrContext && typeof expectedOriginOrContext === "object") {
+    return projectAwareResourcePath(resourceUrl, expectedOriginOrContext);
+  }
   let resource;
   try {
     resource = new URL(resourceUrl);
@@ -1087,10 +1091,10 @@ function resourceUrlToProjectRelativePath(resourceUrl, expectedOrigin) {
     return null;
   }
   if (resource.protocol !== "http:" && resource.protocol !== "https:") return null;
-  if (expectedOrigin) {
+  if (expectedOriginOrContext) {
     let base;
     try {
-      base = new URL(expectedOrigin);
+      base = new URL(expectedOriginOrContext);
     } catch {
       return null;
     }
@@ -1106,6 +1110,322 @@ function resourceUrlToProjectRelativePath(resourceUrl, expectedOrigin) {
   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 {
+    url = new URL(serviceHostUrl);
+  } catch {
+    return null;
+  }
+  const projectRoot = url.searchParams.get("pkgRoot") || "";
+  const resourceBaseUrl = url.searchParams.get("resourceBaseUrl") ?? "";
+  const appId = url.searchParams.get("appId") ?? "";
+  const outputRoot = url.searchParams.get("root") ?? "main";
+  if (!projectRoot || !resourceBaseUrl || !appId) return null;
+  if (activeProjectRoot) {
+    const authoritativeRoot = normalizeSlashPath(projectRoot).replace(/\/+$/, "");
+    const currentRoot = normalizeSlashPath(activeProjectRoot).replace(/\/+$/, "");
+    if (!authoritativeRoot || authoritativeRoot !== currentRoot) return null;
+  }
+  try {
+    new URL(resourceBaseUrl);
+  } catch {
+    return null;
+  }
+  return { projectRoot, resourceBaseUrl, appId, outputRoot };
+}
+function buildDevtoolsProjectSourceLinksScript(context) {
+  const config = JSON.stringify(context);
+  const scheme = JSON.stringify(OPEN_IN_EDITOR_SCHEME);
+  return `
+    (function() {
+      try {
+        const stateKey = '__diminaProjectSourceLinksState__'
+        const previousState = globalThis[stateKey]
+        if (previousState && typeof previousState.dispose === 'function') {
+          try { previousState.dispose() } catch (_) {}
+        }
+
+        const cfg = ${config}
+        const diminaProjectSourcePath = ${projectAwareResourcePath.toString()}
+        const decodePathname = ${decodePathname.toString()}
+        const normalizeSlashPath = ${normalizeSlashPath.toString()}
+        const safeRelativePath = ${safeRelativePath.toString()}
+        const observedRoots = new Set()
+        const observers = []
+        const clickBindings = []
+        let timer = null
+        const state = {
+          dispose() {
+            if (timer !== null) {
+              clearInterval(timer)
+              timer = null
+            }
+            for (const observer of observers.splice(0)) {
+              try { observer.disconnect() } catch (_) {}
+            }
+            for (const binding of clickBindings.splice(0)) {
+              try { binding.target.removeEventListener('click', binding.fn, true) } catch (_) {}
+            }
+            observedRoots.clear()
+          },
+        }
+        globalThis[stateKey] = state
+
+        // The InspectorFrontendHost that owns openInNewTab. Across DevTools
+        // versions it lives on the top-level \`InspectorFrontendHost\` global, the
+        // legacy \`Host.InspectorFrontendHost\`, or \`DevToolsHost\`; resolve at call
+        // time so a late-bootstrapped host is still found.
+        function resolveOpenInNewTabHost() {
+          const candidates = [
+            globalThis.InspectorFrontendHost,
+            globalThis.Host && globalThis.Host.InspectorFrontendHost,
+            globalThis.DevToolsHost,
+          ]
+          for (const host of candidates) {
+            if (host && typeof host.openInNewTab === 'function') return host
+          }
+          return null
+        }
+
+        // Encode (url, 0-based line, 0-based column) as the sentinel the main
+        // process decodes from \`devtools-open-url\` and routes to Monaco.
+        function openInEditor(url, line, column) {
+          const host = resolveOpenInNewTabHost()
+          if (!host) return false
+          const p = new URLSearchParams()
+          p.set('u', String(url))
+          if (typeof line === 'number' && isFinite(line)) p.set('l', String(line))
+          if (typeof column === 'number' && isFinite(column)) p.set('c', String(column))
+          try { host.openInNewTab(${scheme} + ':?' + p.toString()) } catch (_) { return false }
+          return true
+        }
+
+        // Resolve a clicked link element to a project source location. Returns
+        // the FULL resource url (the main process re-maps it against the active
+        // project) plus its display line/column when present.
+        function projectLocationForLink(link) {
+          if (!link) return null
+          const candidates = [
+            link.getAttribute && link.getAttribute('data-url'),
+            link.getAttribute && link.getAttribute('href'),
+            link.getAttribute && link.getAttribute('title'),
+          ]
+          for (const candidate of candidates) {
+            if (!candidate) continue
+            const location = splitLocation(candidate)
+            if (!diminaProjectSourcePath(location.url, cfg)) continue
+            const suffix = location.suffix
+              || ((String(link.textContent || '').match(/(:\\d+(?::\\d+)?)$/) || [])[1] || '')
+            return { url: location.url, suffix }
+          }
+          return null
+        }
+
+        // DevTools shows 1-based line:column in link text; the main process
+        // contract expects 0-based (it re-adds 1). Convert here.
+        function parseSuffix(suffix) {
+          const m = String(suffix || '').match(/^:(\\d+)(?::(\\d+))?$/)
+          if (!m) return { line: undefined, column: undefined }
+          const line = Math.max(0, parseInt(m[1], 10) - 1)
+          const column = m[2] != null ? Math.max(0, parseInt(m[2], 10) - 1) : undefined
+          return { line, column }
+        }
+
+        // Capture-phase click handler: route a project-source link click to
+        // Monaco instead of the DevTools Sources panel. Plain primary clicks only
+        // \u2014 modified clicks (cmd/ctrl/shift/alt, middle button) fall through to
+        // DevTools so its own "open in new tab" / multi-select still work.
+        function onLinkClick(event) {
+          if (event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return
+          const path = typeof event.composedPath === 'function' ? event.composedPath() : []
+          let link = null
+          for (const node of path) {
+            if (node && node.nodeType === 1 && node.classList && node.classList.contains('devtools-link')) {
+              link = node
+              break
+            }
+          }
+          if (!link) return
+          const location = projectLocationForLink(link)
+          if (!location) return
+          const { line, column } = parseSuffix(location.suffix)
+          if (!openInEditor(location.url, line, column)) return
+          event.preventDefault()
+          event.stopImmediatePropagation()
+        }
+
+        function bindClicks(target) {
+          if (!target || !target.addEventListener) return
+          for (const binding of clickBindings) {
+            if (binding.target === target) return
+          }
+          target.addEventListener('click', onLinkClick, true)
+          clickBindings.push({ target, fn: onLinkClick })
+        }
+
+        function splitLocation(value) {
+          const raw = String(value || '')
+          const match = raw.match(/^(.*?)(?::(\\d+))(?::(\\d+))?$/)
+          return match
+            ? { url: match[1], suffix: ':' + match[2] + (match[3] ? ':' + match[3] : '') }
+            : { url: raw, suffix: '' }
+        }
+
+        function rewriteLink(link) {
+          if (!link || link.dataset.diminaProjectSourcePath) return
+          const candidates = [
+            link.getAttribute && link.getAttribute('title'),
+            link.getAttribute && link.getAttribute('href'),
+            link.getAttribute && link.getAttribute('data-url'),
+          ]
+          for (const candidate of candidates) {
+            if (!candidate) continue
+            const location = splitLocation(candidate)
+            const relative = diminaProjectSourcePath(location.url, cfg)
+            if (!relative) continue
+            const textSuffix = location.suffix || ((String(link.textContent || '').match(/(:\\d+(?::\\d+)?)$/) || [])[1] || '')
+            link.textContent = relative + textSuffix
+            link.dataset.diminaProjectSourcePath = relative
+            return
+          }
+        }
+
+        function observeRoot(root) {
+          if (!root || !root.querySelectorAll || observedRoots.has(root)) return
+          observedRoots.add(root)
+          bindClicks(root)
+
+          const observer = new MutationObserver((records) => {
+            for (const record of records) {
+              if (record.type === 'attributes') rewriteLink(record.target)
+              for (const node of record.addedNodes || []) visitNode(node)
+            }
+          })
+          observer.observe(root, {
+            subtree: true,
+            childList: true,
+            attributes: true,
+            attributeFilter: ['title', 'href', 'data-url'],
+          })
+          observers.push(observer)
+
+          for (const link of root.querySelectorAll('.devtools-link')) rewriteLink(link)
+          for (const element of root.querySelectorAll('*')) {
+            if (element.shadowRoot) observeRoot(element.shadowRoot)
+          }
+        }
+
+        function visitNode(node) {
+          if (!node) return
+          if (node.matches && node.matches('.devtools-link')) rewriteLink(node)
+          if (node.shadowRoot) observeRoot(node.shadowRoot)
+          if (!node.querySelectorAll) return
+          for (const link of node.querySelectorAll('.devtools-link')) rewriteLink(link)
+          for (const element of node.querySelectorAll('*')) {
+            if (element.shadowRoot) observeRoot(element.shadowRoot)
+          }
+        }
+
+        observeRoot(document)
+
+        // Fallback for older DevTools fronts that still expose the
+        // setOpenResourceHandler hook. On current Chromium the method is gone,
+        // so this poll simply times out and the capture-phase click interceptor
+        // is the only live path. When the hook IS present the interceptor still
+        // wins (it runs in capture and stops propagation), so the two never
+        // double-open the same click.
+        let tries = 0
+        timer = setInterval(() => {
+          tries++
+          try {
+            const host = resolveOpenInNewTabHost()
+            if (host && typeof host.setOpenResourceHandler === 'function') {
+              host.setOpenResourceHandler((url, lineNumber, columnNumber) => {
+                if (!diminaProjectSourcePath(String(url), cfg)) return
+                openInEditor(
+                  String(url),
+                  typeof lineNumber === 'number' ? lineNumber : undefined,
+                  typeof columnNumber === 'number' ? columnNumber : undefined,
+                )
+              })
+              clearInterval(timer)
+              timer = null
+            }
+          } catch (_) {}
+          if (tries > 80 && timer !== null) {
+            clearInterval(timer)
+            timer = null
+          }
+        }, 50)
+      } catch (_) {}
+    })()
+  `;
+}
 
 // src/main/services/safe-area/index.ts
 function guestInsets(device, isTabPage2) {
@@ -1157,19 +1477,25 @@ function createSafeAreaController(options = {}) {
 }
 
 // src/main/services/views/devtools-tabs.ts
-var DEVTOOLS_KEPT_VIEW_IDS = ["elements", "console", "network"];
+var DEVTOOLS_KEPT_VIEW_IDS = ["elements", "console", "network", "sources"];
 function buildCustomizeTabsScript(keptIds = DEVTOOLS_KEPT_VIEW_IDS) {
   const NAME_MAP = {
     elements: ["Elements", "\u5143\u7D20"],
     console: ["Console", "\u63A7\u5236\u53F0"],
-    network: ["Network", "\u7F51\u7EDC"]
+    network: ["Network", "\u7F51\u7EDC"],
+    sources: ["Sources", "\u6765\u6E90", "\u6E90\u4EE3\u7801"]
   };
   const keepNames = keptIds.flatMap((id) => NAME_MAP[id] ?? [id]);
   const keepIdsJson = JSON.stringify(JSON.stringify([...keptIds]));
   const keepNamesJson = JSON.stringify(JSON.stringify(keepNames));
+  const srcNamesJson = JSON.stringify(JSON.stringify(NAME_MAP.sources));
+  const netNamesJson = JSON.stringify(JSON.stringify(NAME_MAP.network));
   return `(function(){try{
     var KEEPID = new Set(JSON.parse(${keepIdsJson}));
     var KEEPNAME = new Set(JSON.parse(${keepNamesJson}));
+    var SRCNAME = new Set(JSON.parse(${srcNamesJson}));
+    var NETNAME = new Set(JSON.parse(${netNamesJson}));
+    var WANT_SOURCES_LAST = KEEPID.has('sources');
     // (1) Locale infobar \u2014 official host-preference suppression (NOT localStorage).
     try { var IFH=globalThis.InspectorFrontendHost; if(IFH&&typeof IFH.setPreference==='function'){ IFH.setPreference('disable-locale-info-bar','true'); } }catch(_){}
     function deepCollect(sel,cap){ var out=[],seen=0,stack=[document]; while(stack.length&&seen<(cap||40000)){ var root=stack.pop(); try{var m=root.querySelectorAll?root.querySelectorAll(sel):[];for(var i=0;i<m.length;i++)out.push(m[i]);}catch(_){} try{var all=root.querySelectorAll?root.querySelectorAll('*'):[];for(var j=0;j<all.length;j++){seen++;if(all[j].shadowRoot)stack.push(all[j].shadowRoot);}}catch(_){} } return out; }
@@ -1197,9 +1523,18 @@ function buildCustomizeTabsScript(keptIds = DEVTOOLS_KEPT_VIEW_IDS) {
           handled=true;
         }catch(_){} }
         // fallback: registrations not enumerable -> at least clear the bar by id
-        if(!handled){ var FALL=['timeline','resources','heap-profiler','sources','security','lighthouse','chrome-recorder','coverage','linear-memory-inspector','sensors','rendering','animations','autofill-view','medias','issues-pane']; for(var fr=0;fr<FALL.length;fr++){ try{ if(!KEEPID.has(FALL[fr])) maybeRemove(FALL[fr]); }catch(_){} } }
+        if(!handled){ var FALL=['timeline','resources','heap-profiler','security','lighthouse','chrome-recorder','coverage','linear-memory-inspector','sensors','rendering','animations','autofill-view','medias','issues-pane']; for(var fr=0;fr<FALL.length;fr++){ try{ if(!KEEPID.has(FALL[fr])) maybeRemove(FALL[fr]); }catch(_){} } }
       } else { domFallback(); }
     })();
+    // Keep Sources LAST in the bar (after Network). Default DevTools order puts
+    // Sources between Console and Network; nudge it to just after Network. Runs in
+    // BOTH paths (registry removal leaves the kept tabs in default order). Self-
+    // stable: once Sources follows Network the condition no longer holds.
+    if(WANT_SOURCES_LAST){ var ro=0,rt=setInterval(function(){ ro++; try{
+      var tabs=deepCollect('[role="tab"]'),src=null,net=null;
+      for(var i=0;i<tabs.length;i++){ var n=txt(tabs[i]); if(SRCNAME.has(n))src=tabs[i]; else if(NETNAME.has(n))net=tabs[i]; }
+      if(src&&net&&src.parentElement&&src.parentElement===net.parentElement&&(src.compareDocumentPosition(net)&Node.DOCUMENT_POSITION_FOLLOWING)){ net.parentElement.insertBefore(src,net.nextSibling); }
+    }catch(_){} if(ro>120)clearInterval(rt); },60); }
     // DOM fallback: only if the ESM module couldn't be resolved at all.
     function domFallback(){ var cachedBar=null;
       function findBar(){ if(cachedBar&&cachedBar.isConnected)return cachedBar; cachedBar=null; var tabs=deepCollect('[role="tab"]'); var a=null; for(var i=0;i<tabs.length;i++){if(KEEPNAME.has(txt(tabs[i]))){a=tabs[i];break;}} if(!a)return null; var p=a.parentElement; while(p){try{if(p.querySelectorAll('[role="tab"]').length>1){cachedBar=p;return p;}}catch(_){} p=p.parentElement;} cachedBar=a.parentElement; return cachedBar; }
@@ -1454,10 +1789,19 @@ function installElementsForward(deps) {
   function primeGuest(wc) {
     if (!ensureGuestDebugger(wc)) return;
     wireGuestEvents(wc);
-    for (const domain of ["DOM.enable", "CSS.enable", "Overlay.enable"]) {
-      wc.debugger.sendCommand(domain).catch(() => {
-      });
+    void enableGuestDomains(wc);
+  }
+  async function enableGuestDomains(wc) {
+    wc.debugger.sendCommand("CSS.enable").catch(() => {
+    });
+    try {
+      await wc.debugger.sendCommand("DOM.enable");
+    } catch {
+      return;
     }
+    if (disposed || !isActiveWcId(wc.id)) return;
+    wc.debugger.sendCommand("Overlay.enable").catch(() => {
+    });
   }
   function routeCommand(cmd) {
     const wc = activeRenderWc();
@@ -1477,6 +1821,10 @@ function installElementsForward(deps) {
         replyError(cmd, "stale render generation");
         return;
       }
+      if (cmd.method === "Overlay.disable" && isActiveWcId(cmdWcId)) {
+        wc.debugger.sendCommand("Overlay.enable").catch(() => {
+        });
+      }
       replyResult(cmd, result);
     }).catch((err) => {
       if (disposed) return;
@@ -2022,12 +2370,36 @@ function parseRoute(url) {
 }
 
 // src/main/services/views/view-manager.ts
+function resolveProjectEditorTarget(serviceHostUrl, activeProjectRoot, req, isFile = (absolutePath) => fs4.statSync(absolutePath).isFile()) {
+  const sourceContext = projectSourceContextFromServiceHostUrl(
+    serviceHostUrl,
+    activeProjectRoot
+  );
+  if (!sourceContext) return null;
+  const rel = resourceUrlToProjectRelativePath(req.url, sourceContext);
+  if (!rel) return null;
+  const absolute = path7.resolve(sourceContext.projectRoot, ...rel.split("/"));
+  const fromRoot = path7.relative(path7.resolve(sourceContext.projectRoot), absolute);
+  if (!fromRoot || fromRoot.startsWith("..") || path7.isAbsolute(fromRoot)) return null;
+  try {
+    if (!isFile(absolute)) return null;
+  } catch {
+    return null;
+  }
+  return {
+    path: rel,
+    line: typeof req.line === "number" ? req.line + 1 : void 0,
+    column: typeof req.column === "number" ? req.column + 1 : void 0
+  };
+}
 function createViewManager(ctx) {
   const safeArea = createSafeAreaController({ connections: ctx.connections });
   let simulatorView = null;
   let simulatorViewAdded = false;
   let nativeSimulatorView = null;
   let nativeSimulatorViewAdded = false;
+  let nativeSimulatorProjectPath = null;
+  let settleNativeSimulatorReady = null;
   let lastRendererRect = null;
   let nativeCustomApiBridgeHandler = null;
   let currentZoomFactor = 1;
@@ -2260,37 +2632,13 @@ function createViewManager(ctx) {
     closeNativeDevtoolsSource();
   }
   const openInEditorWiredWcIds = /* @__PURE__ */ new Set();
-  function injectOpenResourceHandler(devtoolsWc) {
-    const scheme = JSON.stringify(OPEN_IN_EDITOR_SCHEME);
-    devtoolsWc.executeJavaScript(`
-      (function() {
-        try {
-          let tries = 0
-          const timer = setInterval(() => {
-            tries++
-            try {
-              const Host = globalThis.Host
-              const host = Host && Host.InspectorFrontendHost
-              if (host && typeof host.setOpenResourceHandler === 'function'
-                       && typeof host.openInNewTab === 'function') {
-                host.setOpenResourceHandler((url, lineNumber, columnNumber) => {
-                  try {
-                    const p = new URLSearchParams()
-                    p.set('u', String(url))
-                    if (typeof lineNumber === 'number') p.set('l', String(lineNumber))
-                    if (typeof columnNumber === 'number') p.set('c', String(columnNumber))
-                    host.openInNewTab(${scheme} + ':?' + p.toString())
-                  } catch (_) {}
-                })
-                clearInterval(timer)
-                return
-              }
-            } catch (_) {}
-            if (tries > 80) clearInterval(timer)
-          }, 50)
-        } catch (_) {}
-      })()
-    `).catch(() => {
+  function injectOpenResourceHandler(serviceWc, devtoolsWc) {
+    const sourceContext = projectSourceContextFromServiceHostUrl(
+      serviceWc.getURL(),
+      ctx.workspace?.getProjectPath?.()
+    );
+    if (!sourceContext) return;
+    devtoolsWc.executeJavaScript(buildDevtoolsProjectSourceLinksScript(sourceContext)).catch(() => {
     });
   }
   function customizeDevtoolsTabs(devtoolsWc) {
@@ -2315,9 +2663,9 @@ function createViewManager(ctx) {
   function wireOpenInEditor(serviceWc, devtoolsWc) {
     if (!devtoolsWc.isDestroyed()) {
       if (devtoolsWc.isLoading()) {
-        devtoolsWc.once("dom-ready", () => injectOpenResourceHandler(devtoolsWc));
+        devtoolsWc.once("dom-ready", () => injectOpenResourceHandler(serviceWc, devtoolsWc));
       } else {
-        injectOpenResourceHandler(devtoolsWc);
+        injectOpenResourceHandler(serviceWc, devtoolsWc);
       }
     }
     if (openInEditorWiredWcIds.has(serviceWc.id)) return;
@@ -2325,11 +2673,13 @@ function createViewManager(ctx) {
     const onOpenUrl = (_event, url) => {
       const req = decodeOpenInEditorUrl(url);
       if (!req) return;
-      const rel = resourceUrlToProjectRelativePath(req.url);
-      if (!rel) return;
-      const line = typeof req.line === "number" ? req.line + 1 : void 0;
-      const column = typeof req.column === "number" ? req.column + 1 : void 0;
-      ctx.notify.editorOpenFile({ path: rel, line, column });
+      const target = resolveProjectEditorTarget(
+        serviceWc.getURL(),
+        ctx.workspace?.getProjectPath?.(),
+        req
+      );
+      if (!target) return;
+      ctx.notify.editorOpenFile(target);
     };
     serviceWc.on("devtools-open-url", onOpenUrl);
     const conn = ctx.connections.acquire(serviceWc);
@@ -2489,8 +2839,10 @@ function createViewManager(ctx) {
   function attachNativeSimulator(simulatorUrl, _simWidth) {
     if (!ctx.preloadPath) {
       console.error("[workbench] attachNativeSimulator \u2014 preloadPath unset; cannot mount native simulator");
-      return;
+      return Promise.resolve();
     }
+    settleNativeSimulatorReady?.();
+    settleNativeSimulatorReady = null;
     if (nativeSimulatorView) {
       detachNativeCustomApiBridge();
       if (nativeSimulatorViewAdded) {
@@ -2508,6 +2860,10 @@ function createViewManager(ctx) {
       }
       nativeSimulatorView = null;
     }
+    nativeSimulatorProjectPath = null;
+    const ready = new Promise((resolve) => {
+      settleNativeSimulatorReady = resolve;
+    });
     const route = parseRoute(simulatorUrl);
     const partition = miniappPartition(route?.appId);
     configureMiniappSession(partition);
@@ -2522,6 +2878,7 @@ function createViewManager(ctx) {
       }
     });
     nativeSimulatorView = view;
+    nativeSimulatorProjectPath = ctx.workspace?.getProjectPath() || null;
     view.setBackgroundColor(simDeskBg());
     const simWc = view.webContents;
     const syncDeskBg = () => {
@@ -2571,6 +2928,11 @@ function createViewManager(ctx) {
           e.preventDefault();
         }
       });
+      guestWc.once("did-finish-load", () => {
+        if (nativeSimulatorView !== view || simWc.isDestroyed()) return;
+        settleNativeSimulatorReady?.();
+        settleNativeSimulatorReady = null;
+      });
       followNativeDevtoolsServiceHost();
     });
     simWc.setWindowOpenHandler(({ url }) => handleWindowOpenExternal(url));
@@ -2599,8 +2961,11 @@ function createViewManager(ctx) {
       setNativeSimulatorViewBounds(lastRendererRect);
     }
     attachNativeSimulatorDevtoolsHost();
+    return ready;
   }
   function detachSimulator() {
+    settleNativeSimulatorReady?.();
+    settleNativeSimulatorReady = null;
     stopFollowingNativeServiceHost();
     detachNativeCustomApiBridge();
     try {
@@ -2634,6 +2999,7 @@ function createViewManager(ctx) {
     simulatorView = null;
     simulatorViewAdded = false;
     simulatorWebContentsId = null;
+    nativeSimulatorProjectPath = null;
     simulatorBoundsOverride = null;
     lastRendererRect = null;
   }
@@ -2785,6 +3151,7 @@ function createViewManager(ctx) {
       const wc = webContents.fromId(simulatorWebContentsId);
       return wc && !wc.isDestroyed() ? wc : null;
     },
+    getSimulatorProjectPath: () => nativeSimulatorProjectPath,
     getSettingsWebContents: () => {
       if (!settingsView) return null;
       if (settingsView.webContents.isDestroyed()) return null;
@@ -2909,20 +3276,20 @@ import { z as z2 } from "zod";
 // src/main/services/projects/project-repository.ts
 import { app as app6 } from "electron";
 import path9 from "path";
-import fs4 from "fs";
+import fs5 from "fs";
 var log2 = createLogger("projects");
 function getProjectsFile() {
   return path9.join(app6.getPath("userData"), "dimina-projects.json");
 }
 function load() {
   try {
-    return JSON.parse(fs4.readFileSync(getProjectsFile(), "utf-8"));
+    return JSON.parse(fs5.readFileSync(getProjectsFile(), "utf-8"));
   } catch {
     return [];
   }
 }
 function save(projects) {
-  fs4.writeFileSync(getProjectsFile(), JSON.stringify(projects, null, 2));
+  fs5.writeFileSync(getProjectsFile(), JSON.stringify(projects, null, 2));
 }
 function listProjects() {
   return load();
@@ -2931,14 +3298,14 @@ function validateProjectDir(dirPath) {
   if (!dirPath) {
     return "\u5C0F\u7A0B\u5E8F\u76EE\u5F55\u8DEF\u5F84\u4E3A\u7A7A\uFF0C\u8BF7\u9009\u62E9\u5305\u542B\u5C0F\u7A0B\u5E8F\u6E90\u7801\u7684\u76EE\u5F55";
   }
-  if (!fs4.existsSync(dirPath)) {
+  if (!fs5.existsSync(dirPath)) {
     return `\u5C0F\u7A0B\u5E8F\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${dirPath}`;
   }
-  if (!fs4.existsSync(path9.join(dirPath, "app.json"))) {
+  if (!fs5.existsSync(path9.join(dirPath, "app.json"))) {
     const configPath = path9.join(dirPath, "project.config.json");
-    if (fs4.existsSync(configPath)) {
+    if (fs5.existsSync(configPath)) {
       try {
-        const cfg = JSON.parse(fs4.readFileSync(configPath, "utf-8"));
+        const cfg = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
         if (cfg.miniprogramRoot) {
           const resolvedRoot = path9.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}`;
@@ -2956,8 +3323,8 @@ function addProject(dirPath) {
   let name = path9.basename(dirPath);
   try {
     const configPath = path9.join(dirPath, "project.config.json");
-    if (fs4.existsSync(configPath)) {
-      const cfg = JSON.parse(fs4.readFileSync(configPath, "utf-8"));
+    if (fs5.existsSync(configPath)) {
+      const cfg = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
       if (cfg.projectname) name = cfg.projectname;
     }
   } catch (err) {
@@ -2997,7 +3364,7 @@ function getProjectPages(dirPath) {
   const appJsonPath = path9.join(dirPath, "app.json");
   try {
     const appJson = JSON.parse(
-      fs4.readFileSync(appJsonPath, "utf-8")
+      fs5.readFileSync(appJsonPath, "utf-8")
     );
     return {
       pages: appJson.pages || [],
@@ -3021,7 +3388,7 @@ function getProjectSettings(projectPath) {
   }
   try {
     const configPath = path9.join(projectPath, "project.config.json");
-    const config = JSON.parse(fs4.readFileSync(configPath, "utf-8"));
+    const config = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
     return {
       uploadWithSourceMap: !!config.setting?.uploadWithSourceMap
     };
@@ -3034,14 +3401,14 @@ function updateProjectSettings(projectPath, patch) {
   const configPath = path9.join(projectPath, "project.config.json");
   let config = {};
   try {
-    config = JSON.parse(fs4.readFileSync(configPath, "utf-8"));
+    config = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
   } catch {
   }
   const nextSetting = {
     ...config.setting ?? {},
     ...patch.uploadWithSourceMap === void 0 ? {} : { uploadWithSourceMap: patch.uploadWithSourceMap }
   };
-  fs4.writeFileSync(
+  fs5.writeFileSync(
     configPath,
     JSON.stringify({ ...config, setting: nextSetting }, null, 2)
   );
@@ -3216,10 +3583,16 @@ function createWorkspaceService(ctx) {
     getLastClosedProjectPath: () => lastClosedProjectPath,
     hasActiveSession: () => currentSession !== null,
     async captureThumbnail(projectPath) {
+      if (!currentSession || projectPath !== currentProjectPath) return null;
       const wc = ctx.views.getSimulatorWebContents();
       if (!wc) return null;
+      if (ctx.views.getSimulatorProjectPath() !== projectPath) return null;
+      const session5 = currentSession;
       try {
         const image = await wc.capturePage();
+        if (currentSession !== session5 || currentProjectPath !== projectPath || ctx.views.getSimulatorWebContents() !== wc || ctx.views.getSimulatorProjectPath() !== projectPath) {
+          return null;
+        }
         const dataUrl = `data:image/png;base64,${image.toPNG().toString("base64")}`;
         if (provider.saveThumbnail) {
           await provider.saveThumbnail(projectPath, dataUrl);
@@ -3253,7 +3626,7 @@ function createWorkspaceService(ctx) {
 
 // src/main/services/projects/thumbnail.ts
 import { createHash } from "crypto";
-import fs5 from "fs";
+import fs6 from "fs";
 import path10 from "path";
 import { app as app7 } from "electron";
 function getThumbnailDir() {
@@ -3269,13 +3642,13 @@ var DATA_URL_PNG_PREFIX = "data:image/png;base64,";
 function saveThumbnailFromDataUrl(projectPath, imageDataUrl) {
   if (!imageDataUrl.startsWith(DATA_URL_PNG_PREFIX)) return;
   const png = Buffer.from(imageDataUrl.slice(DATA_URL_PNG_PREFIX.length), "base64");
-  fs5.mkdirSync(getThumbnailDir(), { recursive: true });
-  fs5.writeFileSync(getThumbnailPath(projectPath), png);
+  fs6.mkdirSync(getThumbnailDir(), { recursive: true });
+  fs6.writeFileSync(getThumbnailPath(projectPath), png);
 }
 function loadThumbnail(projectPath) {
   const filePath = getThumbnailPath(projectPath);
   try {
-    const buf = fs5.readFileSync(filePath);
+    const buf = fs6.readFileSync(filePath);
     return `${DATA_URL_PNG_PREFIX}${buf.toString("base64")}`;
   } catch {
     return null;
@@ -3635,7 +4008,7 @@ function deviceInfoToHostEnv(d) {
 function registerSimulatorIpc(ctx) {
   return new IpcRegistry(ctx.senderPolicy).handle(SimulatorChannel.AttachNative, (_, ...args) => {
     const [simulatorUrl, simWidth] = validate(SimulatorChannel.AttachNative, SimulatorAttachNativeSchema, args);
-    ctx.views.attachNativeSimulator(simulatorUrl, simWidth);
+    return ctx.views.attachNativeSimulator(simulatorUrl, simWidth);
   }).handle(SimulatorChannel.Detach, () => {
     ctx.views.detachSimulator();
   }).handle(SimulatorChannel.SetNativeBounds, (_, ...args) => {
@@ -3677,7 +4050,7 @@ import { app as app8, dialog } from "electron";
 import path13 from "path";
 
 // src/main/services/projects/create-project-service.ts
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import path12 from "node:path";
 var DEFAULT_TEMPLATE_ID = "blank";
 async function createProject(input, ctx) {
@@ -3689,12 +4062,12 @@ async function createProject(input, ctx) {
   if (!target || typeof target !== "string") {
     throw new Error("Project path is required");
   }
-  if (fs6.existsSync(target)) {
-    const stat = fs6.statSync(target);
+  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 = fs6.readdirSync(target);
+    const entries = fs7.readdirSync(target);
     if (entries.length > 0) {
       throw new Error(
         `Project path is not empty (refusing to overwrite): ${target}`
@@ -3711,31 +4084,31 @@ async function createProject(input, ctx) {
       `Template '${templateId}' has neither a source directory nor a generate function`
     );
   }
-  fs6.mkdirSync(target, { recursive: true });
+  fs7.mkdirSync(target, { recursive: true });
   if (template.generate) {
     await template.generate(target, { name });
   } else if (template.source) {
-    if (!fs6.existsSync(template.source.path)) {
+    if (!fs7.existsSync(template.source.path)) {
       throw new Error(
         `Template source missing on disk: ${template.source.path}`
       );
     }
-    fs6.cpSync(template.source.path, target, {
+    fs7.cpSync(template.source.path, target, {
       recursive: true,
       force: true
     });
   }
   const cfgPath = path12.join(target, "project.config.json");
   let cfg = {};
-  if (fs6.existsSync(cfgPath)) {
+  if (fs7.existsSync(cfgPath)) {
     try {
-      cfg = JSON.parse(fs6.readFileSync(cfgPath, "utf-8"));
+      cfg = JSON.parse(fs7.readFileSync(cfgPath, "utf-8"));
     } catch {
       cfg = {};
     }
   }
   cfg.projectname = name;
-  fs6.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+  fs7.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
   const created = await ctx.projectsProvider.addProject(target);
   return created;
 }
@@ -3997,7 +4370,7 @@ import { createDebugTap } from "@dimina-kit/electron-deck/main";
 
 // src/main/services/dimina-resource-server.ts
 import http from "node:http";
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 import path14 from "node:path";
 var MIME_TYPES = {
   ".css": "text/css; charset=utf-8",
@@ -4055,7 +4428,7 @@ async function handleRequest(root, req, res) {
     return;
   }
   try {
-    const stat = await fs7.promises.stat(filePath);
+    const stat = await fs8.promises.stat(filePath);
     if (!stat.isFile()) {
       res.writeHead(404);
       res.end("Not Found");
@@ -4070,7 +4443,7 @@ async function handleRequest(root, req, res) {
       res.end();
       return;
     }
-    fs7.createReadStream(filePath).pipe(res);
+    fs8.createReadStream(filePath).pipe(res);
   } catch {
     res.writeHead(404);
     res.end("Not Found");
@@ -4120,6 +4493,7 @@ function buildServiceHostSpawnUrl(opts) {
   url.searchParams.set("appId", opts.appId);
   url.searchParams.set("pagePath", opts.pagePath);
   url.searchParams.set("pkgRoot", opts.pkgRoot);
+  url.searchParams.set("root", opts.root || "main");
   url.searchParams.set("resourceBaseUrl", opts.resourceBaseUrl);
   if (opts.hostEnvSnapshot) {
     url.searchParams.set("hostEnv", encodeURIComponent(JSON.stringify(opts.hostEnvSnapshot)));
@@ -5358,7 +5732,8 @@ async function handleSpawn(state, ctx, event, opts) {
   const appSessionId = bridgeId;
   const simulatorWc = resolveSimulatorWebContents(ctx, opts.simulatorWcId, event.sender);
   const pagePath = normalizePagePath(opts.pagePath || "pages/index/index");
-  const pkgRoot = path16.resolve(opts.pkgRoot || process.cwd());
+  const workspaceProjectPath = typeof ctx.workspace.getProjectPath === "function" ? ctx.workspace.getProjectPath() : "";
+  const pkgRoot = path16.resolve(opts.pkgRoot || workspaceProjectPath || process.cwd());
   const root = opts.root || "main";
   let resourceServer = null;
   let resourceBaseUrl;
@@ -5392,6 +5767,7 @@ async function handleSpawn(state, ctx, event, opts) {
       appId,
       pagePath,
       pkgRoot,
+      root,
       resourceBaseUrl,
       hostEnvSnapshot: hostEnv
     });
@@ -5469,6 +5845,7 @@ async function handleSpawn(state, ctx, event, opts) {
         appId,
         pagePath,
         pkgRoot,
+        root,
         resourceBaseUrl,
         hostEnvSnapshot: hostEnv
       })
@@ -5860,13 +6237,13 @@ function makeLoadResource(ap, page, target) {
       // dimina's service runtime reads hostEnv as `{ systemInfo, menuRect }`
       // (core/host-env.js init → getSystemInfo/getMenuRect; invokeAPI resolves
       // getSystemInfoSync/getWindowInfo/getDeviceInfo from hostEnv.systemInfo).
-      // We previously sent the FLAT HostEnvSnapshot, so `systemInfo` was null →
-      // `wx.getSystemInfoSync()` returned null and pages reading
-      // `.screenWidth` threw. Nest it under `systemInfo`. (render does NOT read
-      // hostEnv, so this is service-only; the devtools sync-api-patch reads the
-      // separate __diminaSpawnContext.hostEnvSnapshot and is unaffected.)
-      // menuRect stays null as before — getMenuButtonBoundingClientRect is
-      // served by the sync-api-patch / DeviceShell capsule, not this path.
+      // The snapshot must be nested under `systemInfo`: a FLAT HostEnvSnapshot
+      // leaves `systemInfo` null → `wx.getSystemInfoSync()` returns null and
+      // pages reading `.screenWidth` throw. (render does NOT read hostEnv, so
+      // this is service-only; the devtools sync-api-patch reads the separate
+      // __diminaSpawnContext.hostEnvSnapshot and is unaffected.)
+      // menuRect stays null — getMenuButtonBoundingClientRect is served by the
+      // sync-api-patch / DeviceShell capsule, not this path.
       hostEnv: { systemInfo: ap.hostEnv, menuRect: null }
     }
   };
@@ -8096,7 +8473,7 @@ var AppDataAccumulator = class {
   }
   /**
    * Apply one entry. Returns true if it was accepted (a mutation worth
-   * republishing), false if dropped (missing ids, or the R6 gate).
+   * republishing), false if dropped (missing ids, or the init-gate).
    */
   apply(input) {
     if (!input.bridgeId || !input.moduleId) return false;
@@ -8244,10 +8621,35 @@ function setupSimulatorCurrentPage(host, options) {
 import { readFileSync } from "node:fs";
 import path17 from "node:path";
 var DEFAULT_SOURCE_PATH = "dist/render-host/render-inspect.js";
+var HIGHLIGHT_CONFIG = {
+  showInfo: true,
+  showRulers: false,
+  showExtensionLines: false,
+  contentColor: { r: 111, g: 168, b: 220, a: 0.66 },
+  paddingColor: { r: 147, g: 196, b: 125, a: 0.55 },
+  borderColor: { r: 255, g: 229, b: 153, a: 0.66 },
+  marginColor: { r: 246, g: 178, b: 107, a: 0.66 }
+};
+var HOVER_OBJECT_GROUP = "render-inspect-hover";
+var ENABLE_HANDSHAKE_TIMEOUT_MS = 500;
+function withTimeout(p, ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    p.then(() => {
+      clearTimeout(timer);
+      resolve();
+    }, () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
 function createRenderInspector(options = {}) {
   const loadSource = options.loadSource ?? (() => readFileSync(path17.join(devtoolsPackageRoot, DEFAULT_SOURCE_PATH), "utf8"));
   let cachedSource = null;
   const injected = /* @__PURE__ */ new Set();
+  const selfAttached = /* @__PURE__ */ new Set();
+  const enablePromises = /* @__PURE__ */ new Map();
   function source() {
     if (cachedSource === null) cachedSource = loadSource();
     return cachedSource;
@@ -8269,10 +8671,14 @@ function createRenderInspector(options = {}) {
       return false;
     }
     injected.add(wc.id);
+    const forget = () => {
+      injected.delete(wc.id);
+      enablePromises.delete(wc.id);
+    };
     if (options.connections) {
-      options.connections.acquire(wc).own(() => injected.delete(wc.id));
+      options.connections.acquire(wc).own(forget);
     } else {
-      wc.once("destroyed", () => injected.delete(wc.id));
+      wc.once("destroyed", forget);
     }
     return true;
   }
@@ -8291,22 +8697,97 @@ function createRenderInspector(options = {}) {
   async function highlight(wc, sid) {
     if (wc.isDestroyed()) return null;
     if (!await ensureInjected(wc)) return null;
+    let inspection;
     try {
       const result = await wc.executeJavaScript(
         `window.__diminaRenderInspect ? window.__diminaRenderInspect.highlightElement(${JSON.stringify(sid)}) : null`
       );
-      return result ?? null;
+      inspection = result ?? null;
     } catch {
       return null;
     }
+    if (!inspection) return null;
+    await drawNativeHighlight(wc, sid).catch(() => {
+    });
+    return inspection;
+  }
+  async function drawNativeHighlight(wc, sid) {
+    if (wc.isDestroyed()) return;
+    if (!ensureGuestDebugger(wc)) return;
+    await withTimeout(ensureDomainsEnabled(wc), ENABLE_HANDSHAKE_TIMEOUT_MS);
+    if (wc.isDestroyed()) return;
+    const expression = `window.__diminaRenderInspect && window.__diminaRenderInspect.elementFor(${JSON.stringify(sid)})`;
+    try {
+      const evaluated = await wc.debugger.sendCommand("Runtime.evaluate", {
+        expression,
+        returnByValue: false,
+        objectGroup: HOVER_OBJECT_GROUP
+      });
+      const objectId = evaluated?.result?.objectId;
+      if (!objectId) return;
+      await wc.debugger.sendCommand("Overlay.highlightNode", {
+        objectId,
+        highlightConfig: HIGHLIGHT_CONFIG
+      });
+    } finally {
+      wc.debugger.sendCommand("Runtime.releaseObjectGroup", { objectGroup: HOVER_OBJECT_GROUP }).catch(() => {
+      });
+    }
+  }
+  function ensureGuestDebugger(wc) {
+    try {
+      if (wc.debugger.isAttached()) return true;
+    } catch {
+      return false;
+    }
+    try {
+      wc.debugger.attach("1.3");
+      trackSelfAttached(wc);
+      return true;
+    } catch {
+      try {
+        return wc.debugger.isAttached();
+      } catch {
+        return false;
+      }
+    }
+  }
+  function trackSelfAttached(wc) {
+    if (selfAttached.has(wc.id)) return;
+    selfAttached.add(wc.id);
+    const detach = () => {
+      selfAttached.delete(wc.id);
+      try {
+        if (!wc.isDestroyed() && wc.debugger.isAttached()) wc.debugger.detach();
+      } catch {
+      }
+    };
+    if (options.connections) options.connections.acquire(wc).own(detach);
+    else {
+      try {
+        wc.once("destroyed", () => selfAttached.delete(wc.id));
+      } catch {
+      }
+    }
+  }
+  function ensureDomainsEnabled(wc) {
+    const cached = enablePromises.get(wc.id);
+    if (cached) return cached;
+    wc.debugger.sendCommand("CSS.enable").catch(() => {
+    });
+    const handshake = wc.debugger.sendCommand("DOM.enable").then(() => {
+      if (wc.isDestroyed()) return;
+      return wc.debugger.sendCommand("Overlay.enable");
+    }).then(() => void 0).catch(() => {
+      enablePromises.delete(wc.id);
+    });
+    enablePromises.set(wc.id, handshake);
+    return handshake;
   }
   async function unhighlight(wc) {
     if (wc.isDestroyed()) return;
-    if (!await ensureInjected(wc)) return;
     try {
-      await wc.executeJavaScript(
-        "window.__diminaRenderInspect && window.__diminaRenderInspect.unhighlightElement && window.__diminaRenderInspect.unhighlightElement()"
-      );
+      await wc.debugger.sendCommand("Overlay.hideHighlight");
     } catch {
     }
   }
@@ -8379,7 +8860,7 @@ function resolveVPath(url) {
 }
 
 // src/main/services/simulator-temp-files/disk.ts
-import fs8 from "node:fs/promises";
+import fs9 from "node:fs/promises";
 import path19 from "node:path";
 var EXT_MIME = {
   ".txt": "text/plain",
@@ -8460,7 +8941,7 @@ function etagOf(mtimeMs, size) {
   return `W/"${Math.floor(mtimeMs)}-${size}"`;
 }
 async function readDiskFile(realPath, opts) {
-  const handle = await fs8.open(realPath, "r");
+  const handle = await fs9.open(realPath, "r");
   try {
     const st = await handle.stat();
     const totalSize = st.size;
@@ -8515,15 +8996,15 @@ async function readDiskFile(realPath, opts) {
 }
 async function writeDiskFile(realPath, bytes) {
   const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(new Uint8Array(bytes));
-  await fs8.mkdir(path19.dirname(realPath), { recursive: true });
-  await fs8.writeFile(realPath, buf);
+  await fs9.mkdir(path19.dirname(realPath), { recursive: true });
+  await fs9.writeFile(realPath, buf);
 }
 async function readDiskDir(realPath) {
-  const entries = await fs8.readdir(realPath);
+  const entries = await fs9.readdir(realPath);
   return entries;
 }
 async function statDiskFile(realPath) {
-  const st = await fs8.stat(realPath);
+  const st = await fs9.stat(realPath);
   return {
     size: st.size,
     mtime: Math.floor(st.mtimeMs),
@@ -8656,14 +9137,14 @@ async function handleDifileRequest(ctx, req) {
 }
 
 // src/main/services/simulator-temp-files/fs-channels.ts
-import fs9 from "node:fs/promises";
+import fs10 from "node:fs/promises";
 import path20 from "node:path";
 async function enforceSandbox(realPath) {
   if (typeof realPath !== "string" || realPath.length === 0) {
     throw new Error("sandbox: realPath must be a non-empty string");
   }
   const base = sandboxBase();
-  const baseReal = await fs9.realpath(base).catch(() => base);
+  const baseReal = await fs10.realpath(base).catch(() => base);
   const normalized = path20.normalize(realPath);
   if (normalized !== base && !normalized.startsWith(base + path20.sep)) {
     throw new Error("sandbox: realPath escapes the user-data base");
@@ -8671,7 +9152,7 @@ async function enforceSandbox(realPath) {
   let probe = normalized;
   while (probe !== path20.parse(probe).root) {
     try {
-      const resolved = await fs9.realpath(probe);
+      const resolved = await fs10.realpath(probe);
       if (resolved !== baseReal && !resolved.startsWith(baseReal + path20.sep)) {
         throw new Error("sandbox: realPath escapes the user-data base via symlink");
       }
@@ -8711,12 +9192,12 @@ async function handleFsReaddir(req) {
 }
 async function handleFsUnlink(req) {
   const safe = await enforceSandbox(req.realPath);
-  await fs9.unlink(safe);
+  await fs10.unlink(safe);
   return { ok: true };
 }
 async function handleFsMkdir(req) {
   const safe = await enforceSandbox(req.realPath);
-  await fs9.mkdir(safe, { recursive: !!req.recursive });
+  await fs10.mkdir(safe, { recursive: !!req.recursive });
   return { ok: true };
 }
 
@@ -9149,9 +9630,12 @@ function wireAppWindowEvents(config, instance) {
     onResize: () => context.views.repositionAll(),
     onClose: async (e) => {
       if (isAppQuitting()) return;
+      if (closing) {
+        e.preventDefault();
+        return;
+      }
       if (!context.workspace.hasActiveSession()) return;
       e.preventDefault();
-      if (closing) return;
       closing = true;
       try {
         if (config.onBeforeClose) {
@@ -9171,7 +9655,7 @@ function enableDevRendererAutoReload(rendererDir2) {
     });
   }
   let reloadTimer = null;
-  const watcher = fs10.watch(rendererDir2, { recursive: true }, () => {
+  const watcher = fs11.watch(rendererDir2, { recursive: true }, () => {
     if (reloadTimer) clearTimeout(reloadTimer);
     reloadTimer = setTimeout(() => {
       for (const win of BrowserWindow8.getAllWindows()) {