@dimina-kit/devtools 0.3.2-dev.20260524104239 → 0.3.2-dev.20260601115343

package/dist/main/index.bundle.js

@@ -1,5 +1,5 @@
 // src/main/app/bootstrap.ts
-import { app as app2 } from "electron";
+import { app as app2, protocol } from "electron";
 
 // src/shared/constants.ts
 var DEFAULT_CDP_PORT = 9222;
@@ -63,6 +63,24 @@ function applyTheme(theme) {
 }
 
 // src/main/app/bootstrap.ts
+var difileSchemeRegistered = false;
+function registerDifileScheme() {
+  if (difileSchemeRegistered) return;
+  difileSchemeRegistered = true;
+  protocol.registerSchemesAsPrivileged([
+    {
+      scheme: "difile",
+      privileges: {
+        standard: true,
+        secure: true,
+        supportFetchAPI: true,
+        stream: true,
+        bypassCSP: true,
+        corsEnabled: true
+      }
+    }
+  ]);
+}
 function setupCdpPort() {
   if (app2.commandLine.getSwitchValue("remote-debugging-port")) return;
   const envPort = process.env.DIMINA_DEBUG_PORT;
@@ -78,101 +96,675 @@ function setupCdpPort() {
   }
 }
 
+// src/main/ipc/project-fs.ts
+import fs2 from "node:fs/promises";
+import nodeFs from "node:fs";
+import path2 from "node:path";
+import { z } from "zod";
+
+// src/main/utils/ipc-registry.ts
+import { ipcMain } from "electron";
+
+// src/main/utils/disposable.ts
+function toDisposable(fn) {
+  let done = false;
+  return {
+    dispose() {
+      if (done) return;
+      done = true;
+      return fn();
+    }
+  };
+}
+var DisposableRegistry = class {
+  entries = [];
+  _disposed = false;
+  /**
+   * Number of live entries. A wrapper's `dispose` splices its entry out and
+   * `disposeAll` clears the array, so `entries.length` is the live count.
+   */
+  get size() {
+    return this.entries.length;
+  }
+  add(d) {
+    if (this._disposed) {
+      throw new Error("cannot add to disposed registry");
+    }
+    const fn = typeof d === "function" ? d : () => d.dispose();
+    const entry = { fn, released: false };
+    this.entries.push(entry);
+    return {
+      dispose: () => {
+        if (entry.released) return;
+        entry.released = true;
+        const i = this.entries.indexOf(entry);
+        if (i >= 0) this.entries.splice(i, 1);
+        return fn();
+      }
+    };
+  }
+  async disposeAll() {
+    if (this._disposed) return;
+    this._disposed = true;
+    const items = this.entries.slice().reverse();
+    this.entries = [];
+    const errors = [];
+    for (const entry of items) {
+      if (entry.released) continue;
+      entry.released = true;
+      try {
+        await entry.fn();
+      } catch (e) {
+        errors.push(e);
+      }
+    }
+    if (errors.length > 0) {
+      throw new AggregateError(errors, "DisposableRegistry encountered errors during disposeAll");
+    }
+  }
+  dispose() {
+    return this.disposeAll();
+  }
+};
+
+// src/main/utils/ipc-schema.ts
+var IpcValidationError = class extends Error {
+  channel;
+  paths;
+  constructor(channel, issues) {
+    const paths = issues.map((i) => i.path.map((p) => String(p)).join(".") || "<root>");
+    super(`Invalid IPC arguments for ${channel}`);
+    this.name = "IpcValidationError";
+    this.channel = channel;
+    this.paths = paths;
+  }
+};
+function validate(channel, schema, args) {
+  const r = schema.safeParse(args);
+  if (!r.success) {
+    console.warn("[ipc] schema reject", channel, r.error.issues);
+    throw new IpcValidationError(channel, r.error.issues);
+  }
+  return r.data;
+}
+
+// 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);
+    }
+  };
+}
+
+// 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(", ")}]`);
+    return;
+  }
+  if (err instanceof Error) {
+    log.error(`listener threw on '${channel}': ${err.message}`, err.stack);
+    return;
+  }
+  log.error(`listener threw on '${channel}'`, err);
+}
+function isThenable(v) {
+  return v != null && (typeof v === "object" || typeof v === "function") && typeof v.then === "function";
+}
+function summarizeSender(sender) {
+  if (sender.isDestroyed()) return "<destroyed>";
+  const url = sender.getURL();
+  return `id=${sender.id} ${url.slice(0, 120)}`;
+}
+var IpcRegistry = class {
+  constructor(policy) {
+    this.policy = policy;
+  }
+  policy;
+  registry = new DisposableRegistry();
+  handle(channel, fn) {
+    const policy = this.policy;
+    const guarded = policy ? async (event, ...args) => {
+      const sender = event.sender;
+      if (!policy(sender)) {
+        console.warn(
+          `[ipc] sender rejected for channel '${channel}' (${summarizeSender(sender)})`
+        );
+        throw new Error(`IPC sender rejected for channel ${channel}`);
+      }
+      return fn(event, ...args);
+    } : fn;
+    ipcMain.handle(channel, guarded);
+    this.registry.add(() => ipcMain.removeHandler(channel));
+    return this;
+  }
+  /**
+   * Register a SYNCHRONOUS `ipcRenderer.sendSync` handler. Unlike {@link on}
+   * (fire-and-forget), the renderer is blocked until we set `event.returnValue`,
+   * so `fn` MUST be synchronous and return the value to hand back. The sender
+   * policy gates it like {@link handle}; a rejected sender or a thrown error
+   * yields a structured `{ ok: false, code, message }` returnValue instead of
+   * the silent drop `on` uses, so the blocked renderer always gets an answer.
+   */
+  handleSync(channel, fn) {
+    const policy = this.policy;
+    const listener = (event, ...args) => {
+      try {
+        if (policy && !policy(event.sender)) {
+          console.warn(
+            `[ipc] sender rejected for channel '${channel}' (${summarizeSender(event.sender)})`
+          );
+          event.returnValue = {
+            ok: false,
+            code: "EREJECTED",
+            message: `IPC sender rejected for channel ${channel}`
+          };
+          return;
+        }
+        event.returnValue = fn(event, ...args);
+      } catch (err) {
+        reportListenerError(channel, err);
+        const code = err?.code;
+        event.returnValue = {
+          ok: false,
+          code: typeof code === "string" ? code : "EUNKNOWN",
+          message: err instanceof Error ? err.message : String(err)
+        };
+      }
+    };
+    ipcMain.on(channel, listener);
+    this.registry.add(() => {
+      ipcMain.removeListener(channel, listener);
+    });
+    return this;
+  }
+  on(channel, fn) {
+    const policy = this.policy;
+    const raw = fn;
+    const safeInvoke = (event, args) => {
+      try {
+        const ret = raw(event, ...args);
+        if (isThenable(ret)) {
+          Promise.resolve(ret).catch((err) => reportListenerError(channel, err));
+        }
+      } catch (err) {
+        reportListenerError(channel, err);
+      }
+    };
+    const guarded = policy ? (event, ...args) => {
+      const sender = event.sender;
+      if (!policy(sender)) {
+        console.warn(
+          `[ipc] sender rejected for channel '${channel}' (${summarizeSender(sender)})`
+        );
+        return;
+      }
+      safeInvoke(event, args);
+    } : (event, ...args) => safeInvoke(event, args);
+    ipcMain.on(channel, guarded);
+    this.registry.add(() => {
+      ipcMain.removeListener(channel, guarded);
+    });
+    return this;
+  }
+  dispose() {
+    return this.registry.dispose();
+  }
+};
+
+// src/shared/ipc-channels.ts
+var SimulatorChannel = {
+  Attach: "simulator:attach",
+  Detach: "simulator:detach",
+  Resize: "simulator:resize",
+  SetVisible: "simulator:setVisible",
+  Console: "simulator:console"
+};
+var SimulatorCustomApiChannel = {
+  List: "simulator:custom-apis:list",
+  Invoke: "simulator:custom-apis:invoke"
+};
+var SimulatorStorageChannel = {
+  GetSnapshot: "simulator:storage:snapshot",
+  GetActivePrefix: "simulator:storage:activePrefix",
+  Set: "simulator:storage:set",
+  Remove: "simulator:storage:remove",
+  Clear: "simulator:storage:clear",
+  ClearAll: "simulator:storage:clearAll",
+  Event: "simulator:storage:event"
+};
+var SimulatorElementChannel = {
+  Inspect: "simulator:element:inspect",
+  Clear: "simulator:element:clear"
+};
+var WorkbenchSettingsChannel = {
+  Get: "workbenchSettings:get",
+  Save: "workbenchSettings:save",
+  SetTheme: "workbenchSettings:setTheme",
+  GetCdpStatus: "workbenchSettings:getCdpStatus",
+  GetMcpStatus: "workbenchSettings:getMcpStatus",
+  SetVisible: "workbenchSettings:setVisible",
+  Init: "workbenchSettings:init"
+};
+var ProjectChannel = {
+  Open: "project:open",
+  Close: "project:close",
+  GetPages: "project:getPages",
+  GetCompileConfig: "project:getCompileConfig",
+  SaveCompileConfig: "project:saveCompileConfig",
+  Status: "project:status",
+  CaptureThumbnail: "project:captureThumbnail",
+  GetThumbnail: "project:getThumbnail"
+};
+var ProjectFsChannel = {
+  GetRoot: "project:fs:getRoot",
+  ReadFile: "project:fs:readFile",
+  WriteFile: "project:fs:writeFile",
+  /**
+   * Synchronous (blocking) write, used ONLY by the editor's `beforeunload`
+   * flush: a hard window/app close tears the renderer down before an async
+   * `WriteFile` IPC can round-trip, so the last in-debounce-window edit would
+   * be lost. `sendSync` blocks page teardown until the bytes hit disk. Runs the
+   * SAME sandbox as `WriteFile` (see project-fs `writeFileSync`).
+   */
+  WriteFileSync: "project:fs:writeFileSync",
+  ListFiles: "project:fs:listFiles"
+};
+var ProjectsChannel = {
+  List: "projects:list",
+  Add: "projects:add",
+  Remove: "projects:remove",
+  /** Phase 3: merged + sanitized template catalog for the create-project dialog. */
+  ListTemplates: "projects:listTemplates",
+  /** Phase 3: host-supplied create-project dialog hook (returns input or null). */
+  OpenCreateDialog: "projects:openCreateDialog",
+  /** Phase 3: 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"
+};
+var DialogChannel = {
+  OpenDirectory: "dialog:openDirectory"
+};
+var PanelChannel = {
+  List: "panel:list",
+  Eval: "panel:eval",
+  Select: "panel:select",
+  SelectSimulator: "panel:selectSimulator"
+};
+var ViewChannel = {
+  /** Update the simulator DevTools view's bounds (or hide if w/h = 0). */
+  SimulatorDevtoolsBounds: "view:simulator:devtools-bounds"
+};
+var PopoverChannel = {
+  Show: "popover:show",
+  Hide: "popover:hide",
+  Relaunch: "popover:relaunch",
+  Closed: "popover:closed",
+  Init: "popover:init"
+};
+var ToolbarChannel = {
+  GetActions: "toolbar:getActions",
+  ActionsChanged: "toolbar:actionsChanged",
+  /** Invoke a toolbar action by id: `invoke(Invoke, actionId)`. */
+  Invoke: "toolbar:invoke"
+};
+var WindowChannel = {
+  NavigateBack: "window:navigateBack"
+};
+var AppChannel = {
+  GetPreloadPath: "app:getPreloadPath",
+  GetBranding: "app:getBranding",
+  GetHeaderHeight: "app:getHeaderHeight"
+};
+var AutomationChannel = {
+  GetPort: "automation:port"
+};
+var SettingsChannel = {
+  SetVisible: "settings:setVisible",
+  ConfigChanged: "settings:configChanged",
+  ProjectSettingsChanged: "settings:projectSettingsChanged",
+  Init: "settings:init",
+  Closed: "settings:closed",
+  Changed: "settings:changed"
+};
+var UpdateChannel = {
+  Check: "updates:check",
+  Download: "updates:download",
+  Install: "updates:install",
+  DownloadProgress: "updates:downloadProgress",
+  Available: "updates:available"
+};
+
+// src/main/ipc/project-fs.ts
+var LIST_FILE_LIMIT = 5e3;
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".svn",
+  ".hg",
+  "dist",
+  "build",
+  ".next",
+  ".cache",
+  ".turbo",
+  ".parcel-cache",
+  ".nuxt",
+  ".output",
+  ".vite"
+]);
+var PathArg = z.string().min(1);
+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;
+}
+function isWithin(parent, child) {
+  if (child === parent) return true;
+  const rel = path2.relative(parent, child);
+  return rel.length > 0 && !rel.startsWith(".." + path2.sep) && rel !== ".." && !path2.isAbsolute(rel);
+}
+function enforceWithinProjectRoot(abs, root) {
+  if (root === "") {
+    throw makeError("ENOACTIVE", "No active project \u2014 open a project before using the editor file system");
+  }
+  if (typeof abs !== "string" || abs.length === 0) {
+    throw makeError("EINVAL", "path must be a non-empty string");
+  }
+  if (abs.includes("\0") || root.includes("\0")) {
+    throw makeError("EINVAL", "path must not contain NUL bytes");
+  }
+  const resolvedRoot = path2.resolve(root);
+  const resolved = path2.resolve(abs);
+  if (!isWithin(resolvedRoot, resolved)) {
+    throw makeError("EACCES", `Path escapes project root: ${resolved}`);
+  }
+  return resolved;
+}
+function pickWriteRoot(absPath, roots) {
+  const resolved = path2.resolve(absPath);
+  if (roots.current !== "" && isWithin(path2.resolve(roots.current), resolved)) {
+    return roots.current;
+  }
+  if (roots.lastClosed !== "" && isWithin(path2.resolve(roots.lastClosed), resolved)) {
+    return roots.lastClosed;
+  }
+  if (roots.current === "" && roots.lastClosed === "") {
+    throw makeError("ENOACTIVE", "No active project \u2014 open a project before using the editor file system");
+  }
+  throw makeError("EACCES", `Path escapes project root: ${resolved}`);
+}
+async function resolveWithinProjectRoot(abs, root) {
+  const lexical = enforceWithinProjectRoot(abs, root);
+  const realRoot = await fs2.realpath(path2.resolve(root));
+  let realTarget;
+  try {
+    realTarget = await fs2.realpath(lexical);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+    const parent = path2.dirname(lexical);
+    const realParent = await fs2.realpath(parent);
+    if (!isWithin(realRoot, realParent)) {
+      throw makeError("EACCES", `Path escapes project root: ${lexical}`);
+    }
+    return path2.join(realParent, path2.basename(lexical));
+  }
+  if (!isWithin(realRoot, realTarget)) {
+    throw makeError("EACCES", `Path escapes project root: ${realTarget}`);
+  }
+  return realTarget;
+}
+async function assertOpenedWithinRoot(safe, root) {
+  const realRoot = await fs2.realpath(path2.resolve(root));
+  const real = await fs2.realpath(safe);
+  if (!isWithin(realRoot, real)) {
+    throw makeError("EACCES", `Path escapes project root (mid-path race): ${real}`);
+  }
+}
+async function readFile(root, p) {
+  const safe = await resolveWithinProjectRoot(p, root);
+  const fh = await fs2.open(safe, fs2.constants.O_RDONLY | fs2.constants.O_NOFOLLOW);
+  try {
+    await assertOpenedWithinRoot(safe, root);
+    return await fh.readFile("utf8");
+  } finally {
+    await fh.close();
+  }
+}
+async function assertWritableAncestor(lexical, root) {
+  const realRoot = await fs2.realpath(path2.resolve(root));
+  let ancestor = path2.dirname(lexical);
+  for (; ; ) {
+    let realAncestor;
+    try {
+      realAncestor = await fs2.realpath(ancestor);
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+      const next = path2.dirname(ancestor);
+      if (next === ancestor) {
+        throw makeError("EACCES", `Path escapes project root: ${lexical}`);
+      }
+      ancestor = next;
+      continue;
+    }
+    if (!isWithin(realRoot, realAncestor)) {
+      throw makeError("EACCES", `Path escapes project root: ${lexical}`);
+    }
+    return;
+  }
+}
+async function writeFile(root, p, content) {
+  const lexical = enforceWithinProjectRoot(p, root);
+  await assertWritableAncestor(lexical, root);
+  await fs2.mkdir(path2.dirname(lexical), { recursive: true });
+  const safe = await resolveWithinProjectRoot(p, root);
+  const fh = await fs2.open(
+    safe,
+    fs2.constants.O_WRONLY | fs2.constants.O_CREAT | fs2.constants.O_NOFOLLOW,
+    438
+  );
+  try {
+    await assertOpenedWithinRoot(safe, root);
+    const buf = Buffer.from(content, "utf8");
+    let off = 0;
+    while (off < buf.length) {
+      const { bytesWritten } = await fh.write(buf, off, buf.length - off, off);
+      if (bytesWritten <= 0) break;
+      off += bytesWritten;
+    }
+    await fh.truncate(buf.length);
+  } finally {
+    await fh.close();
+  }
+}
+function resolveWithinProjectRootSync(abs, root) {
+  const lexical = enforceWithinProjectRoot(abs, root);
+  const realRoot = nodeFs.realpathSync(path2.resolve(root));
+  let realTarget;
+  try {
+    realTarget = nodeFs.realpathSync(lexical);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+    const parent = path2.dirname(lexical);
+    const realParent = nodeFs.realpathSync(parent);
+    if (!isWithin(realRoot, realParent)) {
+      throw makeError("EACCES", `Path escapes project root: ${lexical}`);
+    }
+    return path2.join(realParent, path2.basename(lexical));
+  }
+  if (!isWithin(realRoot, realTarget)) {
+    throw makeError("EACCES", `Path escapes project root: ${realTarget}`);
+  }
+  return realTarget;
+}
+function assertWritableAncestorSync(lexical, root) {
+  const realRoot = nodeFs.realpathSync(path2.resolve(root));
+  let ancestor = path2.dirname(lexical);
+  for (; ; ) {
+    let realAncestor;
+    try {
+      realAncestor = nodeFs.realpathSync(ancestor);
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+      const next = path2.dirname(ancestor);
+      if (next === ancestor) {
+        throw makeError("EACCES", `Path escapes project root: ${lexical}`);
+      }
+      ancestor = next;
+      continue;
+    }
+    if (!isWithin(realRoot, realAncestor)) {
+      throw makeError("EACCES", `Path escapes project root: ${lexical}`);
+    }
+    return;
+  }
+}
+function assertOpenedWithinRootSync(safe, root) {
+  const realRoot = nodeFs.realpathSync(path2.resolve(root));
+  const real = nodeFs.realpathSync(safe);
+  if (!isWithin(realRoot, real)) {
+    throw makeError("EACCES", `Path escapes project root (mid-path race): ${real}`);
+  }
+}
+function writeFileSync(root, p, content) {
+  const lexical = enforceWithinProjectRoot(p, root);
+  assertWritableAncestorSync(lexical, root);
+  nodeFs.mkdirSync(path2.dirname(lexical), { recursive: true });
+  const safe = resolveWithinProjectRootSync(p, root);
+  const fd = nodeFs.openSync(
+    safe,
+    nodeFs.constants.O_WRONLY | nodeFs.constants.O_CREAT | nodeFs.constants.O_NOFOLLOW,
+    438
+  );
+  try {
+    assertOpenedWithinRootSync(safe, root);
+    const buf = Buffer.from(content, "utf8");
+    let off = 0;
+    while (off < buf.length) {
+      const bytesWritten = nodeFs.writeSync(fd, buf, off, buf.length - off, off);
+      if (bytesWritten <= 0) break;
+      off += bytesWritten;
+    }
+    nodeFs.ftruncateSync(fd, buf.length);
+  } finally {
+    nodeFs.closeSync(fd);
+  }
+}
+async function listFiles(root, rootArg) {
+  const safeRoot = await resolveWithinProjectRoot(rootArg, root);
+  const out = [];
+  const queue = [safeRoot];
+  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) {
+      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("/"));
+    }
+  }
+  return out;
+}
+function registerProjectFsIpc(ctx) {
+  const getRoot = () => ctx.workspace.getProjectPath();
+  const getLastClosedRoot = () => ctx.workspace.getLastClosedProjectPath();
+  return new IpcRegistry(ctx.senderPolicy).handle(ProjectFsChannel.GetRoot, () => getRoot()).handle(ProjectFsChannel.ReadFile, (_event, ...args) => {
+    const [p] = validate(ProjectFsChannel.ReadFile, ReadFileSchema, args);
+    return readFile(getRoot(), p);
+  }).handle(ProjectFsChannel.WriteFile, (_event, ...args) => {
+    const [p, content] = validate(ProjectFsChannel.WriteFile, WriteFileSchema, args);
+    const root = pickWriteRoot(p, { current: getRoot(), lastClosed: getLastClosedRoot() });
+    return writeFile(root, p, content);
+  }).handleSync(ProjectFsChannel.WriteFileSync, (_event, ...args) => {
+    const [p, content] = validate(ProjectFsChannel.WriteFileSync, WriteFileSchema, args);
+    const root = pickWriteRoot(p, { current: getRoot(), lastClosed: getLastClosedRoot() });
+    writeFileSync(root, p, content);
+    return { ok: true };
+  }).handle(ProjectFsChannel.ListFiles, (_event, ...args) => {
+    const [p] = validate(ProjectFsChannel.ListFiles, ListFilesSchema, args);
+    return listFiles(getRoot(), p);
+  });
+}
+
 // src/main/app/app.ts
-import { app as app13, BrowserWindow as BrowserWindow4, nativeImage } from "electron";
-import fs7 from "fs";
-import path12 from "path";
+import { app as app13, BrowserWindow as BrowserWindow4, nativeImage, session as session2 } from "electron";
+import fs10 from "fs";
+import path16 from "path";
 
 // src/main/utils/paths.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 import { fileURLToPath } from "url";
 function resolveDevtoolsPackageRoot() {
-  let dir = path2.dirname(fileURLToPath(import.meta.url));
-  const root = path2.parse(dir).root;
+  let dir = path3.dirname(fileURLToPath(import.meta.url));
+  const root = path3.parse(dir).root;
   while (dir !== root) {
-    const pkgPath = path2.join(dir, "package.json");
+    const pkgPath = path3.join(dir, "package.json");
     try {
-      const pkg2 = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+      const pkg2 = JSON.parse(fs3.readFileSync(pkgPath, "utf8"));
       if (pkg2.name === "@dimina-kit/devtools") return dir;
     } catch {
     }
-    dir = path2.dirname(dir);
+    dir = path3.dirname(dir);
   }
   throw new Error("@dimina-kit/devtools package root not found from " + fileURLToPath(import.meta.url));
 }
 var devtoolsPackageRoot = resolveDevtoolsPackageRoot();
-var rendererDir = path2.join(devtoolsPackageRoot, "dist/renderer");
-var defaultPreloadPath = path2.join(devtoolsPackageRoot, "dist/preload/windows/simulator.js");
-var mainPreloadPath = path2.join(devtoolsPackageRoot, "dist/preload/windows/main.cjs");
-var simulatorDir = path2.join(devtoolsPackageRoot, "dist/simulator");
+var rendererDir = path3.join(devtoolsPackageRoot, "dist/renderer");
+var defaultPreloadPath = path3.join(devtoolsPackageRoot, "dist/preload/windows/simulator.js");
+var mainPreloadPath = path3.join(devtoolsPackageRoot, "dist/preload/windows/main.cjs");
+var simulatorDir = path3.join(devtoolsPackageRoot, "dist/simulator");
 
 // src/main/utils/theme.ts
 import { BrowserWindow, nativeTheme as nativeTheme2 } from "electron";
-
-// src/main/utils/disposable.ts
-function toDisposable(fn) {
-  let done = false;
-  return {
-    dispose() {
-      if (done) return;
-      done = true;
-      return fn();
-    }
-  };
-}
-var DisposableRegistry = class {
-  entries = [];
-  _disposed = false;
-  /**
-   * Number of live entries. A wrapper's `dispose` splices its entry out and
-   * `disposeAll` clears the array, so `entries.length` is the live count.
-   */
-  get size() {
-    return this.entries.length;
-  }
-  add(d) {
-    if (this._disposed) {
-      throw new Error("cannot add to disposed registry");
-    }
-    const fn = typeof d === "function" ? d : () => d.dispose();
-    const entry = { fn, released: false };
-    this.entries.push(entry);
-    return {
-      dispose: () => {
-        if (entry.released) return;
-        entry.released = true;
-        const i = this.entries.indexOf(entry);
-        if (i >= 0) this.entries.splice(i, 1);
-        return fn();
-      }
-    };
-  }
-  async disposeAll() {
-    if (this._disposed) return;
-    this._disposed = true;
-    const items = this.entries.slice().reverse();
-    this.entries = [];
-    const errors = [];
-    for (const entry of items) {
-      if (entry.released) continue;
-      entry.released = true;
-      try {
-        await entry.fn();
-      } catch (e) {
-        errors.push(e);
-      }
-    }
-    if (errors.length > 0) {
-      throw new AggregateError(errors, "DisposableRegistry encountered errors during disposeAll");
-    }
-  }
-  dispose() {
-    return this.disposeAll();
-  }
-};
-
-// src/main/utils/theme.ts
 function themeBg() {
   return nativeTheme2.shouldUseDarkColors ? "#1a1a1a" : "#fafafa";
 }
@@ -205,7 +797,7 @@ function registerAppLifecycle() {
 
 // src/main/windows/main-window/create.ts
 import { app as app4, BrowserWindow as BrowserWindow2, View, session, shell as shell2 } from "electron";
-import path4 from "path";
+import path5 from "path";
 
 // src/main/services/simulator/referer.ts
 var DEFAULT_VERSION = "develop";
@@ -228,7 +820,7 @@ function getSimulatorServicewechatReferer() {
 
 // src/main/windows/navigation-hardening.ts
 import { shell } from "electron";
-import path3 from "path";
+import path4 from "path";
 import { pathToFileURL } from "url";
 function handleWindowOpenExternal(url) {
   try {
@@ -241,7 +833,7 @@ function handleWindowOpenExternal(url) {
   return { action: "deny" };
 }
 function applyNavigationHardening(wc, rendererDir2) {
-  const rendererPrefix = pathToFileURL(rendererDir2 + path3.sep).href;
+  const rendererPrefix = pathToFileURL(rendererDir2 + path4.sep).href;
   wc.setWindowOpenHandler(({ url }) => handleWindowOpenExternal(url));
   wc.on("will-navigate", (event, url) => {
     let parsed;
@@ -319,7 +911,7 @@ function createMainWindow(opts) {
       }
     }
   });
-  const rendererDir2 = path4.dirname(opts.indexHtml);
+  const rendererDir2 = path5.dirname(opts.indexHtml);
   applyNavigationHardening(mainWindow.webContents, rendererDir2);
   mainWindow.webContents.on("will-attach-webview", (event, webPreferences, params) => {
     ;
@@ -408,13 +1000,13 @@ function createWorkbenchSenderPolicy(ctx) {
 }
 
 // src/main/services/default-adapter.ts
-import path5 from "path";
+import path6 from "path";
 import { app as app5 } from "electron";
 var defaultAdapter = {
   async openProject(opts) {
     const diminaKit = await import("@dimina-kit/devkit");
     const openProjectOpts = {
-      outputDir: path5.join(app5.getPath("userData"), "dimina-fe-output"),
+      outputDir: path6.join(app5.getPath("userData"), "dimina-fe-output"),
       ...opts,
       simulatorDir
     };
@@ -422,112 +1014,6 @@ var defaultAdapter = {
   }
 };
 
-// src/shared/ipc-channels.ts
-var SimulatorChannel = {
-  Attach: "simulator:attach",
-  Detach: "simulator:detach",
-  Resize: "simulator:resize",
-  SetVisible: "simulator:setVisible",
-  Console: "simulator:console"
-};
-var SimulatorCustomApiChannel = {
-  List: "simulator:custom-apis:list",
-  Invoke: "simulator:custom-apis:invoke"
-};
-var SimulatorStorageChannel = {
-  GetSnapshot: "simulator:storage:snapshot",
-  GetActivePrefix: "simulator:storage:activePrefix",
-  Set: "simulator:storage:set",
-  Remove: "simulator:storage:remove",
-  Clear: "simulator:storage:clear",
-  ClearAll: "simulator:storage:clearAll",
-  Event: "simulator:storage:event"
-};
-var SimulatorElementChannel = {
-  Inspect: "simulator:element:inspect",
-  Clear: "simulator:element:clear"
-};
-var WorkbenchSettingsChannel = {
-  Get: "workbenchSettings:get",
-  Save: "workbenchSettings:save",
-  SetTheme: "workbenchSettings:setTheme",
-  GetCdpStatus: "workbenchSettings:getCdpStatus",
-  GetMcpStatus: "workbenchSettings:getMcpStatus",
-  SetVisible: "workbenchSettings:setVisible",
-  Init: "workbenchSettings:init"
-};
-var ProjectChannel = {
-  Open: "project:open",
-  Close: "project:close",
-  GetPages: "project:getPages",
-  GetCompileConfig: "project:getCompileConfig",
-  SaveCompileConfig: "project:saveCompileConfig",
-  Status: "project:status",
-  CaptureThumbnail: "project:captureThumbnail",
-  GetThumbnail: "project:getThumbnail"
-};
-var ProjectsChannel = {
-  List: "projects:list",
-  Add: "projects:add",
-  Remove: "projects:remove",
-  /** Phase 3: merged + sanitized template catalog for the create-project dialog. */
-  ListTemplates: "projects:listTemplates",
-  /** Phase 3: host-supplied create-project dialog hook (returns input or null). */
-  OpenCreateDialog: "projects:openCreateDialog",
-  /** Phase 3: 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"
-};
-var DialogChannel = {
-  OpenDirectory: "dialog:openDirectory"
-};
-var PanelChannel = {
-  List: "panel:list",
-  Eval: "panel:eval",
-  Select: "panel:select",
-  SelectSimulator: "panel:selectSimulator"
-};
-var PopoverChannel = {
-  Show: "popover:show",
-  Hide: "popover:hide",
-  Relaunch: "popover:relaunch",
-  Closed: "popover:closed",
-  Init: "popover:init"
-};
-var ToolbarChannel = {
-  GetActions: "toolbar:getActions",
-  ActionsChanged: "toolbar:actionsChanged",
-  /** Invoke a toolbar action by id: `invoke(Invoke, actionId)`. */
-  Invoke: "toolbar:invoke"
-};
-var WindowChannel = {
-  NavigateBack: "window:navigateBack"
-};
-var AppChannel = {
-  GetPreloadPath: "app:getPreloadPath",
-  GetBranding: "app:getBranding",
-  GetHeaderHeight: "app:getHeaderHeight"
-};
-var AutomationChannel = {
-  GetPort: "automation:port"
-};
-var SettingsChannel = {
-  SetVisible: "settings:setVisible",
-  ConfigChanged: "settings:configChanged",
-  ProjectSettingsChanged: "settings:projectSettingsChanged",
-  Init: "settings:init",
-  Closed: "settings:closed",
-  Changed: "settings:changed"
-};
-var UpdateChannel = {
-  Check: "updates:check",
-  Download: "updates:download",
-  Install: "updates:install",
-  DownloadProgress: "updates:downloadProgress",
-  Available: "updates:available"
-};
-
 // src/main/services/notifications/renderer-notifier.ts
 function liveWebContents(wc) {
   if (!wc) return null;
@@ -584,7 +1070,7 @@ function createRendererNotifier(ctx) {
 
 // src/main/services/views/view-manager.ts
 import { WebContentsView as WebContentsView2, webContents } from "electron";
-import path6 from "path";
+import path7 from "path";
 
 // src/main/services/layout/index.ts
 var SPLITTER_W = 4;
@@ -608,7 +1094,7 @@ function computeSettingsBounds(contentWidth, contentHeight, headerHeight) {
   return {
     x: Math.max(0, contentWidth - SETTINGS_W),
     y: headerHeight,
-    width: SETTINGS_W,
+    width: Math.min(SETTINGS_W, Math.max(1, contentWidth)),
     height: Math.max(1, contentHeight - headerHeight)
   };
 }
@@ -616,7 +1102,7 @@ function computePopoverBounds(contentWidth, contentHeight, headerHeight) {
   return {
     x: 0,
     y: headerHeight,
-    width: contentWidth,
+    width: Math.max(1, contentWidth),
     height: contentHeight - headerHeight
   };
 }
@@ -631,6 +1117,7 @@ function createViewManager(ctx) {
   let popoverView = null;
   let lastSimWidth = 375;
   let simulatorWebContentsId = null;
+  let simulatorBoundsOverride = null;
   function destroyViewInternal(view) {
     if (!view) return;
     if (!ctx.windows.mainWindow.isDestroyed()) {
@@ -648,8 +1135,37 @@ function createViewManager(ctx) {
   }
   function applySimulatorBounds(simWidth) {
     if (!simulatorView || ctx.windows.mainWindow.isDestroyed()) return;
+    if (simulatorBoundsOverride) {
+      simulatorView.setBounds(simulatorBoundsOverride);
+      return;
+    }
     const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
-    simulatorView.setBounds(computeSimulatorBounds(w, h, simWidth, headerHeight));
+    simulatorView.setBounds(
+      computeSimulatorBounds(w, h, simWidth, headerHeight)
+    );
+  }
+  function isHidden(b) {
+    return b.width <= 0 || b.height <= 0;
+  }
+  function setSimulatorDevtoolsBounds(bounds) {
+    simulatorBoundsOverride = bounds;
+    if (!simulatorView || simulatorView.webContents.isDestroyed()) return;
+    if (ctx.windows.mainWindow.isDestroyed()) return;
+    if (isHidden(bounds)) {
+      if (simulatorViewAdded) {
+        try {
+          ctx.windows.mainWindow.contentView.removeChildView(simulatorView);
+        } catch {
+        }
+        simulatorViewAdded = false;
+      }
+      return;
+    }
+    if (!simulatorViewAdded) {
+      ctx.windows.mainWindow.contentView.addChildView(simulatorView);
+      simulatorViewAdded = true;
+    }
+    simulatorView.setBounds(bounds);
   }
   function applySettingsBounds() {
     if (!settingsView || ctx.windows.mainWindow.isDestroyed()) return;
@@ -690,25 +1206,35 @@ function createViewManager(ctx) {
           let tries = 0
           const timer = setInterval(() => {
             tries++
-            const tabs = document.querySelectorAll('[role="tab"], .tabbed-pane-header-tab')
-            for (const tab of tabs) {
-              const label = (tab.getAttribute('aria-label') || tab.textContent || '').trim().toLowerCase()
-              if (label === 'console' || label.startsWith('console')) {
-                tab.click()
+            try {
+              const UI = globalThis.UI
+              const vm = UI && UI.ViewManager && typeof UI.ViewManager.instance === 'function'
+                ? UI.ViewManager.instance()
+                : null
+              if (vm && typeof vm.showView === 'function') {
+                vm.showView('console')
                 clearInterval(timer)
                 return
               }
-            }
-            if (tries > 40) clearInterval(timer)
-          }, 100)
+            } catch {}
+            if (tries > 80) clearInterval(timer)
+          }, 50)
         })()
       `).catch(() => {
       });
     });
     if (getDefaultTab(ctx) === "simulator") {
-      ctx.windows.mainWindow.contentView.addChildView(simulatorView);
-      simulatorViewAdded = true;
-      applySimulatorBounds(simWidth);
+      if (simulatorBoundsOverride) {
+        if (!isHidden(simulatorBoundsOverride)) {
+          ctx.windows.mainWindow.contentView.addChildView(simulatorView);
+          simulatorViewAdded = true;
+          simulatorView.setBounds(simulatorBoundsOverride);
+        }
+      } else {
+        ctx.windows.mainWindow.contentView.addChildView(simulatorView);
+        simulatorViewAdded = true;
+        applySimulatorBounds(simWidth);
+      }
     }
   }
   function detachSimulator() {
@@ -720,6 +1246,7 @@ function createViewManager(ctx) {
     simulatorView = null;
     simulatorViewAdded = false;
     simulatorWebContentsId = null;
+    simulatorBoundsOverride = null;
   }
   function showSimulator(simWidth) {
     lastSimWidth = simWidth;
@@ -752,7 +1279,7 @@ function createViewManager(ctx) {
       });
       applyNavigationHardening(settingsView.webContents, ctx.rendererDir);
       await settingsView.webContents.loadFile(
-        path6.join(ctx.rendererDir, "entries/settings/index.html")
+        path7.join(ctx.rendererDir, "entries/settings/index.html")
       );
     }
     if (!settingsViewAdded) {
@@ -789,7 +1316,7 @@ function createViewManager(ctx) {
       ctx.notify.popoverInit(popover, data);
     });
     popover.webContents.loadFile(
-      path6.join(ctx.rendererDir, "entries/popover/index.html")
+      path7.join(ctx.rendererDir, "entries/popover/index.html")
     );
   }
   function hidePopover() {
@@ -860,7 +1387,8 @@ function createViewManager(ctx) {
       return popoverView.webContents.id;
     },
     resize,
-    setVisible
+    setVisible,
+    setSimulatorDevtoolsBounds
   };
 }
 
@@ -892,61 +1420,21 @@ function createWindowService(mainWindow) {
 
 // src/main/services/projects/project-repository.ts
 import { app as app6 } from "electron";
-import path7 from "path";
-import fs3 from "fs";
-
-// 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);
-    }
-  };
-}
-
-// src/main/services/projects/project-repository.ts
-var log = createLogger("projects");
+import path8 from "path";
+import fs4 from "fs";
+var log2 = createLogger("projects");
 function getProjectsFile() {
-  return path7.join(app6.getPath("userData"), "dimina-projects.json");
+  return path8.join(app6.getPath("userData"), "dimina-projects.json");
 }
 function load() {
   try {
-    return JSON.parse(fs3.readFileSync(getProjectsFile(), "utf-8"));
+    return JSON.parse(fs4.readFileSync(getProjectsFile(), "utf-8"));
   } catch {
     return [];
   }
 }
 function save(projects) {
-  fs3.writeFileSync(getProjectsFile(), JSON.stringify(projects, null, 2));
+  fs4.writeFileSync(getProjectsFile(), JSON.stringify(projects, null, 2));
 }
 function listProjects() {
   return load();
@@ -955,20 +1443,20 @@ 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 (!fs3.existsSync(dirPath)) {
+  if (!fs4.existsSync(dirPath)) {
     return `\u5C0F\u7A0B\u5E8F\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${dirPath}`;
   }
-  if (!fs3.existsSync(path7.join(dirPath, "app.json"))) {
-    const configPath = path7.join(dirPath, "project.config.json");
-    if (fs3.existsSync(configPath)) {
+  if (!fs4.existsSync(path8.join(dirPath, "app.json"))) {
+    const configPath = path8.join(dirPath, "project.config.json");
+    if (fs4.existsSync(configPath)) {
       try {
-        const cfg = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+        const cfg = JSON.parse(fs4.readFileSync(configPath, "utf-8"));
         if (cfg.miniprogramRoot) {
-          const resolvedRoot = path7.resolve(dirPath, cfg.miniprogramRoot);
+          const resolvedRoot = path8.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) {
-        log.warn("Failed to parse project.config.json", err);
+        log2.warn("Failed to parse project.config.json", err);
       }
     }
     return "\u8BE5\u76EE\u5F55\u7F3A\u5C11 app.json\uFF0C\u8BF7\u9009\u62E9\u5305\u542B\u5C0F\u7A0B\u5E8F\u6E90\u7801\u7684\u76EE\u5F55";
@@ -977,15 +1465,15 @@ function validateProjectDir(dirPath) {
 }
 function addProject(dirPath) {
   const projects = load();
-  let name = path7.basename(dirPath);
+  let name = path8.basename(dirPath);
   try {
-    const configPath = path7.join(dirPath, "project.config.json");
-    if (fs3.existsSync(configPath)) {
-      const cfg = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+    const configPath = path8.join(dirPath, "project.config.json");
+    if (fs4.existsSync(configPath)) {
+      const cfg = JSON.parse(fs4.readFileSync(configPath, "utf-8"));
       if (cfg.projectname) name = cfg.projectname;
     }
   } catch (err) {
-    log.warn("Failed to read project name from config", err);
+    log2.warn("Failed to read project name from config", err);
   }
   const project = { name, path: dirPath, lastOpened: null };
   const idx = projects.findIndex((p) => p.path === dirPath);
@@ -1018,10 +1506,10 @@ function getCompileConfig(dirPath) {
   };
 }
 function getProjectPages(dirPath) {
-  const appJsonPath = path7.join(dirPath, "app.json");
+  const appJsonPath = path8.join(dirPath, "app.json");
   try {
     const appJson = JSON.parse(
-      fs3.readFileSync(appJsonPath, "utf-8")
+      fs4.readFileSync(appJsonPath, "utf-8")
     );
     return {
       pages: appJson.pages || [],
@@ -1044,8 +1532,8 @@ function getProjectSettings(projectPath) {
     return { uploadWithSourceMap: false };
   }
   try {
-    const configPath = path7.join(projectPath, "project.config.json");
-    const config = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+    const configPath = path8.join(projectPath, "project.config.json");
+    const config = JSON.parse(fs4.readFileSync(configPath, "utf-8"));
     return {
       uploadWithSourceMap: !!config.setting?.uploadWithSourceMap
     };
@@ -1055,17 +1543,17 @@ function getProjectSettings(projectPath) {
 }
 function updateProjectSettings(projectPath, patch) {
   if (!projectPath) return;
-  const configPath = path7.join(projectPath, "project.config.json");
+  const configPath = path8.join(projectPath, "project.config.json");
   let config = {};
   try {
-    config = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+    config = JSON.parse(fs4.readFileSync(configPath, "utf-8"));
   } catch {
   }
   const nextSetting = {
     ...config.setting ?? {},
     ...patch.uploadWithSourceMap === void 0 ? {} : { uploadWithSourceMap: patch.uploadWithSourceMap }
   };
-  fs3.writeFileSync(
+  fs4.writeFileSync(
     configPath,
     JSON.stringify({ ...config, setting: nextSetting }, null, 2)
   );
@@ -1082,6 +1570,7 @@ var DEFAULT_COMPILE_CONFIG = {
 function createWorkspaceService(ctx) {
   let currentSession = null;
   let currentProjectPath = "";
+  let lastClosedProjectPath = "";
   function sendStatus(status2, message, hotReload) {
     ctx.notify.projectStatus(hotReload ? { status: status2, message, hotReload: true } : { status: status2, message });
   }
@@ -1094,11 +1583,11 @@ function createWorkspaceService(ctx) {
   }
   async function disposeSession() {
     if (!currentSession) return;
-    const session2 = currentSession;
+    const session3 = currentSession;
     currentSession = null;
     try {
       await Promise.race([
-        session2.close(),
+        session3.close(),
         new Promise(
           (_, reject) => setTimeout(() => reject(new Error("session close timed out")), 5e3)
         )
@@ -1107,8 +1596,8 @@ function createWorkspaceService(ctx) {
       console.error("[workspace] session close failed:", err);
     }
   }
-  function applyRefererFromSession(session2) {
-    const appInfo = session2.appInfo;
+  function applyRefererFromSession(session3) {
+    const appInfo = session3.appInfo;
     if (appInfo && typeof appInfo.appId === "string" && appInfo.appId.length > 0) {
       setSimulatorServicewechatReferer(
         appInfo.appId,
@@ -1128,20 +1617,27 @@ function createWorkspaceService(ctx) {
       return projects.some((p) => p.path === dirPath);
     },
     validateProjectDir: async (dirPath) => provider.validateProjectDir ? provider.validateProjectDir(dirPath) : null,
-    async openProject(projectPath) {
-      clearSimulatorServicewechatReferer();
-      await disposeSession();
-      currentProjectPath = "";
+    async openProject(projectPath) {
       const dirError = provider.validateProjectDir ? await provider.validateProjectDir(projectPath) : null;
       if (dirError) {
         sendStatus("error", dirError);
         return { success: false, error: dirError };
       }
+      const gate = ctx.beforeOpenProject ? await ctx.beforeOpenProject(projectPath) : void 0;
+      if (gate && !gate.allow) {
+        const message = gate.userMessage ?? gate.reason;
+        sendStatus("error", message);
+        return { success: false, error: message };
+      }
+      clearSimulatorServicewechatReferer();
+      await disposeSession();
+      currentProjectPath = "";
+      lastClosedProjectPath = "";
       sendStatus("compiling", "\u6B63\u5728\u7F16\u8BD1...");
       const { compile } = loadWorkbenchSettings();
-      let session2;
+      let session3;
       try {
-        session2 = await ctx.adapter.openProject({
+        session3 = await ctx.adapter.openProject({
           projectPath,
           sourcemap: true,
           watch: compile.watch,
@@ -1153,27 +1649,29 @@ function createWorkspaceService(ctx) {
         sendStatus("error", String(err));
         return { success: false, error: String(err) };
       }
-      currentSession = session2;
+      currentSession = session3;
       currentProjectPath = projectPath;
       bestEffort("updateLastOpened", () => {
         if (provider.updateLastOpened) provider.updateLastOpened(projectPath);
       });
-      bestEffort("sendStatus", () => sendStatus("ready", "\u7F16\u8BD1\u5B8C\u6210"));
-      bestEffort("applyReferer", () => applyRefererFromSession(session2));
+      bestEffort("sendStatus", () => sendStatus("ready", gate?.statusMessage ?? "\u7F16\u8BD1\u5B8C\u6210"));
+      bestEffort("applyReferer", () => applyRefererFromSession(session3));
       return {
         success: true,
-        port: session2.port,
-        appInfo: session2.appInfo
+        port: session3.port,
+        appInfo: session3.appInfo
       };
     },
     async closeProject() {
       clearSimulatorServicewechatReferer();
       await disposeSession();
+      if (currentProjectPath !== "") lastClosedProjectPath = currentProjectPath;
       currentProjectPath = "";
       ctx.views.disposeAll();
     },
     getSession: () => currentSession,
     getProjectPath: () => currentProjectPath,
+    getLastClosedProjectPath: () => lastClosedProjectPath,
     hasActiveSession: () => currentSession !== null,
     async captureThumbnail(projectPath) {
       const wc = ctx.views.getSimulatorWebContents();
@@ -1213,29 +1711,29 @@ function createWorkspaceService(ctx) {
 
 // src/main/services/projects/thumbnail.ts
 import { createHash } from "crypto";
-import fs4 from "fs";
-import path8 from "path";
+import fs5 from "fs";
+import path9 from "path";
 import { app as app7 } from "electron";
 function getThumbnailDir() {
-  return path8.join(app7.getPath("userData"), "thumbnails");
+  return path9.join(app7.getPath("userData"), "thumbnails");
 }
 function hashProjectPath(projectPath) {
   return createHash("sha256").update(projectPath).digest("hex").slice(0, 16);
 }
 function getThumbnailPath(projectPath) {
-  return path8.join(getThumbnailDir(), `${hashProjectPath(projectPath)}.png`);
+  return path9.join(getThumbnailDir(), `${hashProjectPath(projectPath)}.png`);
 }
 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");
-  fs4.mkdirSync(getThumbnailDir(), { recursive: true });
-  fs4.writeFileSync(getThumbnailPath(projectPath), png);
+  fs5.mkdirSync(getThumbnailDir(), { recursive: true });
+  fs5.writeFileSync(getThumbnailPath(projectPath), png);
 }
 function loadThumbnail(projectPath) {
   const filePath = getThumbnailPath(projectPath);
   try {
-    const buf = fs4.readFileSync(filePath);
+    const buf = fs5.readFileSync(filePath);
     return `${DATA_URL_PNG_PREFIX}${buf.toString("base64")}`;
   } catch {
     return null;
@@ -1282,6 +1780,18 @@ function createSimulatorApiRegistry() {
 }
 
 // src/main/services/toolbar/toolbar-store.ts
+function toPublicAction(action) {
+  const projected = {
+    id: action.id,
+    label: action.label
+  };
+  if (action.kind) projected.kind = action.kind;
+  if (action.placement) projected.placement = action.placement;
+  if (action.icon) projected.icon = action.icon;
+  if (action.displayInitial) projected.displayInitial = action.displayInitial;
+  if (action.avatarUrl) projected.avatarUrl = action.avatarUrl;
+  return projected;
+}
 function createToolbarStore() {
   let actions = [];
   return {
@@ -1296,7 +1806,7 @@ function createToolbarStore() {
       actions = next.slice();
     },
     list() {
-      return actions.map(({ id, label }) => ({ id, label }));
+      return actions.map(toPublicAction);
     },
     getHandler(id) {
       return actions.find((a) => a.id === id)?.handler;
@@ -1331,20 +1841,20 @@ function sanitizeTemplates(templates) {
 }
 
 // src/main/services/projects/builtin-templates.ts
-import path9 from "node:path";
-var TEMPLATES_DIR = path9.join(devtoolsPackageRoot, "templates");
+import path10 from "node:path";
+var TEMPLATES_DIR = path10.join(devtoolsPackageRoot, "templates");
 var BUILTIN_TEMPLATES = [
   {
     id: "blank",
     name: "Blank",
     description: "\u6700\u5C0F\u9AA8\u67B6\uFF1Aapp.* + \u4E00\u4E2A index \u9875\u9762",
-    source: { type: "directory", path: path9.join(TEMPLATES_DIR, "blank") }
+    source: { type: "directory", path: path10.join(TEMPLATES_DIR, "blank") }
   },
   {
     id: "taro-todo",
     name: "Taro Todo",
     description: "Taro \u7F16\u8BD1\u4EA7\u7269\u7684 Todo \u793A\u4F8B",
-    source: { type: "directory", path: path9.join(TEMPLATES_DIR, "taro-todo") }
+    source: { type: "directory", path: path10.join(TEMPLATES_DIR, "taro-todo") }
   }
 ];
 
@@ -1465,113 +1975,10 @@ function installAppMenu(ctx) {
 }
 
 // src/main/ipc/app.ts
-import fs5 from "fs";
-
-// src/main/utils/ipc-registry.ts
-import { ipcMain } from "electron";
-
-// src/main/utils/ipc-schema.ts
-var IpcValidationError = class extends Error {
-  channel;
-  paths;
-  constructor(channel, issues) {
-    const paths = issues.map((i) => i.path.map((p) => String(p)).join(".") || "<root>");
-    super(`Invalid IPC arguments for ${channel}`);
-    this.name = "IpcValidationError";
-    this.channel = channel;
-    this.paths = paths;
-  }
-};
-function validate(channel, schema, args) {
-  const r = schema.safeParse(args);
-  if (!r.success) {
-    console.warn("[ipc] schema reject", channel, r.error.issues);
-    throw new IpcValidationError(channel, r.error.issues);
-  }
-  return r.data;
-}
-
-// src/main/utils/ipc-registry.ts
-var log2 = createLogger("ipc");
-function reportListenerError(channel, err) {
-  if (err instanceof IpcValidationError) {
-    log2.warn(`schema reject on '${channel}' at [${err.paths.join(", ")}]`);
-    return;
-  }
-  if (err instanceof Error) {
-    log2.error(`listener threw on '${channel}': ${err.message}`, err.stack);
-    return;
-  }
-  log2.error(`listener threw on '${channel}'`, err);
-}
-function isThenable(v) {
-  return v != null && (typeof v === "object" || typeof v === "function") && typeof v.then === "function";
-}
-function summarizeSender(sender) {
-  if (sender.isDestroyed()) return "<destroyed>";
-  const url = sender.getURL();
-  return `id=${sender.id} ${url.slice(0, 120)}`;
-}
-var IpcRegistry = class {
-  constructor(policy) {
-    this.policy = policy;
-  }
-  policy;
-  registry = new DisposableRegistry();
-  handle(channel, fn) {
-    const policy = this.policy;
-    const guarded = policy ? async (event, ...args) => {
-      const sender = event.sender;
-      if (!policy(sender)) {
-        console.warn(
-          `[ipc] sender rejected for channel '${channel}' (${summarizeSender(sender)})`
-        );
-        throw new Error(`IPC sender rejected for channel ${channel}`);
-      }
-      return fn(event, ...args);
-    } : fn;
-    ipcMain.handle(channel, guarded);
-    this.registry.add(() => ipcMain.removeHandler(channel));
-    return this;
-  }
-  on(channel, fn) {
-    const policy = this.policy;
-    const raw = fn;
-    const safeInvoke = (event, args) => {
-      try {
-        const ret = raw(event, ...args);
-        if (isThenable(ret)) {
-          Promise.resolve(ret).catch((err) => reportListenerError(channel, err));
-        }
-      } catch (err) {
-        reportListenerError(channel, err);
-      }
-    };
-    const guarded = policy ? (event, ...args) => {
-      const sender = event.sender;
-      if (!policy(sender)) {
-        console.warn(
-          `[ipc] sender rejected for channel '${channel}' (${summarizeSender(sender)})`
-        );
-        return;
-      }
-      safeInvoke(event, args);
-    } : (event, ...args) => safeInvoke(event, args);
-    ipcMain.on(channel, guarded);
-    this.registry.add(() => {
-      ipcMain.removeListener(channel, guarded);
-    });
-    return this;
-  }
-  dispose() {
-    return this.registry.dispose();
-  }
-};
-
-// src/main/ipc/app.ts
+import fs6 from "fs";
 function registerAppIpc(ctx) {
   return new IpcRegistry(ctx.senderPolicy).handle(AppChannel.GetPreloadPath, () => {
-    return `file://${fs5.realpathSync(ctx.preloadPath)}`;
+    return `file://${fs6.realpathSync(ctx.preloadPath)}`;
   }).handle(AppChannel.GetBranding, async () => {
     if (ctx.brandingProvider) return ctx.brandingProvider();
     return { appName: ctx.appName };
@@ -1581,71 +1988,80 @@ function registerAppIpc(ctx) {
 }
 
 // src/shared/ipc-schemas.ts
-import { z } from "zod";
-var AbsolutePath = z.string().min(1).refine(
+import { z as z2 } from "zod";
+var AbsolutePath = z2.string().min(1).refine(
   (p) => p.startsWith("/") || /^[a-zA-Z]:\\/.test(p) || /^[a-zA-Z]:\//.test(p),
   "must be an absolute path"
 );
-var PanelEvalSchema = z.tuple([z.string().min(1).max(5e4)]);
-var ProjectsAddSchema = z.tuple([AbsolutePath]);
-var ProjectOpenSchema = z.tuple([AbsolutePath]);
-var CompileConfigShape = z.looseObject({
-  startPage: z.string().optional(),
-  scene: z.number().optional(),
-  queryParams: z.array(z.looseObject({ key: z.string(), value: z.string() })).optional()
+var PanelEvalSchema = z2.tuple([z2.string().min(1).max(5e4)]);
+var ProjectsAddSchema = z2.tuple([AbsolutePath]);
+var ProjectOpenSchema = z2.tuple([AbsolutePath]);
+var CompileConfigShape = z2.looseObject({
+  startPage: z2.string().optional(),
+  scene: z2.number().optional(),
+  queryParams: z2.array(z2.looseObject({ key: z2.string(), value: z2.string() })).optional()
 });
-var ProjectSaveCompileConfigSchema = z.tuple([
+var ProjectSaveCompileConfigSchema = z2.tuple([
   AbsolutePath,
   CompileConfigShape
 ]);
-var PopoverShowSchema = z.tuple([z.looseObject({})]);
-var SimWidth = z.number().int().min(100).max(2e3);
-var SimulatorAttachSchema = z.tuple([
-  z.number().int().positive(),
+var PopoverShowSchema = z2.tuple([z2.looseObject({})]);
+var SimWidth = z2.number().int().min(100).max(2e3);
+var SimulatorAttachSchema = z2.tuple([
+  z2.number().int().positive(),
   SimWidth
 ]);
-var SimulatorResizeSchema = z.tuple([SimWidth]);
-var SimulatorSetVisibleSchema = z.tuple([z.boolean(), SimWidth]);
-var SimulatorCustomApiInvokeSchema = z.tuple([
-  z.string().min(1).max(256),
-  z.unknown()
+var SimulatorResizeSchema = z2.tuple([SimWidth]);
+var NonNegInt = z2.number().int().min(0).max(1e5);
+var ViewBoundsSchema = z2.tuple([
+  z2.object({
+    x: NonNegInt,
+    y: NonNegInt,
+    width: NonNegInt,
+    height: NonNegInt
+  })
+]);
+var SimulatorSetVisibleSchema = z2.tuple([z2.boolean(), SimWidth]);
+var SimulatorCustomApiInvokeSchema = z2.tuple([
+  z2.string().min(1).max(256),
+  z2.unknown()
 ]);
-var ToolbarInvokeSchema = z.tuple([z.string().min(1).max(256)]);
-var ProjectGetPagesSchema = z.tuple([AbsolutePath]);
-var ProjectGetCompileConfigSchema = z.tuple([AbsolutePath]);
-var ProjectsRemoveSchema = z.tuple([AbsolutePath]);
-var WorkbenchSettingsSaveSchema = z.tuple([
-  z.looseObject({
-    cdp: z.looseObject({
-      enabled: z.boolean(),
-      port: z.number().int().min(0).max(65535)
+var ToolbarInvokeSchema = z2.tuple([z2.string().min(1).max(256)]);
+var ProjectGetPagesSchema = z2.tuple([AbsolutePath]);
+var ProjectGetCompileConfigSchema = z2.tuple([AbsolutePath]);
+var ProjectsRemoveSchema = z2.tuple([AbsolutePath]);
+var WorkbenchSettingsSaveSchema = z2.tuple([
+  z2.looseObject({
+    cdp: z2.looseObject({
+      enabled: z2.boolean(),
+      port: z2.number().int().min(0).max(65535)
     }),
-    mcp: z.looseObject({
-      enabled: z.boolean(),
-      port: z.number().int().min(0).max(65535)
+    mcp: z2.looseObject({
+      enabled: z2.boolean(),
+      port: z2.number().int().min(0).max(65535)
     }),
-    compile: z.looseObject({
-      watch: z.boolean()
+    compile: z2.looseObject({
+      watch: z2.boolean()
     }),
-    theme: z.enum(["system", "light", "dark"]),
-    lastCreateBaseDir: z.union([z.string(), z.null()])
+    theme: z2.enum(["system", "light", "dark"]),
+    lastCreateBaseDir: z2.union([z2.string(), z2.null()])
   })
 ]);
-var WorkbenchSettingsSetThemeSchema = z.tuple([
-  z.enum(["system", "light", "dark"])
+var WorkbenchSettingsSetThemeSchema = z2.tuple([
+  z2.enum(["system", "light", "dark"])
 ]);
-var WorkbenchSettingsSetVisibleSchema = z.tuple([z.boolean()]);
-var SettingsSetVisibleSchema = z.tuple([z.boolean()]);
-var SettingsConfigChangedSchema = z.tuple([CompileConfigShape]);
-var PopoverRelaunchSchema = z.tuple([CompileConfigShape]);
-var SettingsProjectSettingsChangedSchema = z.tuple([
-  z.looseObject({
-    uploadWithSourceMap: z.boolean().optional()
+var WorkbenchSettingsSetVisibleSchema = z2.tuple([z2.boolean()]);
+var SettingsSetVisibleSchema = z2.tuple([z2.boolean()]);
+var SettingsConfigChangedSchema = z2.tuple([CompileConfigShape]);
+var PopoverRelaunchSchema = z2.tuple([CompileConfigShape]);
+var SettingsProjectSettingsChangedSchema = z2.tuple([
+  z2.looseObject({
+    uploadWithSourceMap: z2.boolean().optional()
   })
 ]);
-var PanelSelectSchema = z.tuple([z.string().min(1).max(200)]);
-var ProjectCaptureThumbnailSchema = z.tuple([AbsolutePath]);
-var ProjectGetThumbnailSchema = z.tuple([AbsolutePath]);
+var PanelSelectSchema = z2.tuple([z2.string().min(1).max(200)]);
+var ProjectCaptureThumbnailSchema = z2.tuple([AbsolutePath]);
+var ProjectGetThumbnailSchema = z2.tuple([AbsolutePath]);
 
 // src/main/ipc/simulator.ts
 function registerSimulatorIpc(ctx) {
@@ -1718,11 +2134,11 @@ var popoverModule = {
 
 // src/main/ipc/projects.ts
 import { app as app8, dialog } from "electron";
-import path11 from "path";
+import path12 from "path";
 
 // src/main/services/projects/create-project-service.ts
-import fs6 from "node:fs";
-import path10 from "node:path";
+import fs7 from "node:fs";
+import path11 from "node:path";
 var DEFAULT_TEMPLATE_ID = "blank";
 async function createProject(input, ctx) {
   const name = (input.name ?? "").trim();
@@ -1733,12 +2149,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}`
@@ -1755,31 +2171,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 = path10.join(target, "project.config.json");
+  const cfgPath = path11.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;
 }
@@ -1855,7 +2271,7 @@ function registerProjectsIpc(ctx) {
     }
     try {
       const settings = loadWorkbenchSettings();
-      const newBase = path11.dirname(input.path);
+      const newBase = path12.dirname(input.path);
       if (newBase && settings.lastCreateBaseDir !== newBase) {
         saveWorkbenchSettings({ ...settings, lastCreateBaseDir: newBase });
       }
@@ -2049,6 +2465,18 @@ function registerToolbarIpc(ctx) {
   });
 }
 
+// src/main/ipc/views.ts
+function registerViewsIpc(ctx) {
+  return new IpcRegistry(ctx.senderPolicy).handle(ViewChannel.SimulatorDevtoolsBounds, (_event, ...args) => {
+    const [bounds] = validate(
+      ViewChannel.SimulatorDevtoolsBounds,
+      ViewBoundsSchema,
+      args
+    );
+    ctx.views.setSimulatorDevtoolsBounds(bounds);
+  });
+}
+
 // src/main/ipc/simulator-module.ts
 var simulatorModule = {
   setup: (ctx) => {
@@ -2056,6 +2484,7 @@ var simulatorModule = {
     reg.add(registerSimulatorIpc(ctx));
     reg.add(registerPanelsIpc(ctx));
     reg.add(registerToolbarIpc(ctx));
+    reg.add(registerViewsIpc(ctx));
     return reg;
   }
 };
@@ -2749,7 +3178,7 @@ function getClient(kind) {
 }
 
 // src/main/services/mcp/tool-registry.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 function registerCommonTargetTools(server, kind) {
   const descriptions = kind === "simulator" ? {
     screenshot: "Take a screenshot of the simulator webview",
@@ -2770,9 +3199,9 @@ function registerCommonTargetTools(server, kind) {
     return { content: [{ type: "image", data, mimeType: "image/png" }] };
   });
   server.tool(`${kind}_console_logs`, descriptions.consoleLogs, {
-    limit: z2.number().optional().default(50).describe("Maximum number of log entries"),
-    level: z2.enum(["error", "warning", "warn", "info", "log", "debug"]).optional().describe("Only return entries with this level"),
-    sinceTimestamp: z2.string().optional().describe("ISO timestamp; only return entries at or after this time")
+    limit: z3.number().optional().default(50).describe("Maximum number of log entries"),
+    level: z3.enum(["error", "warning", "warn", "info", "log", "debug"]).optional().describe("Only return entries with this level"),
+    sinceTimestamp: z3.string().optional().describe("ISO timestamp; only return entries at or after this time")
   }, async ({ limit, level, sinceTimestamp }) => {
     getClient(kind);
     let entries = getTargetState(kind).consoleLogs;
@@ -2787,7 +3216,7 @@ function registerCommonTargetTools(server, kind) {
   });
   if (kind !== "workbench") {
     server.tool(`${kind}_evaluate`, descriptions.evaluate, {
-      expression: z2.string().describe("JavaScript expression to evaluate")
+      expression: z3.string().describe("JavaScript expression to evaluate")
     }, async ({ expression }) => {
       const c = getClient(kind);
       const result = await c.Runtime.evaluate({ expression, returnByValue: true, awaitPromise: true });
@@ -2800,15 +3229,15 @@ ${JSON.stringify(result.exceptionDetails, null, 2)}` }], isError: true };
     });
   }
   server.tool(`${kind}_get_dom`, descriptions.getDom, {
-    depth: z2.number().optional().default(3).describe("Maximum depth")
+    depth: z3.number().optional().default(3).describe("Maximum depth")
   }, async ({ depth }) => {
     const c = getClient(kind);
     const { root } = await c.DOM.getDocument({ depth });
     return { content: [{ type: "text", text: JSON.stringify(root, null, 2) }] };
   });
   server.tool(`${kind}_network_log`, descriptions.networkLog, {
-    limit: z2.number().optional().default(20).describe("Maximum number of entries"),
-    minStatus: z2.number().optional().describe("Only return entries with status >= minStatus (status 0 = failed before response is included when minStatus >= 400)")
+    limit: z3.number().optional().default(20).describe("Maximum number of entries"),
+    minStatus: z3.number().optional().describe("Only return entries with status >= minStatus (status 0 = failed before response is included when minStatus >= 400)")
   }, async ({ limit, minStatus }) => {
     getClient(kind);
     let entries = getTargetState(kind).networkRequests;
@@ -3051,11 +3480,11 @@ function registerContextTools(server) {
 }
 
 // src/main/services/mcp/tools/simulator-tools.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 function registerSimulatorTools(server) {
   server.tool("simulator_navigate", "Navigate the simulator to a URL, or reload the current page", {
-    url: z3.string().optional().describe("URL to navigate to"),
-    reload: z3.boolean().optional().describe("If true, reload current page instead of navigating")
+    url: z4.string().optional().describe("URL to navigate to"),
+    reload: z4.boolean().optional().describe("If true, reload current page instead of navigating")
   }, async ({ url, reload }) => {
     const c = getClient("simulator");
     if (reload) {
@@ -3070,15 +3499,15 @@ function registerSimulatorTools(server) {
     return { content: [{ type: "text", text: "Error: either url or reload is required" }], isError: true };
   });
   server.tool("simulator_input", "Dispatch input to the simulator. `tap_coord` requires x and y. `tap_selector` requires selector and optional nth. `type` requires selector and text. `scroll` requires x, y, deltaX, and deltaY. `key` is best-effort for common keys such as Enter, Escape, Tab, Arrow* and Space.", {
-    action: z3.enum(["tap_coord", "tap_selector", "type", "scroll", "key"]).describe("Input action to dispatch"),
-    x: z3.number().optional().describe("Viewport x coordinate for `tap_coord` or `scroll`"),
-    y: z3.number().optional().describe("Viewport y coordinate for `tap_coord` or `scroll`"),
-    selector: z3.string().optional().describe("CSS selector for `tap_selector` or `type`"),
-    nth: z3.number().int().optional().describe("Zero-based index when selector matches multiple elements; defaults to 0"),
-    text: z3.string().optional().describe("Text to insert for `type`"),
-    key: z3.string().optional().describe("Best-effort keyboard key name for `key`; common keys such as Enter, Escape, Tab, Arrow* and Space work best"),
-    deltaX: z3.number().optional().describe("Horizontal wheel delta for `scroll`"),
-    deltaY: z3.number().optional().describe("Vertical wheel delta for `scroll`")
+    action: z4.enum(["tap_coord", "tap_selector", "type", "scroll", "key"]).describe("Input action to dispatch"),
+    x: z4.number().optional().describe("Viewport x coordinate for `tap_coord` or `scroll`"),
+    y: z4.number().optional().describe("Viewport y coordinate for `tap_coord` or `scroll`"),
+    selector: z4.string().optional().describe("CSS selector for `tap_selector` or `type`"),
+    nth: z4.number().int().optional().describe("Zero-based index when selector matches multiple elements; defaults to 0"),
+    text: z4.string().optional().describe("Text to insert for `type`"),
+    key: z4.string().optional().describe("Best-effort keyboard key name for `key`; common keys such as Enter, Escape, Tab, Arrow* and Space work best"),
+    deltaX: z4.number().optional().describe("Horizontal wheel delta for `scroll`"),
+    deltaY: z4.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 });
@@ -3532,6 +3961,527 @@ async function clearElementInspection() {
   }
 }
 
+// src/main/services/simulator-temp-files/store.ts
+function registerTempFile(store, path18, mime, bytes) {
+  const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(new Uint8Array(bytes));
+  store.delete(path18);
+  store.set(path18, { bytes: buf, mime });
+}
+function revokeTempFile(store, path18) {
+  store.delete(path18);
+}
+function revokeAllTempFiles(store) {
+  store.clear();
+}
+
+// src/shared/vpath.ts
+import os from "node:os";
+import path13 from "node:path";
+var DIFILE_PREFIX = "difile://";
+function sandboxBase() {
+  const env = typeof process !== "undefined" && process.env && process.env.DIMINA_HOME || "";
+  if (env) {
+    return path13.join(env, "files");
+  }
+  return path13.join(os.homedir(), ".dimina", "files");
+}
+function resolveVPath(url) {
+  if (typeof url !== "string") return null;
+  if (!url.startsWith(DIFILE_PREFIX)) return null;
+  const raw = url.slice(DIFILE_PREFIX.length);
+  if (raw.length === 0) return null;
+  let decoded;
+  try {
+    decoded = decodeURIComponent(raw);
+  } catch {
+    return null;
+  }
+  if (decoded.includes("\0")) return null;
+  decoded = decoded.replace(/^[/\\]+/, "");
+  if (decoded.length === 0) return null;
+  const segments = decoded.split(/[/\\]+/);
+  if (segments.some((s) => s === ".." || s === ".")) return null;
+  let kind;
+  let writable;
+  if (decoded.startsWith("_tmp/")) {
+    kind = "tmp";
+    writable = false;
+  } else if (decoded.startsWith("_store/")) {
+    kind = "store";
+    writable = false;
+  } else {
+    kind = "usr";
+    writable = true;
+  }
+  if (kind === "tmp") {
+    return { kind, writable };
+  }
+  const base = sandboxBase();
+  const joined = path13.join(base, decoded);
+  const normalized = path13.normalize(joined);
+  if (normalized !== base && !normalized.startsWith(base + path13.sep)) return null;
+  return { kind, writable, realPath: normalized };
+}
+
+// src/main/services/simulator-temp-files/disk.ts
+import fs8 from "node:fs/promises";
+import path14 from "node:path";
+var EXT_MIME = {
+  ".txt": "text/plain",
+  ".log": "text/plain",
+  ".md": "text/markdown",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".css": "text/css",
+  ".csv": "text/csv",
+  ".json": "application/json",
+  ".xml": "application/xml",
+  ".js": "application/javascript",
+  ".mjs": "application/javascript",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+  ".mp4": "video/mp4",
+  ".m4v": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".pdf": "application/pdf",
+  ".zip": "application/zip"
+};
+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;
+}
+function extMime(realPath) {
+  const ext = path14.extname(realPath).toLowerCase();
+  if (!ext) return null;
+  return EXT_MIME[ext] ?? null;
+}
+function detectMime(realPath, head) {
+  const sniffed = sniffMime(head);
+  if (sniffed) return sniffed;
+  const byExt = extMime(realPath);
+  if (byExt) return byExt;
+  return "application/octet-stream";
+}
+function etagOf(mtimeMs, size) {
+  return `W/"${Math.floor(mtimeMs)}-${size}"`;
+}
+async function readDiskFile(realPath, opts) {
+  const handle = await fs8.open(realPath, "r");
+  try {
+    const st = await handle.stat();
+    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);
+      }
+    }
+    return {
+      bytes,
+      mime: detectMime(realPath, head),
+      etag: etagOf(mtimeMs, totalSize),
+      totalSize
+    };
+  } finally {
+    await handle.close();
+  }
+}
+async function writeDiskFile(realPath, bytes) {
+  const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(new Uint8Array(bytes));
+  await fs8.mkdir(path14.dirname(realPath), { recursive: true });
+  await fs8.writeFile(realPath, buf);
+}
+async function readDiskDir(realPath) {
+  const entries = await fs8.readdir(realPath);
+  return entries;
+}
+async function statDiskFile(realPath) {
+  const st = await fs8.stat(realPath);
+  return {
+    size: st.size,
+    mtime: Math.floor(st.mtimeMs),
+    mode: st.mode,
+    isFile: st.isFile(),
+    isDirectory: st.isDirectory()
+  };
+}
+
+// src/main/services/simulator-temp-files/request-handler.ts
+var CACHE_CONTROL = "public, max-age=31536000, immutable";
+function getHeader(headers, name) {
+  if (!headers) return void 0;
+  const lc = name.toLowerCase();
+  for (const k of Object.keys(headers)) {
+    if (k.toLowerCase() === lc) return headers[k];
+  }
+  return void 0;
+}
+function etagsMatch(a, b) {
+  if (!a) return false;
+  const stripped = (s) => s.startsWith("W/") ? s.slice(2) : s;
+  return stripped(a.trim()) === stripped(b);
+}
+function parseRange(header, totalSize) {
+  if (!header) return null;
+  const m = /^bytes=(\d*)-(\d*)$/.exec(header.trim());
+  if (!m) return null;
+  const startStr = m[1];
+  const endStr = m[2];
+  if (startStr === "" && endStr === "") return null;
+  if (startStr === "") {
+    const n = Number(endStr);
+    if (!Number.isFinite(n) || n <= 0) return null;
+    const start2 = Math.max(0, totalSize - n);
+    return { start: start2, end: totalSize - 1 };
+  }
+  const start = Number(startStr);
+  if (!Number.isFinite(start) || start < 0) return null;
+  const end = endStr === "" ? totalSize - 1 : Number(endStr);
+  if (!Number.isFinite(end)) return null;
+  return { start, end };
+}
+function notFound() {
+  return new Response(null, { status: 404 });
+}
+function notModified(etag) {
+  return new Response(null, {
+    status: 304,
+    headers: {
+      ETag: etag,
+      "Cache-Control": CACHE_CONTROL,
+      "Access-Control-Allow-Origin": "*"
+    }
+  });
+}
+function bufferToBody(bytes) {
+  const out = new ArrayBuffer(bytes.byteLength);
+  new Uint8Array(out).set(bytes);
+  return out;
+}
+function tempBody(bytes, mime) {
+  return new Response(bufferToBody(bytes), {
+    status: 200,
+    headers: {
+      "Content-Type": mime,
+      "Cache-Control": CACHE_CONTROL,
+      "Access-Control-Allow-Origin": "*"
+    }
+  });
+}
+async function handleDifileRequest(ctx, req) {
+  const v = resolveVPath(req.url);
+  if (!v) return notFound();
+  if (v.kind === "tmp") {
+    const record = ctx.tempStore.get(req.url);
+    if (!record) return notFound();
+    return tempBody(record.bytes, record.mime || "application/octet-stream");
+  }
+  if (!v.realPath) return notFound();
+  try {
+    const probe = await readDiskFile(v.realPath);
+    const etag = probe.etag;
+    const totalSize = probe.totalSize;
+    const mime = probe.mime;
+    const ifNoneMatch = getHeader(req.headers, "If-None-Match");
+    if (etagsMatch(ifNoneMatch, etag)) {
+      return notModified(etag);
+    }
+    const rangeHeader = getHeader(req.headers, "Range");
+    const range = parseRange(rangeHeader, totalSize);
+    if (range) {
+      if (range.start < 0 || range.start >= totalSize || range.end < range.start) {
+        return new Response(null, {
+          status: 416,
+          headers: {
+            "Content-Range": `bytes */${totalSize}`,
+            "Access-Control-Allow-Origin": "*"
+          }
+        });
+      }
+      const clampedEnd = Math.min(range.end, totalSize - 1);
+      const sliced = await readDiskFile(v.realPath, { range: { start: range.start, end: clampedEnd } });
+      const { bytes } = sliced;
+      const lastByte = range.start + bytes.length - 1;
+      return new Response(bufferToBody(bytes), {
+        status: 206,
+        headers: {
+          "Content-Type": mime,
+          "Content-Length": String(bytes.length),
+          "Content-Range": `bytes ${range.start}-${lastByte}/${totalSize}`,
+          "Cache-Control": CACHE_CONTROL,
+          ETag: etag,
+          "Access-Control-Allow-Origin": "*"
+        }
+      });
+    }
+    return new Response(bufferToBody(probe.bytes), {
+      status: 200,
+      headers: {
+        "Content-Type": mime,
+        "Cache-Control": CACHE_CONTROL,
+        ETag: etag,
+        "Access-Control-Allow-Origin": "*"
+      }
+    });
+  } catch {
+    return notFound();
+  }
+}
+
+// src/main/services/simulator-temp-files/fs-channels.ts
+import fs9 from "node:fs/promises";
+import path15 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 normalized = path15.normalize(realPath);
+  if (normalized !== base && !normalized.startsWith(base + path15.sep)) {
+    throw new Error("sandbox: realPath escapes the user-data base");
+  }
+  let probe = normalized;
+  while (probe !== path15.parse(probe).root) {
+    try {
+      const resolved = await fs9.realpath(probe);
+      if (resolved !== baseReal && !resolved.startsWith(baseReal + path15.sep)) {
+        throw new Error("sandbox: realPath escapes the user-data base via symlink");
+      }
+      break;
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        probe = path15.dirname(probe);
+        continue;
+      }
+      throw err;
+    }
+  }
+  return normalized;
+}
+async function handleFsRead(req) {
+  const safe = await enforceSandbox(req.realPath);
+  const result = await readDiskFile(safe, req.range ? { range: req.range } : void 0);
+  return {
+    bytes: result.bytes,
+    mime: result.mime,
+    etag: result.etag,
+    totalSize: result.totalSize
+  };
+}
+async function handleFsWrite(req) {
+  const safe = await enforceSandbox(req.realPath);
+  await writeDiskFile(safe, req.bytes);
+  return { ok: true };
+}
+async function handleFsStat(req) {
+  const safe = await enforceSandbox(req.realPath);
+  return statDiskFile(safe);
+}
+async function handleFsReaddir(req) {
+  const safe = await enforceSandbox(req.realPath);
+  return readDiskDir(safe);
+}
+async function handleFsUnlink(req) {
+  const safe = await enforceSandbox(req.realPath);
+  await fs9.unlink(safe);
+  return { ok: true };
+}
+async function handleFsMkdir(req) {
+  const safe = await enforceSandbox(req.realPath);
+  await fs9.mkdir(safe, { recursive: !!req.recursive });
+  return { ok: true };
+}
+
+// src/main/services/simulator-temp-files/index.ts
+var MAX_STORE_ENTRIES = 200;
+var PENDING_TIMEOUT_MS = 500;
+function enforceStoreCap(store) {
+  while (store.size > MAX_STORE_ENTRIES) {
+    const next = store.keys().next();
+    if (next.done) break;
+    store.delete(next.value);
+  }
+}
+function setupSimulatorTempFiles(simSession) {
+  const store = /* @__PURE__ */ new Map();
+  const pendingWaiters = /* @__PURE__ */ new Map();
+  let disposed = false;
+  function drainWaiters(path18) {
+    const list = pendingWaiters.get(path18);
+    if (!list) return;
+    pendingWaiters.delete(path18);
+    for (const fn of list) fn();
+  }
+  function drainAllWaiters() {
+    const lists = Array.from(pendingWaiters.values());
+    pendingWaiters.clear();
+    for (const list of lists) for (const fn of list) fn();
+  }
+  const simulatorOnlyPolicy = (sender) => !sender.isDestroyed() && sender.session === simSession;
+  const registry = new IpcRegistry(simulatorOnlyPolicy);
+  registry.on("simulator:temp-file:write", (_event, payload) => {
+    if (disposed) return;
+    const { path: path18, mime, bytes } = payload;
+    registerTempFile(store, path18, mime, bytes);
+    enforceStoreCap(store);
+    drainWaiters(path18);
+  });
+  registry.on("simulator:temp-file:revoke", (_event, payload) => {
+    if (disposed) return;
+    const { path: path18 } = payload;
+    revokeTempFile(store, path18);
+  });
+  registry.on("simulator:temp-file:revoke-all", () => {
+    if (disposed) return;
+    revokeAllTempFiles(store);
+  });
+  try {
+    simSession.protocol.unhandle("difile");
+  } catch {
+  }
+  simSession.protocol.handle("difile", async (req) => {
+    const url = req.url;
+    const headers = {};
+    try {
+      req.headers.forEach((v, k) => {
+        headers[k] = v;
+      });
+    } catch {
+    }
+    const ctx = { tempStore: store };
+    let res = await handleDifileRequest(ctx, { url, headers });
+    if (res.status === 404 && !disposed && url.startsWith("difile://_tmp/")) {
+      await new Promise((resolve) => {
+        let timer = null;
+        const notify = () => {
+          if (timer) clearTimeout(timer);
+          resolve();
+        };
+        const list = pendingWaiters.get(url) ?? /* @__PURE__ */ new Set();
+        list.add(notify);
+        pendingWaiters.set(url, list);
+        timer = setTimeout(() => {
+          const cur = pendingWaiters.get(url);
+          if (cur) {
+            cur.delete(notify);
+            if (cur.size === 0) pendingWaiters.delete(url);
+          }
+          resolve();
+        }, PENDING_TIMEOUT_MS);
+      });
+      res = await handleDifileRequest(ctx, { url, headers });
+    }
+    return res;
+  });
+  registry.handle(
+    "simulator:fs:read",
+    (_event, payload) => handleFsRead(payload)
+  );
+  registry.handle(
+    "simulator:fs:write",
+    (_event, payload) => handleFsWrite(payload)
+  );
+  registry.handle(
+    "simulator:fs:stat",
+    (_event, payload) => handleFsStat(payload)
+  );
+  registry.handle(
+    "simulator:fs:readdir",
+    (_event, payload) => handleFsReaddir(payload)
+  );
+  registry.handle(
+    "simulator:fs:unlink",
+    (_event, payload) => handleFsUnlink(payload)
+  );
+  registry.handle(
+    "simulator:fs:mkdir",
+    (_event, payload) => handleFsMkdir(payload)
+  );
+  return toDisposable(async () => {
+    disposed = true;
+    drainAllWaiters();
+    store.clear();
+    try {
+      simSession.protocol.unhandle("difile");
+    } catch {
+    }
+    await registry.dispose();
+  });
+}
+
 // src/main/services/update/update-manager.ts
 import { app as app11, shell as shell3 } from "electron";
 var UpdateManager = class {
@@ -3540,6 +4490,16 @@ var UpdateManager = class {
   getCurrentVersion;
   latestUpdate = null;
   downloadedPath = null;
+  /**
+   * Whether this instance has already emitted `Available` once. The periodic
+   * check fires forever (interval default 1h), and downstream UI (qdmp shell
+   * renders a native toast / Notification) is not idempotent — every event
+   * stacks. We dedupe at the source: at most one Available per instance
+   * lifetime, regardless of how the upstream `info.version` shifts. The user
+   * already knows "an update exists"; tracking minor version bumps mid-
+   * session is not worth duplicating the toast.
+   */
+  hasNotified = false;
   timer = null;
   initialTimer = null;
   ipc;
@@ -3613,9 +4573,10 @@ var UpdateManager = class {
   }
   async checkAndNotify() {
     const result = await this.check();
-    if (result.hasUpdate && result.info) {
-      this.mainWindow.webContents.send(UpdateChannel.Available, result.info);
-    }
+    if (!result.hasUpdate || !result.info) return;
+    if (this.hasNotified) return;
+    this.hasNotified = true;
+    this.mainWindow.webContents.send(UpdateChannel.Available, result.info);
   }
 };
 
@@ -3690,7 +4651,7 @@ async function disposeContext(ctx) {
 function createConfiguredMainWindow(config, rendererDir2) {
   const mainWindow = createMainWindow({
     title: config.appName ?? "Dimina DevTools",
-    indexHtml: path12.join(rendererDir2, "entries/main/index.html"),
+    indexHtml: path16.join(rendererDir2, "entries/main/index.html"),
     width: config.window?.width,
     height: config.window?.height,
     minWidth: config.window?.minWidth,
@@ -3788,7 +4749,7 @@ function enableDevRendererAutoReload(rendererDir2) {
     });
   }
   let reloadTimer = null;
-  const watcher = fs7.watch(rendererDir2, { recursive: true }, () => {
+  const watcher = fs10.watch(rendererDir2, { recursive: true }, () => {
     if (reloadTimer) clearTimeout(reloadTimer);
     reloadTimer = setTimeout(() => {
       for (const win of BrowserWindow4.getAllWindows()) {
@@ -3807,7 +4768,12 @@ function enableDevRendererAutoReload(rendererDir2) {
 function createWorkbenchApp(config = {}) {
   let setupPromise = null;
   let appEventsRegistered = false;
+  try {
+    app13.setName(config.appName ?? "Dimina DevTools");
+  } catch {
+  }
   setupCdpPort();
+  registerDifileScheme();
   async function setup() {
     if (setupPromise) return setupPromise;
     setupPromise = app13.whenReady().then(async () => {
@@ -3816,8 +4782,11 @@ function createWorkbenchApp(config = {}) {
       const mainWindow = createConfiguredMainWindow(config, rendererDir2);
       const context = createContext(config, mainWindow, rendererDir2);
       context.registry.add(registerAppIpc(context));
+      context.registry.add(registerProjectFsIpc(context));
       context.registry.add(installThemeBackgroundSync());
       registerBuiltinModules(config, context);
+      const simSession = session2.fromPartition("persist:simulator");
+      context.registry.add(setupSimulatorTempFiles(simSession));
       installMenu(config, mainWindow, context);
       const hostIpc = new IpcRegistry(context.senderPolicy);
       context.registry.add(hostIpc);
@@ -3838,6 +4807,9 @@ function createWorkbenchApp(config = {}) {
         },
         dispose: () => disposeContext(context)
       };
+      if (config.onBeforeOpenProject) {
+        context.beforeOpenProject = (projectPath) => config.onBeforeOpenProject({ projectPath, instance });
+      }
       if (config.onSetup) {
         await config.onSetup(instance);
       }
@@ -3864,8 +4836,8 @@ function createWorkbenchApp(config = {}) {
         // prefixes; this callback lets the storage panel filter the CDP
         // snapshot/event stream to the active appId.
         getActiveAppId: () => {
-          const session2 = context.workspace.getSession();
-          const appInfo = session2?.appInfo;
+          const session3 = context.workspace.getSession();
+          const appInfo = session3?.appInfo;
           return appInfo?.appId ?? null;
         }
       }));
@@ -3890,7 +4862,7 @@ function createWorkbenchApp(config = {}) {
 
 // src/main/windows/settings-window/create.ts
 import { BrowserWindow as BrowserWindow5 } from "electron";
-import path13 from "path";
+import path17 from "path";
 async function createSettingsWindow(parent, rendererDir2) {
   const win = new BrowserWindow5({
     width: 420,
@@ -3908,7 +4880,7 @@ async function createSettingsWindow(parent, rendererDir2) {
     }
   });
   applyNavigationHardening(win.webContents, rendererDir2);
-  await win.loadFile(path13.join(rendererDir2, "entries/workbench-settings/index.html"));
+  await win.loadFile(path17.join(rendererDir2, "entries/workbench-settings/index.html"));
   return win;
 }