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

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,218 @@ 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 normalizedRaw = normalizeSlashPath(raw);
+  if (projectRoot && (normalizedRaw === projectRoot || normalizedRaw.startsWith(`${projectRoot}/`))) {
+    const relative = normalizedRaw.slice(projectRoot.length).replace(/^\/+/, "");
+    return 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 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 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 = []
+        let timer = null
+        const state = {
+          dispose() {
+            if (timer !== null) {
+              clearInterval(timer)
+              timer = null
+            }
+            for (const observer of observers.splice(0)) {
+              try { observer.disconnect() } catch (_) {}
+            }
+            observedRoots.clear()
+          },
+        }
+        globalThis[stateKey] = state
+
+        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)
+
+          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)
+
+        let tries = 0
+        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 {
+                  if (!diminaProjectSourcePath(String(url), cfg)) return
+                  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)
+              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) {
@@ -2022,12 +2238,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 +2500,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 +2531,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 +2541,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 +2707,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 +2728,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 +2746,7 @@ function createViewManager(ctx) {
       }
     });
     nativeSimulatorView = view;
+    nativeSimulatorProjectPath = ctx.workspace?.getProjectPath() || null;
     view.setBackgroundColor(simDeskBg());
     const simWc = view.webContents;
     const syncDeskBg = () => {
@@ -2571,6 +2796,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 +2829,11 @@ function createViewManager(ctx) {
       setNativeSimulatorViewBounds(lastRendererRect);
     }
     attachNativeSimulatorDevtoolsHost();
+    return ready;
   }
   function detachSimulator() {
+    settleNativeSimulatorReady?.();
+    settleNativeSimulatorReady = null;
     stopFollowingNativeServiceHost();
     detachNativeCustomApiBridge();
     try {
@@ -2634,6 +2867,7 @@ function createViewManager(ctx) {
     simulatorView = null;
     simulatorViewAdded = false;
     simulatorWebContentsId = null;
+    nativeSimulatorProjectPath = null;
     simulatorBoundsOverride = null;
     lastRendererRect = null;
   }
@@ -2785,6 +3019,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 +3144,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 +3166,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 +3191,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 +3232,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 +3256,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 +3269,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 +3451,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 +3494,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 +3510,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 +3876,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 +3918,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 +3930,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 +3952,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 +4238,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 +4296,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 +4311,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 +4361,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 +5600,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 +5635,7 @@ async function handleSpawn(state, ctx, event, opts) {
       appId,
       pagePath,
       pkgRoot,
+      root,
       resourceBaseUrl,
       hostEnvSnapshot: hostEnv
     });
@@ -5469,6 +5713,7 @@ async function handleSpawn(state, ctx, event, opts) {
         appId,
         pagePath,
         pkgRoot,
+        root,
         resourceBaseUrl,
         hostEnvSnapshot: hostEnv
       })
@@ -5860,13 +6105,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 +8341,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;
@@ -8379,7 +8624,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 +8705,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 +8760,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 +8901,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 +8916,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 +8956,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 +9394,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 +9419,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()) {