@dimina-kit/devtools 0.4.0-dev.20260824071518 → 0.4.0-dev.20260828092243

package/dist/main/index.bundle.js

@@ -31,6 +31,9 @@ var DEFAULT_CDP_PORT = 9222;
 var DEFAULT_SCENE = 1001;
 var HEADER_H = 40;
 var HOST_TOOLBAR_RUNTIME_MARKER = "--dimina-host-toolbar";
+var HOST_SIDEBAR_RUNTIME_MARKER = "--dimina-host-sidebar";
+var HOST_DIALOG_RUNTIME_MARKER = "--dimina-host-dialog";
+var HOST_SIDEBAR_DEFAULT_WIDTH = 56;
 
 // src/main/services/settings/index.ts
 import { app, nativeTheme } from "electron";
@@ -494,64 +497,6 @@ var ProjectsChannel = {
 var DialogChannel = {
   OpenDirectory: "dialog:openDirectory"
 };
-var ViewChannel = {
-  /**
-   * Reverse size-advertiser: the host-toolbar WCV's OWN renderer advertises its
-   * intrinsic content height so main reserves exactly that much. Payload
-   * `{ axis: 'block', extent }`. fire-and-forget (send), NOT invoke.
-   */
-  HostToolbarAdvertiseHeight: "view:host-toolbar:advertise-height",
-  /**
-   * main → host-toolbar WCV renderer: per-load MessagePort handshake for the
-   * gated narrow channel. On every toolbar `did-finish-load` main creates a
-   * `MessageChannelMain` and transfers port2 here
-   * (`wc.postMessage(HostToolbarPort, null, [port2])`); the session-resident
-   * toolbar runtime preload receives it via `event.ports[0]` and bridges it to
-   * the page as `window.diminaHostToolbar`. Envelope both directions:
-   * `{ channel: string, payload: unknown }`.
-   */
-  HostToolbarPort: "view:host-toolbar:port",
-  /**
-   * main → main-window renderer: push the reserved host-toolbar height so the
-   * renderer placeholder div resizes (closing the dynamic-height loop).
-   */
-  HostToolbarHeightChanged: "view:host-toolbar:height-changed",
-  /**
-   * main ← main-window renderer (invoke): pull the last NOTIFIED toolbar
-   * height retained in main. Mount-time replay companion to
-   * `HostToolbarHeightChanged`: the push listener mounts with the project
-   * view and the toolbar's size-advertiser deduplicates (never re-reports),
-   * so a height pushed while no project view was mounted would otherwise be
-   * lost forever (cold start on the project list races it; close-project →
-   * reopen hits it deterministically). No payload; resolves a number.
-   */
-  HostToolbarGetHeight: "view:host-toolbar:get-height",
-  /**
-   * Renderer → main: the window-level placement snapshot (one monotonic epoch
-   * per commit tick, one generation per renderer lifetime) that drives the view
-   * reconciler. The single source of truth for every managed native view's
-   * bounds/visibility/z-order — supersedes the per-view bounds channels above.
-   * invoke.
-   */
-  PlacementSnapshot: "view:placement-snapshot"
-};
-var PopoverChannel = {
-  Show: "popover:show",
-  Hide: "popover:hide",
-  Relaunch: "popover:relaunch",
-  Closed: "popover:closed",
-  Init: "popover:init"
-};
-var OverlayChannel = {
-  Ready: "overlay:ready"
-};
-var TooltipChannel = {
-  Prepare: "tooltip:prepare",
-  Show: "tooltip:show",
-  Hide: "tooltip:hide",
-  Init: "tooltip:init",
-  Measured: "tooltip:measured"
-};
 var WindowChannel = {
   NavigateBack: "window:navigateBack",
   OpenProject: "window:openProject",
@@ -574,19 +519,6 @@ var InternalDevtoolsChannel = {
   // its own dedicated window (see internal-devtools-window/index.ts).
   Open: "internal-devtools:open"
 };
-var SettingsChannel = {
-  SetVisible: "settings:setVisible",
-  ConfigChanged: "settings:configChanged",
-  ProjectSettingsChanged: "settings:projectSettingsChanged",
-  Init: "settings:init"
-};
-var UpdateChannel = {
-  Check: "updates:check",
-  Download: "updates:download",
-  Install: "updates:install",
-  DownloadProgress: "updates:downloadProgress",
-  Available: "updates:available"
-};
 
 // src/main/ipc/project-fs.ts
 import { WATCH_IGNORE_DIRS } from "@dimina-kit/devkit/watch-ignore";
@@ -921,7 +853,7 @@ function registerProjectFsIpc(ctx) {
 }
 
 // src/main/app/app.ts
-import { app as app13, BrowserWindow as BrowserWindow6, nativeImage, session as session2 } from "electron";
+import { app as app13, BrowserWindow as BrowserWindow5, nativeImage, session as session2 } from "electron";
 import fs10 from "fs";
 import path19 from "path";
 
@@ -954,6 +886,14 @@ var hostToolbarRuntimePreloadPath = path3.join(
   devtoolsPackageRoot,
   "dist/preload/windows/host-toolbar-runtime.cjs"
 );
+var hostSidebarRuntimePreloadPath = path3.join(
+  devtoolsPackageRoot,
+  "dist/preload/windows/host-sidebar-runtime.cjs"
+);
+var hostDialogRuntimePreloadPath = path3.join(
+  devtoolsPackageRoot,
+  "dist/preload/windows/host-dialog-runtime.cjs"
+);
 var simulatorDir = path3.join(devtoolsPackageRoot, "dist/simulator");
 var runtimeAssetPaths = {
   root: path3.join(devtoolsPackageRoot, "dist"),
@@ -1595,6 +1535,10 @@ function createWorkbenchSenderPolicy(ctx) {
     if (popoverViewId != null && sender.id === popoverViewId) return true;
     const tooltipViewId = ctx.views.getTooltipWebContentsId();
     if (tooltipViewId != null && sender.id === tooltipViewId) return true;
+    const projectCreateDialogViewId = ctx.views.getProjectCreateDialogWebContentsId();
+    if (projectCreateDialogViewId != null && sender.id === projectCreateDialogViewId) return true;
+    const updateDialogViewId = ctx.views.getUpdateDialogWebContentsId();
+    if (updateDialogViewId != null && sender.id === updateDialogViewId) return true;
     return false;
   };
 }
@@ -1614,6 +1558,148 @@ var defaultAdapter = {
   }
 };
 
+// src/shared/ipc-channels-overlays.ts
+var ViewChannel = {
+  /**
+   * Reverse size-advertiser: the host-toolbar WCV's OWN renderer advertises its
+   * intrinsic content height so main reserves exactly that much. Payload
+   * `{ axis: 'block', extent }`. fire-and-forget (send), NOT invoke.
+   */
+  HostToolbarAdvertiseHeight: "view:host-toolbar:advertise-height",
+  /**
+   * main → host-toolbar WCV renderer: per-load MessagePort handshake for the
+   * gated narrow channel. On every toolbar `did-finish-load` main creates a
+   * `MessageChannelMain` and transfers port2 here
+   * (`wc.postMessage(HostToolbarPort, null, [port2])`); the session-resident
+   * toolbar runtime preload receives it via `event.ports[0]` and bridges it to
+   * the page as `window.diminaHostToolbar`. Envelope both directions:
+   * `{ channel: string, payload: unknown }`.
+   */
+  HostToolbarPort: "view:host-toolbar:port",
+  /**
+   * main → main-window renderer: push the reserved host-toolbar height so the
+   * renderer placeholder div resizes (closing the dynamic-height loop).
+   */
+  HostToolbarHeightChanged: "view:host-toolbar:height-changed",
+  /**
+   * main ← main-window renderer (invoke): pull the last NOTIFIED toolbar
+   * height retained in main. Mount-time replay companion to
+   * `HostToolbarHeightChanged`: the push listener mounts with the project
+   * view and the toolbar's size-advertiser deduplicates (never re-reports),
+   * so a height pushed while no project view was mounted would otherwise be
+   * lost forever (cold start on the project list races it; close-project →
+   * reopen hits it deterministically). No payload; resolves a number.
+   */
+  HostToolbarGetHeight: "view:host-toolbar:get-height",
+  /**
+   * Reverse size-advertiser for the host-sidebar WCV, mirroring
+   * `HostToolbarAdvertiseHeight` on the inline (width) axis instead of block.
+   * Payload `{ axis: 'inline', extent }`. fire-and-forget (send), NOT invoke.
+   */
+  HostSidebarAdvertiseWidth: "view:host-sidebar:advertise-width",
+  /**
+   * main → host-sidebar WCV renderer: per-load MessagePort handshake, same
+   * contract as `HostToolbarPort` (see that entry).
+   */
+  HostSidebarPort: "view:host-sidebar:port",
+  /**
+   * main → main-window renderer: push the reserved host-sidebar width so the
+   * renderer placeholder div resizes, mirroring `HostToolbarHeightChanged`.
+   */
+  HostSidebarWidthChanged: "view:host-sidebar:width-changed",
+  /**
+   * main ← main-window renderer (invoke): pull the last NOTIFIED sidebar
+   * width, mirroring `HostToolbarGetHeight`'s mount-time replay role.
+   */
+  HostSidebarGetWidth: "view:host-sidebar:get-width",
+  /**
+   * main → main-window renderer: push the project category (`Project.type`)
+   * selected in the host-sidebar's content — devtools' own default icon rail,
+   * or any downstream replacement that sends on the same channel. No
+   * pull/replay companion like `HostSidebarGetWidth`: the default category is
+   * a stable initial value regardless of load-order, and nothing is ever sent
+   * before the main-window renderer (and thus `ProjectListScreen`) is already
+   * mounted.
+   */
+  HostSidebarCategorySelected: "view:host-sidebar:category-selected",
+  /**
+   * Reverse size-advertiser for the host-dialog WCV. Unlike the toolbar/sidebar
+   * (single-axis, `setBaseDesired`-placed strips), the dialog is a BOTH-AXES
+   * overlay positioned by `setOverlayDesired` — main centers it in the main
+   * window once it knows both dimensions. One channel carries either axis'
+   * report (`{ axis: 'block' | 'inline', extent }`); the dialog's own content
+   * advertises both from the same root (see `host-dialog-advertiser.ts`).
+   * fire-and-forget (send), NOT invoke.
+   *
+   * No `HostDialogSizeChanged` / `HostDialogGetSize` counterparts: those exist
+   * for toolbar/sidebar so a renderer-owned PLACEHOLDER can replay a size it
+   * missed. The dialog has no such placeholder — it is a main-driven overlay
+   * shown/hidden on demand (`hostDialog.show()`/`hide()`), so there is nothing
+   * in the renderer to replay a size into.
+   */
+  HostDialogAdvertiseSize: "view:host-dialog:advertise-size",
+  /**
+   * main → host-dialog WCV renderer: per-load MessagePort handshake, same
+   * contract as `HostToolbarPort` (see that entry).
+   */
+  HostDialogPort: "view:host-dialog:port",
+  /**
+   * Renderer → main: the window-level placement snapshot (one monotonic epoch
+   * per commit tick, one generation per renderer lifetime) that drives the view
+   * reconciler. The single source of truth for every managed native view's
+   * bounds/visibility/z-order — supersedes the per-view bounds channels above.
+   * invoke.
+   */
+  PlacementSnapshot: "view:placement-snapshot",
+  /**
+   * main ← main-window renderer (invoke): allocate a fresh placement
+   * generation seed for this renderer bootstrap. See
+   * renderer-placement-generation.ts for why the seed comes from main
+   * (a wall-clock `Date.now()` seed is not guaranteed to exceed main's
+   * still-standing high-water mark across two reloads that happen faster
+   * than the clock's resolution). No payload; resolves a number.
+   */
+  AllocatePlacementGeneration: "view:allocate-placement-generation"
+};
+var PopoverChannel = {
+  Show: "popover:show",
+  Hide: "popover:hide",
+  Relaunch: "popover:relaunch",
+  Closed: "popover:closed",
+  Init: "popover:init"
+};
+var OverlayChannel = {
+  Ready: "overlay:ready"
+};
+var TooltipChannel = {
+  Prepare: "tooltip:prepare",
+  Show: "tooltip:show",
+  Hide: "tooltip:hide",
+  Init: "tooltip:init",
+  Measured: "tooltip:measured"
+};
+var ProjectCreateChannel = {
+  Show: "projectCreate:show",
+  Init: "projectCreate:init",
+  Submit: "projectCreate:submit",
+  Cancel: "projectCreate:cancel",
+  Submitted: "projectCreate:submitted"
+};
+var SettingsChannel = {
+  SetVisible: "settings:setVisible",
+  ConfigChanged: "settings:configChanged",
+  ProjectSettingsChanged: "settings:projectSettingsChanged",
+  Init: "settings:init"
+};
+var UpdateChannel = {
+  Check: "updates:check",
+  Download: "updates:download",
+  Install: "updates:install",
+  DownloadProgress: "updates:downloadProgress",
+  Available: "updates:available",
+  Close: "updates:close"
+};
+
 // src/main/services/notifications/renderer-notifier.ts
 function liveWebContents(wc) {
   if (!wc) return null;
@@ -1652,9 +1738,18 @@ function createRendererNotifier(ctx) {
     hostToolbarHeightChanged(height) {
       sendToMain(ViewChannel.HostToolbarHeightChanged, height);
     },
+    hostSidebarWidthChanged(width) {
+      sendToMain(ViewChannel.HostSidebarWidthChanged, width);
+    },
+    hostSidebarCategorySelected(category) {
+      sendToMain(ViewChannel.HostSidebarCategorySelected, category);
+    },
     editorOpenFile(payload) {
       sendToMain(EditorChannel.OpenFile, payload);
     },
+    projectCreateSubmitted(payload) {
+      sendToMain(ProjectCreateChannel.Submitted, payload);
+    },
     popoverInit(popoverView, payload) {
       const wc = liveWebContents(popoverView.webContents);
       if (!wc) return;
@@ -1665,6 +1760,16 @@ function createRendererNotifier(ctx) {
       if (!wc) return;
       wc.send(TooltipChannel.Init, payload);
     },
+    projectCreateInit(dialogView, payload) {
+      const wc = liveWebContents(dialogView.webContents);
+      if (!wc) return;
+      wc.send(ProjectCreateChannel.Init, payload);
+    },
+    updateAvailable(dialogView, payload) {
+      const wc = liveWebContents(dialogView.webContents);
+      if (!wc) return;
+      wc.send(UpdateChannel.Available, payload);
+    },
     settingsInit(payload) {
       const wc = liveWebContents(ctx.views.getSettingsWebContents());
       if (!wc) return;
@@ -1933,6 +2038,7 @@ function createPlacementReconciler(ctx) {
   let placementState = createInitialState();
   let epochCounter = 0;
   let rendererGeneration = 0;
+  let allocatedGeneration = 0;
   const appliedActual = /* @__PURE__ */ new Map();
   const baseDesired = /* @__PURE__ */ new Map();
   const overlayDesired = /* @__PURE__ */ new Map();
@@ -2022,6 +2128,12 @@ function createPlacementReconciler(ctx) {
     placementState = { ...placementState, actual: cloneAppliedActual() };
   }
   function setPlacementSnapshot(snapshot) {
+    if (snapshot.generation < rendererGeneration) {
+      console.warn(
+        `[placement-reconciler] snapshot generation ${snapshot.generation} is behind the current ${rendererGeneration}; dropping without applying its content`
+      );
+      return;
+    }
     rendererGeneration = snapshot.generation;
     baseDesired.clear();
     for (const v of snapshot.views) baseDesired.set(v.viewId, v);
@@ -2059,7 +2171,11 @@ function createPlacementReconciler(ctx) {
     deleteOverlayDesired: (viewId) => {
       overlayDesired.delete(viewId);
     },
-    hasOverlayDesired: (viewId) => overlayDesired.has(viewId)
+    hasOverlayDesired: (viewId) => overlayDesired.has(viewId),
+    allocateGeneration: () => {
+      allocatedGeneration = Math.max(allocatedGeneration, rendererGeneration) + 1;
+      return allocatedGeneration;
+    }
   };
 }
 
@@ -2072,16 +2188,26 @@ var VIEW_ID = {
   simulatorDevtools: "simulator-devtools",
   workbench: "workbench",
   hostToolbar: "host-toolbar",
+  hostSidebar: "host-sidebar",
+  hostDialog: "host-dialog",
   settings: "settings",
   popover: "popover",
-  tooltip: "tooltip"
+  tooltip: "tooltip",
+  projectCreateDialog: "project-create-dialog",
+  updateDialog: "update-dialog"
 };
 var VIEW_LAYER = {
   base: 0,
   hostToolbar: 5,
+  hostSidebar: 5,
   settings: 10,
   popover: 20,
-  tooltip: 30
+  tooltip: 30,
+  // devtools' own ProjectCreateDialog/UpdateDialog panels (createOverlayPanel).
+  dialog: 40,
+  // Host-controlled fully-custom dialog (loadURL-level takeover); sits above
+  // devtools' own dialog layer so host content is never occluded by it.
+  hostDialog: 45
 };
 
 // src/main/services/views/workbench-view.ts
@@ -4855,34 +4981,44 @@ function createDevtoolsHost(ctx, reconciler, deps) {
   };
 }
 
-// src/main/services/views/host-toolbar-view.ts
-import { WebContentsView as WebContentsView5 } from "electron";
+// src/main/services/views/host-slot-session-runtime.ts
+import { session } from "electron";
+function createHostSlotSessionRuntime(preloadPath) {
+  let refCount = 0;
+  let registrationId = null;
+  return {
+    acquire() {
+      if (refCount === 0) {
+        registrationId = session.defaultSession.registerPreloadScript({
+          type: "frame",
+          filePath: preloadPath
+        });
+      }
+      refCount++;
+    },
+    release() {
+      if (refCount === 0) return;
+      refCount--;
+      if (refCount === 0 && registrationId !== null) {
+        session.defaultSession.unregisterPreloadScript(registrationId);
+        registrationId = null;
+      }
+    }
+  };
+}
 
 // src/main/services/views/host-toolbar-session-runtime.ts
-import { session } from "electron";
-var refCount = 0;
-var registrationId = null;
+var runtime = createHostSlotSessionRuntime(hostToolbarRuntimePreloadPath);
 function acquireHostToolbarSessionRuntime() {
-  if (refCount === 0) {
-    registrationId = session.defaultSession.registerPreloadScript({
-      type: "frame",
-      filePath: hostToolbarRuntimePreloadPath
-    });
-  }
-  refCount++;
+  runtime.acquire();
 }
 function releaseHostToolbarSessionRuntime() {
-  if (refCount === 0) return;
-  refCount--;
-  if (refCount === 0 && registrationId !== null) {
-    session.defaultSession.unregisterPreloadScript(registrationId);
-    registrationId = null;
-  }
+  runtime.release();
 }
 
-// src/main/services/views/host-toolbar-port-channel.ts
+// src/main/services/views/host-slot-port-channel.ts
 import { MessageChannelMain } from "electron";
-function createHostToolbarPortChannel(opts) {
+function createHostSlotPortChannel(opts) {
   let activePort = null;
   let activeWc = null;
   let state = "absent";
@@ -4894,7 +5030,14 @@ function createHostToolbarPortChannel(opts) {
     const { channel, payload } = data;
     if (typeof channel !== "string") return;
     for (const entry of [...handlers2]) {
-      if (entry.channel === channel) entry.handler(payload);
+      if (entry.channel === channel) invokeMessageHandler(entry.handler, payload);
+    }
+  }
+  function invokeMessageHandler(handler, payload) {
+    try {
+      handler(payload);
+    } catch (err2) {
+      console.error(`${opts.logPrefix} onMessage handler threw:`, err2);
     }
   }
   function dropActivePort(close, next) {
@@ -4913,7 +5056,7 @@ function createHostToolbarPortChannel(opts) {
     try {
       handler();
     } catch (err2) {
-      console.error("[host-toolbar] onReady handler threw:", err2);
+      console.error(`${opts.logPrefix} onReady handler threw:`, err2);
     }
   }
   function fireReadyHandlers() {
@@ -4932,7 +5075,7 @@ function createHostToolbarPortChannel(opts) {
     port1.on("close", () => {
       if (activePort === port1) dropActivePort(false, "absent");
     });
-    wc.postMessage(ViewChannel.HostToolbarPort, null, [port2]);
+    wc.postMessage(opts.channel, null, [port2]);
     port1.start();
     activePort = port1;
     activeWc = wc;
@@ -4963,7 +5106,7 @@ function createHostToolbarPortChannel(opts) {
     onMessage(channel, handler) {
       if (typeof channel !== "string" || channel === "") {
         throw new TypeError(
-          "hostToolbar.onMessage: channel must be a non-empty string"
+          `${opts.logPrefix} onMessage: channel must be a non-empty string`
         );
       }
       const entry = { channel, handler };
@@ -5011,135 +5154,401 @@ function createHostToolbarPortChannel(opts) {
   };
 }
 
-// src/main/services/views/host-toolbar-view.ts
-function createHostToolbarView(ctx, reconciler, deps) {
-  let hostToolbarView = null;
-  let hostToolbarPreloadOverride = null;
-  let hostToolbarRuntimeAcquired = false;
-  let hostToolbarHeightMode = "auto";
-  let hostToolbarLastHeight = 0;
-  const hostToolbarPort = createHostToolbarPortChannel({
-    isCurrent: (wc) => liveHostToolbarWebContents() === wc
+// src/main/services/views/host-toolbar-port-channel.ts
+function createHostToolbarPortChannel(opts) {
+  return createHostSlotPortChannel({
+    isCurrent: opts.isCurrent,
+    channel: ViewChannel.HostToolbarPort,
+    logPrefix: "[host-toolbar]"
   });
-  function liveHostToolbarWebContents() {
-    const wc = hostToolbarView?.webContents;
+}
+
+// src/main/services/views/managed-web-contents-view.ts
+import { WebContentsView as WebContentsView5 } from "electron";
+function createManagedWebContentsView(opts) {
+  let view = null;
+  let preloadOverride = null;
+  let runtimeAcquired = false;
+  function liveWebContents2() {
+    const wc = view?.webContents;
     if (!wc || wc.isDestroyed()) return null;
     return wc;
   }
-  function ensureHostToolbarView() {
-    if (hostToolbarView && liveHostToolbarWebContents()) {
-      return hostToolbarView;
+  function teardown(current, detail) {
+    if (view !== current) return;
+    console.error(`[${opts.viewId}] ${detail} \u2014 destroying so the next ensureView() rebuilds`);
+    view = null;
+    opts.reconciler.destroyView(opts.viewId, current);
+    opts.onBroken?.();
+  }
+  function ensureView() {
+    if (view && liveWebContents2()) {
+      return view;
     }
-    if (hostToolbarView) {
-      reconciler.destroyView(VIEW_ID.hostToolbar, hostToolbarView);
+    if (view) {
+      opts.reconciler.destroyView(opts.viewId, view);
     }
-    if (!hostToolbarRuntimeAcquired) {
-      acquireHostToolbarSessionRuntime();
-      hostToolbarRuntimeAcquired = true;
+    if (!runtimeAcquired) {
+      opts.sessionRuntime.acquire();
+      runtimeAcquired = true;
     }
     const webPreferences = {
       nodeIntegration: false,
       contextIsolation: true,
       sandbox: false,
-      additionalArguments: [HOST_TOOLBAR_RUNTIME_MARKER]
+      additionalArguments: [opts.marker]
     };
-    if (hostToolbarPreloadOverride !== null) {
-      webPreferences.preload = hostToolbarPreloadOverride;
+    if (preloadOverride !== null) {
+      webPreferences.preload = preloadOverride;
     }
-    const view = new WebContentsView5({ webPreferences });
-    hostToolbarView = view;
-    hostToolbarPort.attach(view.webContents);
+    const next = new WebContentsView5({ webPreferences });
+    view = next;
+    opts.port.attach(next.webContents);
     try {
-      view.setBackgroundColor("#121212");
+      next.setBackgroundColor("#121212");
     } catch {
     }
     try {
-      view.webContents.setWindowOpenHandler(({ url }) => handleWindowOpenExternal(url));
+      next.webContents.setWindowOpenHandler(({ url }) => handleWindowOpenExternal(url));
     } catch {
     }
-    return view;
-  }
-  function notifyHostToolbarHeight(height) {
-    hostToolbarLastHeight = height;
-    ctx.notify.hostToolbarHeightChanged(height);
-    deps.reapplyPresentOverlays();
-  }
-  function setHostToolbarHeight(extent) {
-    if (hostToolbarHeightMode !== "auto") return;
-    notifyHostToolbarHeight(extent);
-  }
-  function hideHostToolbar() {
-    reconciler.setBaseDesired(VIEW_ID.hostToolbar, {
-      viewId: VIEW_ID.hostToolbar,
-      placement: { visible: false },
-      layer: VIEW_LAYER.hostToolbar
+    next.webContents.on("did-fail-load", (_event, errorCode, _errorDescription, _validatedURL, isMainFrame) => {
+      if (!isMainFrame || errorCode === -3) return;
+      teardown(next, `did-fail-load (code ${errorCode})`);
     });
-    reconciler.reconcileNow();
-    notifyHostToolbarHeight(0);
+    next.webContents.on("render-process-gone", (_event, details) => {
+      teardown(next, `render-process-gone (${details.reason})`);
+    });
+    return next;
   }
-  const control = {
+  return {
     async loadURL(url) {
-      const view = ensureHostToolbarView();
-      hostToolbarPort.invalidate();
-      await view.webContents.loadURL(url);
+      const v = ensureView();
+      opts.port.invalidate();
+      await v.webContents.loadURL(url);
     },
     async loadFile(filePath) {
-      const view = ensureHostToolbarView();
-      hostToolbarPort.invalidate();
-      await view.webContents.loadFile(filePath);
+      const v = ensureView();
+      opts.port.invalidate();
+      await v.webContents.loadFile(filePath);
+    },
+    liveWebContents: liveWebContents2,
+    getView: () => view,
+    setPreloadPath(path20) {
+      preloadOverride = path20;
     },
+    ensureView,
+    dispose() {
+      opts.port.dispose();
+      opts.reconciler.destroyView(opts.viewId, view);
+      view = null;
+      if (runtimeAcquired) {
+        opts.sessionRuntime.release();
+        runtimeAcquired = false;
+      }
+    }
+  };
+}
+
+// src/main/services/views/host-slot-view.ts
+function deriveSlotControl(base, extra) {
+  return {
+    loadURL: (url) => base.loadURL(url),
+    loadFile: (filePath) => base.loadFile(filePath),
     get webContents() {
-      return liveHostToolbarWebContents();
+      return base.webContents;
     },
-    hide() {
-      hideHostToolbar();
+    hide: () => base.hide(),
+    setPreloadPath: (path20) => base.setPreloadPath(path20),
+    onMessage: (channel, handler) => base.onMessage(channel, handler),
+    onReady: (handler) => base.onReady(handler),
+    send: (channel, payload) => base.send(channel, payload),
+    ...extra
+  };
+}
+function createHostSlotView(reconciler, config, deps) {
+  let extentMode = "auto";
+  let lastExtent = 0;
+  let lastAdvertisedExtent = null;
+  const port = config.portChannel;
+  const managed = createManagedWebContentsView({
+    reconciler,
+    viewId: config.viewId,
+    marker: config.marker,
+    sessionRuntime: config.sessionRuntime,
+    port
+  });
+  function notifyExtent(extent) {
+    lastExtent = extent;
+    deps.onExtentChanged(extent);
+    deps.reapplyPresentOverlays?.();
+  }
+  function setExtent(extent) {
+    lastAdvertisedExtent = extent;
+    if (extentMode !== "auto") return;
+    notifyExtent(extent);
+  }
+  function hideView() {
+    reconciler.setBaseDesired(config.viewId, {
+      viewId: config.viewId,
+      placement: { visible: false },
+      layer: config.layer
+    });
+    reconciler.reconcileNow();
+    notifyExtent(0);
+    lastAdvertisedExtent = null;
+  }
+  const control = {
+    loadURL: (url) => managed.loadURL(url),
+    loadFile: (filePath) => managed.loadFile(filePath),
+    get webContents() {
+      return managed.liveWebContents();
     },
-    setPreloadPath(path20) {
-      hostToolbarPreloadOverride = path20;
+    hide() {
+      hideView();
     },
-    setHeightMode(mode) {
+    setPreloadPath: (path20) => managed.setPreloadPath(path20),
+    setExtentMode(mode) {
       if (mode !== "auto" && !(Number.isFinite(mode.fixed) && mode.fixed >= 0)) {
         throw new TypeError(
-          `hostToolbar.setHeightMode: fixed height must be a finite, non-negative number (got ${mode.fixed})`
+          `${config.setExtentModeErrorLabel}: fixed extent must be a finite, non-negative number (got ${mode.fixed})`
         );
       }
-      hostToolbarHeightMode = mode;
+      extentMode = mode;
       if (mode !== "auto") {
-        notifyHostToolbarHeight(mode.fixed);
+        notifyExtent(mode.fixed);
+      } else if (lastAdvertisedExtent !== null && lastAdvertisedExtent !== lastExtent) {
+        notifyExtent(lastAdvertisedExtent);
       }
     },
     onMessage(channel, handler) {
-      return hostToolbarPort.onMessage(channel, handler);
+      return port.onMessage(channel, handler);
     },
     onReady(handler) {
-      return hostToolbarPort.onReady(handler);
+      return port.onReady(handler);
     },
     send(channel, payload) {
-      return hostToolbarPort.send(channel, payload);
+      return port.send(channel, payload);
     }
   };
-  reconciler.registerView(VIEW_ID.hostToolbar, {
-    getView: () => hostToolbarView,
-    ensureView: () => ensureHostToolbarView(),
+  reconciler.registerView(config.viewId, {
+    getView: () => managed.getView(),
+    ensureView: () => managed.ensureView(),
     ensureLazy: (desired) => {
-      if (desired?.placement.visible && !liveHostToolbarWebContents()) ensureHostToolbarView();
+      if (desired?.placement.visible && !managed.liveWebContents()) managed.ensureView();
+    }
+  });
+  return {
+    control,
+    setExtent,
+    getExtent: () => lastExtent,
+    getWebContentsId: () => managed.liveWebContents()?.id ?? null,
+    dispose: () => managed.dispose()
+  };
+}
+
+// src/main/services/views/host-toolbar-view.ts
+function createHostToolbarView(ctx, reconciler, deps) {
+  const port = createHostToolbarPortChannel({
+    isCurrent: (wc) => slot.getWebContentsId() === wc.id
+  });
+  const slot = createHostSlotView(
+    reconciler,
+    {
+      viewId: VIEW_ID.hostToolbar,
+      layer: VIEW_LAYER.hostToolbar,
+      marker: HOST_TOOLBAR_RUNTIME_MARKER,
+      sessionRuntime: {
+        acquire: acquireHostToolbarSessionRuntime,
+        release: releaseHostToolbarSessionRuntime
+      },
+      portChannel: port,
+      setExtentModeErrorLabel: "hostToolbar.setHeightMode"
+    },
+    {
+      onExtentChanged: (height) => ctx.notify.hostToolbarHeightChanged(height),
+      reapplyPresentOverlays: () => deps.reapplyPresentOverlays()
+    }
+  );
+  const control = deriveSlotControl(slot.control, {
+    setHeightMode: (mode) => slot.control.setExtentMode(mode)
+  });
+  return {
+    control,
+    setHostToolbarHeight: (extent) => slot.setExtent(extent),
+    getHostToolbarHeight: () => slot.getExtent(),
+    getHostToolbarWebContentsId: () => slot.getWebContentsId(),
+    dispose: () => slot.dispose()
+  };
+}
+
+// src/main/services/views/host-sidebar-session-runtime.ts
+var runtime2 = createHostSlotSessionRuntime(hostSidebarRuntimePreloadPath);
+function acquireHostSidebarSessionRuntime() {
+  runtime2.acquire();
+}
+function releaseHostSidebarSessionRuntime() {
+  runtime2.release();
+}
+
+// src/main/services/views/host-sidebar-port-channel.ts
+function createHostSidebarPortChannel(opts) {
+  return createHostSlotPortChannel({
+    isCurrent: opts.isCurrent,
+    channel: ViewChannel.HostSidebarPort,
+    logPrefix: "[host-sidebar]"
+  });
+}
+
+// src/main/services/views/host-sidebar-view.ts
+function createHostSidebarView(ctx, reconciler) {
+  const port = createHostSidebarPortChannel({
+    isCurrent: (wc) => slot.getWebContentsId() === wc.id
+  });
+  const slot = createHostSlotView(
+    reconciler,
+    {
+      viewId: VIEW_ID.hostSidebar,
+      layer: VIEW_LAYER.hostSidebar,
+      marker: HOST_SIDEBAR_RUNTIME_MARKER,
+      sessionRuntime: {
+        acquire: acquireHostSidebarSessionRuntime,
+        release: releaseHostSidebarSessionRuntime
+      },
+      portChannel: port,
+      setExtentModeErrorLabel: "hostSidebar.setWidthMode"
+    },
+    {
+      onExtentChanged: (width) => ctx.notify.hostSidebarWidthChanged(width)
     }
+  );
+  const control = deriveSlotControl(slot.control, {
+    setWidthMode: (mode) => slot.control.setExtentMode(mode)
   });
-  function dispose() {
-    hostToolbarPort.dispose();
-    reconciler.destroyView(VIEW_ID.hostToolbar, hostToolbarView);
-    hostToolbarView = null;
-    if (hostToolbarRuntimeAcquired) {
-      releaseHostToolbarSessionRuntime();
-      hostToolbarRuntimeAcquired = false;
+  return {
+    control,
+    setHostSidebarWidth: (extent) => slot.setExtent(extent),
+    getHostSidebarWidth: () => slot.getExtent(),
+    getHostSidebarWebContentsId: () => slot.getWebContentsId(),
+    dispose: () => slot.dispose()
+  };
+}
+
+// src/main/services/views/host-dialog-session-runtime.ts
+var runtime3 = createHostSlotSessionRuntime(hostDialogRuntimePreloadPath);
+function acquireHostDialogSessionRuntime() {
+  runtime3.acquire();
+}
+function releaseHostDialogSessionRuntime() {
+  runtime3.release();
+}
+
+// src/main/services/views/host-dialog-port-channel.ts
+function createHostDialogPortChannel(opts) {
+  return createHostSlotPortChannel({
+    isCurrent: opts.isCurrent,
+    channel: ViewChannel.HostDialogPort,
+    logPrefix: "[host-dialog]"
+  });
+}
+
+// src/main/services/views/host-dialog-view.ts
+var DEFAULT_WIDTH = 480;
+var DEFAULT_HEIGHT = 320;
+function createHostDialogView(ctx, reconciler) {
+  const port = createHostDialogPortChannel({
+    isCurrent: (wc) => managed.liveWebContents()?.id === wc.id
+  });
+  let visible = false;
+  let width = DEFAULT_WIDTH;
+  let height = DEFAULT_HEIGHT;
+  const managed = createManagedWebContentsView({
+    reconciler,
+    viewId: VIEW_ID.hostDialog,
+    marker: HOST_DIALOG_RUNTIME_MARKER,
+    sessionRuntime: {
+      acquire: acquireHostDialogSessionRuntime,
+      release: releaseHostDialogSessionRuntime
+    },
+    port,
+    onBroken: () => {
+      visible = false;
+      reconciler.deleteOverlayDesired(VIEW_ID.hostDialog);
     }
+  });
+  function computeBounds() {
+    const [winW = 0, winH = 0] = ctx.windows.mainWindow.getContentSize();
+    const w = Math.min(width, Math.max(1, winW));
+    const h = Math.min(height, Math.max(1, winH));
+    return {
+      x: Math.max(0, Math.round((winW - w) / 2)),
+      y: Math.max(0, Math.round((winH - h) / 2)),
+      width: w,
+      height: h
+    };
   }
+  function present() {
+    reconciler.setOverlayDesired(VIEW_ID.hostDialog, {
+      viewId: VIEW_ID.hostDialog,
+      placement: { visible: true, bounds: computeBounds() },
+      layer: VIEW_LAYER.hostDialog
+    });
+    reconciler.reconcileNow();
+  }
+  function reportMeasuredExtent(axis, extent) {
+    if (!Number.isFinite(extent) || extent <= 0) return;
+    if (axis === "inline") {
+      width = extent;
+    } else {
+      height = extent;
+    }
+    if (visible) present();
+  }
+  function resetMeasuredExtent() {
+    width = DEFAULT_WIDTH;
+    height = DEFAULT_HEIGHT;
+    if (visible) present();
+  }
+  const control = {
+    loadURL: (url) => {
+      resetMeasuredExtent();
+      return managed.loadURL(url);
+    },
+    loadFile: (filePath) => {
+      resetMeasuredExtent();
+      return managed.loadFile(filePath);
+    },
+    get webContents() {
+      return managed.liveWebContents();
+    },
+    setPreloadPath: (path20) => managed.setPreloadPath(path20),
+    onMessage: (channel, handler) => port.onMessage(channel, handler),
+    onReady: (handler) => port.onReady(handler),
+    send: (channel, payload) => port.send(channel, payload),
+    show() {
+      managed.ensureView();
+      visible = true;
+      present();
+    },
+    hide() {
+      visible = false;
+      reconciler.deleteOverlayDesired(VIEW_ID.hostDialog);
+      reconciler.reconcileNow();
+    },
+    isVisible: () => visible
+  };
+  reconciler.registerView(VIEW_ID.hostDialog, {
+    getView: () => managed.getView(),
+    ensureView: () => managed.ensureView()
+  });
   return {
     control,
-    setHostToolbarHeight,
-    getHostToolbarHeight: () => hostToolbarLastHeight,
-    getHostToolbarWebContentsId: () => liveHostToolbarWebContents()?.id ?? null,
-    dispose
+    reportMeasuredExtent,
+    getHostDialogWebContentsId: () => managed.liveWebContents()?.id ?? null,
+    reposition: () => {
+      if (visible) present();
+    },
+    dispose: () => managed.dispose()
   };
 }
 
@@ -5272,6 +5681,44 @@ function createOverlayPanelsView(ctx, reconciler, deps) {
     pushData: (view, data) => ctx.notify.tooltipInit(view, data),
     readyMode: "manual"
   });
+  function fullWindowBounds() {
+    const [width = 0, height = 0] = ctx.windows.mainWindow.getContentSize();
+    return { x: 0, y: 0, width: Math.max(1, width), height: Math.max(1, height) };
+  }
+  const projectCreateDialogPanel = createOverlayPanel({
+    electron: { createWebContentsView: (opts) => new WebContentsView6(opts) },
+    rendererDir: ctx.rendererDir,
+    entry: "entries/project-create-dialog/index.html",
+    webPreferences: {
+      nodeIntegration: false,
+      contextIsolation: true,
+      sandbox: false,
+      preload: mainPreloadPath
+    },
+    hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+    setDesired: overlayDesiredSetter(VIEW_ID.projectCreateDialog, VIEW_LAYER.dialog),
+    registerView: (getView) => reconciler.registerView(VIEW_ID.projectCreateDialog, { getView }),
+    destroyView: (view) => reconciler.destroyView(VIEW_ID.projectCreateDialog, view),
+    pushData: (view, data) => ctx.notify.projectCreateInit(view, data),
+    readyMode: "manual"
+  });
+  const updateDialogPanel = createOverlayPanel({
+    electron: { createWebContentsView: (opts) => new WebContentsView6(opts) },
+    rendererDir: ctx.rendererDir,
+    entry: "entries/update-dialog/index.html",
+    webPreferences: {
+      nodeIntegration: false,
+      contextIsolation: true,
+      sandbox: false,
+      preload: mainPreloadPath
+    },
+    hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+    setDesired: overlayDesiredSetter(VIEW_ID.updateDialog, VIEW_LAYER.dialog),
+    registerView: (getView) => reconciler.registerView(VIEW_ID.updateDialog, { getView }),
+    destroyView: (view) => reconciler.destroyView(VIEW_ID.updateDialog, view),
+    pushData: (view, data) => ctx.notify.updateAvailable(view, data),
+    readyMode: "manual"
+  });
   let tooltipRequestId = 0;
   let activeTooltip = null;
   async function showSettings() {
@@ -5311,10 +5758,29 @@ function createOverlayPanelsView(ctx, reconciler, deps) {
     activeTooltip = null;
     tooltipPanel.hide();
   }
+  function showProjectCreateDialog(data) {
+    projectCreateDialogPanel.show(data, fullWindowBounds());
+  }
+  function hideProjectCreateDialog() {
+    projectCreateDialogPanel.hide();
+  }
+  function showUpdateDialog(data) {
+    updateDialogPanel.show(data, fullWindowBounds());
+  }
+  function hideUpdateDialog() {
+    updateDialogPanel.hide();
+  }
+  function notifyUpdateDownloadProgress(percent) {
+    const wc = updateDialogPanel.getWebContents();
+    if (!wc) return;
+    wc.send(UpdateChannel.DownloadProgress, { percent });
+  }
   function markOverlayReady(webContentsId) {
     settingsPanel.markReady(webContentsId);
     popoverPanel.markReady(webContentsId);
     tooltipPanel.markReady(webContentsId);
+    projectCreateDialogPanel.markReady(webContentsId);
+    updateDialogPanel.markReady(webContentsId);
   }
   function applyTooltipMeasurement(webContentsId, measurement) {
     const active = activeTooltip;
@@ -5324,20 +5790,36 @@ function createOverlayPanelsView(ctx, reconciler, deps) {
     tooltipPanel.reposition(computeTooltipBounds(active.anchor, w, h, measurement));
   }
   function reapplyPresentOverlays() {
-    if (settingsPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.settings)) void showSettings();
+    if (settingsPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.settings)) {
+      showSettings().catch(() => {
+      });
+    }
     if (popoverPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.popover)) {
       const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
       popoverPanel.reposition(computePopoverBounds(w, h, overlayHeaderHeight()));
     }
+    if (projectCreateDialogPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.projectCreateDialog)) {
+      projectCreateDialogPanel.reposition(fullWindowBounds());
+    }
+    if (updateDialogPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.updateDialog)) {
+      updateDialogPanel.reposition(fullWindowBounds());
+    }
   }
   function applySettingsBoundsIfPresent() {
-    if (settingsPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.settings)) void showSettings();
+    if (settingsPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.settings)) {
+      showSettings().catch(() => {
+      });
+    }
   }
   function destroySettings() {
     activeTooltip = null;
     settingsPanel.destroy();
     tooltipPanel.destroy();
   }
+  function destroyDialogs() {
+    projectCreateDialogPanel.destroy();
+    updateDialogPanel.destroy();
+  }
   return {
     showSettings,
     hideSettings,
@@ -5348,13 +5830,21 @@ function createOverlayPanelsView(ctx, reconciler, deps) {
     hideTooltip,
     markOverlayReady,
     applyTooltipMeasurement,
+    showProjectCreateDialog,
+    hideProjectCreateDialog,
+    showUpdateDialog,
+    hideUpdateDialog,
+    notifyUpdateDownloadProgress,
     reapplyPresentOverlays,
     applySettingsBoundsIfPresent,
     destroySettings,
+    destroyDialogs,
     getSettingsWebContents: () => settingsPanel.getWebContents(),
     getSettingsWebContentsId: () => settingsPanel.getWebContentsId(),
     getPopoverWebContentsId: () => popoverPanel.getWebContentsId(),
-    getTooltipWebContentsId: () => tooltipPanel.getWebContentsId()
+    getTooltipWebContentsId: () => tooltipPanel.getWebContentsId(),
+    getProjectCreateDialogWebContentsId: () => projectCreateDialogPanel.getWebContentsId(),
+    getUpdateDialogWebContentsId: () => updateDialogPanel.getWebContentsId()
   };
 }
 
@@ -5693,6 +6183,8 @@ function createViewManager(ctx) {
   const hostToolbar = createHostToolbarView(ctx, reconciler, {
     reapplyPresentOverlays: () => reapplyToolbarDependentOverlays()
   });
+  const hostSidebar = createHostSidebarView(ctx, reconciler);
+  const hostDialog = createHostDialogView(ctx, reconciler);
   const overlayPanels = createOverlayPanelsView(ctx, reconciler, {
     getHostToolbarHeight: hostToolbar.getHostToolbarHeight
   });
@@ -5713,6 +6205,9 @@ function createViewManager(ctx) {
     workbench.cancelWorkbenchAttachHold();
     disposeProjectViews();
     hostToolbar.dispose();
+    hostSidebar.dispose();
+    hostDialog.dispose();
+    overlayPanels.destroyDialogs();
   }
   return {
     attachNativeSimulator: nativeSimulator.attachNativeSimulator,
@@ -5729,7 +6224,17 @@ function createViewManager(ctx) {
     hideTooltip: overlayPanels.hideTooltip,
     markOverlayReady: overlayPanels.markOverlayReady,
     applyTooltipMeasurement: overlayPanels.applyTooltipMeasurement,
-    repositionAll: () => overlayPanels.reapplyPresentOverlays(),
+    showProjectCreateDialog: overlayPanels.showProjectCreateDialog,
+    hideProjectCreateDialog: overlayPanels.hideProjectCreateDialog,
+    showUpdateDialog: overlayPanels.showUpdateDialog,
+    hideUpdateDialog: overlayPanels.hideUpdateDialog,
+    notifyUpdateDownloadProgress: overlayPanels.notifyUpdateDownloadProgress,
+    getProjectCreateDialogWebContentsId: overlayPanels.getProjectCreateDialogWebContentsId,
+    getUpdateDialogWebContentsId: overlayPanels.getUpdateDialogWebContentsId,
+    repositionAll: () => {
+      overlayPanels.reapplyPresentOverlays();
+      hostDialog.reposition();
+    },
     disposeProjectViews,
     disposeAll,
     getSimulatorWebContentsId: nativeSimulator.getSimulatorWebContentsId,
@@ -5743,6 +6248,7 @@ function createViewManager(ctx) {
     getHostToolbarHeight: hostToolbar.getHostToolbarHeight,
     resize: () => overlayPanels.applySettingsBoundsIfPresent(),
     setPlacementSnapshot: reconciler.setPlacementSnapshot,
+    allocatePlacementGeneration: reconciler.allocateGeneration,
     attachWorkbench: workbench.attachWorkbench,
     setWorkbenchSource: workbench.setWorkbenchSource,
     detachWorkbench: workbench.detachWorkbench,
@@ -5750,7 +6256,14 @@ function createViewManager(ctx) {
     holdWorkbenchAttach: workbench.holdWorkbenchAttach,
     cancelWorkbenchAttachHold: workbench.cancelWorkbenchAttachHold,
     setHostToolbarHeight: hostToolbar.setHostToolbarHeight,
-    hostToolbar: hostToolbar.control
+    hostToolbar: hostToolbar.control,
+    getHostSidebarWebContentsId: hostSidebar.getHostSidebarWebContentsId,
+    getHostSidebarWidth: hostSidebar.getHostSidebarWidth,
+    setHostSidebarWidth: hostSidebar.setHostSidebarWidth,
+    hostSidebar: hostSidebar.control,
+    getHostDialogWebContentsId: hostDialog.getHostDialogWebContentsId,
+    reportHostDialogMeasuredExtent: hostDialog.reportMeasuredExtent,
+    hostDialog: hostDialog.control
   };
 }
 
@@ -5885,6 +6398,29 @@ import { app as app6 } from "electron";
 import path9 from "path";
 import fs5 from "fs";
 var log2 = createLogger("projects");
+function readProjectConfig(dirPath) {
+  let merged = {};
+  for (const fileName of ["project.config.json", "project.private.config.json"]) {
+    const configPath = path9.join(dirPath, fileName);
+    if (!fs5.existsSync(configPath)) continue;
+    try {
+      merged = { ...merged, ...JSON.parse(fs5.readFileSync(configPath, "utf-8")) };
+    } catch (err2) {
+      log2.warn(`Failed to parse ${configPath}`, err2);
+    }
+  }
+  return merged;
+}
+function detectRuntimeType(dirPath) {
+  const compileType = readProjectConfig(dirPath).compileType;
+  if (compileType === "game") return "minigame";
+  if (compileType === "miniprogram") return "miniprogram";
+  const hasMiniProgramConfig = fs5.existsSync(path9.join(dirPath, "app.json"));
+  const hasMiniGameConfig = fs5.existsSync(path9.join(dirPath, "game.json"));
+  const hasMiniGameEntry = ["game.js", "game.ts"].some((fileName) => fs5.existsSync(path9.join(dirPath, fileName)));
+  if (!hasMiniProgramConfig && hasMiniGameConfig && hasMiniGameEntry) return "minigame";
+  return "miniprogram";
+}
 function getProjectsFile() {
   return path9.join(app6.getPath("userData"), "dimina-projects.json");
 }
@@ -5908,6 +6444,12 @@ function validateProjectDir(dirPath) {
   if (!fs5.existsSync(dirPath)) {
     return `\u5C0F\u7A0B\u5E8F\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${dirPath}`;
   }
+  if (detectRuntimeType(dirPath) === "minigame") {
+    if (!fs5.existsSync(path9.join(dirPath, "game.json"))) {
+      return "\u8BE5\u76EE\u5F55\u7F3A\u5C11 game.json\uFF0C\u8BF7\u9009\u62E9\u5305\u542B\u5C0F\u6E38\u620F\u6E90\u7801\u7684\u76EE\u5F55";
+    }
+    return null;
+  }
   if (!fs5.existsSync(path9.join(dirPath, "app.json"))) {
     const configPath = path9.join(dirPath, "project.config.json");
     if (fs5.existsSync(configPath)) {
@@ -5940,10 +6482,11 @@ function addProject(dirPath) {
   } catch (err2) {
     log2.warn("Failed to read project name from config", err2);
   }
-  const project = { name, path: dirPath, lastOpened: null };
+  const type = detectRuntimeType(dirPath);
+  const project = { name, path: dirPath, lastOpened: null, type };
   const idx = projects.findIndex((p) => p.path === dirPath);
   if (idx >= 0) {
-    projects[idx] = { ...projects[idx], name };
+    projects[idx] = { ...projects[idx], name, type };
   } else {
     projects.unshift(project);
   }
@@ -5964,13 +6507,17 @@ function updateLastOpened(dirPath) {
 function getCompileConfig(dirPath) {
   const projects = load();
   const project = projects.find((p) => p.path === dirPath);
-  return project?.compileConfig ?? {
-    startPage: "",
+  if (project?.compileConfig) return project.compileConfig;
+  return {
+    startPage: getProjectPages(dirPath).entryPagePath,
     scene: DEFAULT_SCENE,
     queryParams: []
   };
 }
 function getProjectPages(dirPath) {
+  if (detectRuntimeType(dirPath) === "minigame") {
+    return { pages: ["game"], entryPagePath: "game" };
+  }
   const appJsonPath = path9.join(dirPath, "app.json");
   try {
     const appJson = JSON.parse(
@@ -6800,6 +7347,19 @@ var TooltipMeasuredSchema = z3.tuple([
     height: z3.number().finite().positive()
   })
 ]);
+var ProjectCreateShowSchema = z3.tuple([
+  z3.object({
+    templates: z3.array(z3.looseObject({})),
+    defaultBaseDir: z3.string()
+  })
+]);
+var ProjectCreateSubmitSchema = z3.tuple([
+  z3.object({
+    name: z3.string().min(1),
+    path: AbsolutePath,
+    templateId: z3.string().min(1)
+  })
+]);
 var SimWidth = z3.number().int().min(100).max(2e3);
 var SimulatorAttachNativeSchema = z3.tuple([
   z3.string().url().refine((u) => u.startsWith("http://") || u.startsWith("https://"), {
@@ -6865,6 +7425,18 @@ var HostToolbarAdvertiseHeightSchema = z3.tuple([
     extent: NonNegInt
   })
 ]);
+var HostSidebarAdvertiseWidthSchema = z3.tuple([
+  z3.object({
+    axis: z3.literal("inline"),
+    extent: NonNegInt
+  })
+]);
+var HostDialogAdvertiseSizeSchema = z3.tuple([
+  z3.object({
+    axis: z3.union([z3.literal("block"), z3.literal("inline")]),
+    extent: NonNegInt
+  })
+]);
 var SimulatorCustomApiInvokeSchema = z3.tuple([
   z3.string().min(1).max(256),
   z3.unknown()
@@ -6968,6 +7540,20 @@ function registerTooltipIpc(ctx) {
   });
 }
 
+// src/main/ipc/project-create.ts
+function registerProjectCreateIpc(ctx) {
+  return new IpcRegistry(ctx.senderPolicy).on(ProjectCreateChannel.Show, (_event, ...args) => {
+    const [data] = validate(ProjectCreateChannel.Show, ProjectCreateShowSchema, args);
+    ctx.views.showProjectCreateDialog(data);
+  }).on(ProjectCreateChannel.Cancel, () => {
+    ctx.views.hideProjectCreateDialog();
+  }).on(ProjectCreateChannel.Submit, (_event, ...args) => {
+    const [input] = validate(ProjectCreateChannel.Submit, ProjectCreateSubmitSchema, args);
+    ctx.views.hideProjectCreateDialog();
+    ctx.notify.projectCreateSubmitted(input);
+  });
+}
+
 // src/main/ipc/projects.ts
 import { app as app8, dialog } from "electron";
 import path13 from "path";
@@ -7087,6 +7673,9 @@ function registerProjectsIpc(ctx) {
         buttons: ["\u786E\u5B9A"]
       });
     }
+    const importedCategory = project.type ?? "miniprogram";
+    ctx.notify.hostSidebarCategorySelected(importedCategory);
+    ctx.views.hostSidebar.send("project-category-forced", { category: importedCategory });
     return project;
   }).handle(ProjectsChannel.Remove, (_event, ...args) => {
     const [dirPath] = validate(ProjectsChannel.Remove, ProjectsRemoveSchema, args);
@@ -7253,13 +7842,13 @@ function registerSettingsIpc(ctx) {
     };
   }).handle(WorkbenchSettingsChannel.GetMcpStatus, () => {
     const settings = loadWorkbenchSettings();
-    const runtime = getMcpStatus();
+    const runtime4 = getMcpStatus();
     return {
       configured: settings.mcp.enabled,
       configuredPort: settings.mcp.port,
-      running: runtime.running,
-      activePort: runtime.port,
-      error: runtime.error
+      running: runtime4.running,
+      activePort: runtime4.port,
+      error: runtime4.error
     };
   }).handle(SettingsChannel.SetVisible, async (_, ...args) => {
     const [visible] = validate(SettingsChannel.SetVisible, SettingsSetVisibleSchema, args);
@@ -7307,6 +7896,76 @@ function registerInternalDevtoolsIpc(ctx) {
   });
 }
 
+// src/main/ipc/views.ts
+import { ipcMain as ipcMain3 } from "electron";
+function registerViewsIpc(ctx) {
+  const registry = new IpcRegistry(ctx.senderPolicy).handle(ViewChannel.AllocatePlacementGeneration, () => ctx.views.allocatePlacementGeneration()).handle(ViewChannel.PlacementSnapshot, (_event, ...args) => {
+    const [snapshot] = validate(
+      ViewChannel.PlacementSnapshot,
+      PlacementSnapshotSchema,
+      args
+    );
+    ctx.views.setPlacementSnapshot(snapshot);
+  }).handle(ViewChannel.HostToolbarGetHeight, () => ctx.views.getHostToolbarHeight()).handle(ViewChannel.HostSidebarGetWidth, () => ctx.views.getHostSidebarWidth());
+  const onAdvertiseHeight = (event, ...args) => {
+    if (event.sender.id !== ctx.views.getHostToolbarWebContentsId()) return;
+    let extent;
+    try {
+      ;
+      [{ extent }] = validate(
+        ViewChannel.HostToolbarAdvertiseHeight,
+        HostToolbarAdvertiseHeightSchema,
+        args
+      );
+    } catch {
+      return;
+    }
+    ctx.views.setHostToolbarHeight(extent);
+  };
+  ipcMain3.on(ViewChannel.HostToolbarAdvertiseHeight, onAdvertiseHeight);
+  const onAdvertiseWidth = (event, ...args) => {
+    if (event.sender.id !== ctx.views.getHostSidebarWebContentsId()) return;
+    let extent;
+    try {
+      ;
+      [{ extent }] = validate(
+        ViewChannel.HostSidebarAdvertiseWidth,
+        HostSidebarAdvertiseWidthSchema,
+        args
+      );
+    } catch {
+      return;
+    }
+    ctx.views.setHostSidebarWidth(extent);
+  };
+  ipcMain3.on(ViewChannel.HostSidebarAdvertiseWidth, onAdvertiseWidth);
+  const onAdvertiseDialogSize = (event, ...args) => {
+    if (event.sender.id !== ctx.views.getHostDialogWebContentsId()) return;
+    let axis;
+    let extent;
+    try {
+      ;
+      [{ axis, extent }] = validate(
+        ViewChannel.HostDialogAdvertiseSize,
+        HostDialogAdvertiseSizeSchema,
+        args
+      );
+    } catch {
+      return;
+    }
+    ctx.views.reportHostDialogMeasuredExtent(axis, extent);
+  };
+  ipcMain3.on(ViewChannel.HostDialogAdvertiseSize, onAdvertiseDialogSize);
+  return {
+    dispose() {
+      void registry.dispose();
+      ipcMain3.removeListener(ViewChannel.HostToolbarAdvertiseHeight, onAdvertiseHeight);
+      ipcMain3.removeListener(ViewChannel.HostSidebarAdvertiseWidth, onAdvertiseWidth);
+      ipcMain3.removeListener(ViewChannel.HostDialogAdvertiseSize, onAdvertiseDialogSize);
+    }
+  };
+}
+
 // src/main/ipc/simulator-module.ts
 import { DisposableRegistry as DisposableRegistry3 } from "@dimina-kit/electron-deck/main";
 
@@ -7341,47 +8000,11 @@ function installBridgeRouter(ctx) {
   installRuntimeBridgeRouter(ctx);
 }
 
-// src/main/ipc/views.ts
-import { ipcMain as ipcMain3 } from "electron";
-function registerViewsIpc(ctx) {
-  const registry = new IpcRegistry(ctx.senderPolicy).handle(ViewChannel.PlacementSnapshot, (_event, ...args) => {
-    const [snapshot] = validate(
-      ViewChannel.PlacementSnapshot,
-      PlacementSnapshotSchema,
-      args
-    );
-    ctx.views.setPlacementSnapshot(snapshot);
-  }).handle(ViewChannel.HostToolbarGetHeight, () => ctx.views.getHostToolbarHeight());
-  const onAdvertiseHeight = (event, ...args) => {
-    if (event.sender.id !== ctx.views.getHostToolbarWebContentsId()) return;
-    let extent;
-    try {
-      ;
-      [{ extent }] = validate(
-        ViewChannel.HostToolbarAdvertiseHeight,
-        HostToolbarAdvertiseHeightSchema,
-        args
-      );
-    } catch {
-      return;
-    }
-    ctx.views.setHostToolbarHeight(extent);
-  };
-  ipcMain3.on(ViewChannel.HostToolbarAdvertiseHeight, onAdvertiseHeight);
-  return {
-    dispose() {
-      void registry.dispose();
-      ipcMain3.removeListener(ViewChannel.HostToolbarAdvertiseHeight, onAdvertiseHeight);
-    }
-  };
-}
-
 // src/main/ipc/simulator-module.ts
 var simulatorModule = {
   setup: (ctx) => {
     const reg = new DisposableRegistry3();
     reg.add(registerSimulatorIpc(ctx));
-    reg.add(registerViewsIpc(ctx));
     installBridgeRouter(ctx);
     return reg;
   }
@@ -10025,7 +10648,9 @@ async function startWorkbenchCoiServer(options) {
 import { app as app11, shell as shell3 } from "electron";
 var UpdateManager = class {
   checker;
-  mainWindow;
+  showUpdatePanel;
+  notifyDownloadProgress;
+  hideUpdatePanel;
   getCurrentVersion;
   latestUpdate = null;
   downloadedPath = null;
@@ -10042,16 +10667,26 @@ var UpdateManager = class {
   timer = null;
   initialTimer = null;
   ipc;
+  /**
+   * Set by `dispose()`. Clearing the timers only stops FUTURE ticks — an
+   * in-flight `checkAndNotify()` invocation (already past its `await
+   * this.check()`) has no timer left to cancel it, and would otherwise call
+   * `showUpdatePanel` after dispose has torn down the overlay panel that
+   * owns (e.g. `views.disposeAll()` destroying its WebContentsView).
+   */
+  disposed = false;
   constructor(opts) {
     this.checker = opts.checker;
-    this.mainWindow = opts.mainWindow;
+    this.showUpdatePanel = opts.showUpdatePanel;
+    this.notifyDownloadProgress = opts.notifyDownloadProgress;
+    this.hideUpdatePanel = opts.hideUpdatePanel;
     this.getCurrentVersion = opts.getCurrentVersion ?? (() => app11.getVersion());
     this.ipc = new IpcRegistry(opts.senderPolicy);
     this.registerIpc();
     this.startPeriodicCheck(opts.checkInterval ?? 60 * 60 * 1e3, opts.initialDelay ?? 5e3);
   }
   registerIpc() {
-    this.ipc.handle(UpdateChannel.Check, async () => this.check()).handle(UpdateChannel.Download, async () => this.download()).handle(UpdateChannel.Install, async () => this.install());
+    this.ipc.handle(UpdateChannel.Check, async () => this.check()).handle(UpdateChannel.Download, async () => this.download()).handle(UpdateChannel.Install, async () => this.install()).on(UpdateChannel.Close, () => this.hideUpdatePanel());
   }
   async check() {
     try {
@@ -10075,7 +10710,7 @@ var UpdateManager = class {
     }
     try {
       const filePath = await this.checker.downloadUpdate(this.latestUpdate, (percent) => {
-        this.mainWindow.webContents.send(UpdateChannel.DownloadProgress, { percent });
+        this.notifyDownloadProgress(percent);
       });
       this.downloadedPath = filePath;
       return { success: true, filePath };
@@ -10103,6 +10738,7 @@ var UpdateManager = class {
    * the timer clears + handler removals are scheduled synchronously.
    */
   dispose() {
+    this.disposed = true;
     if (this.timer) {
       clearInterval(this.timer);
       this.timer = null;
@@ -10119,10 +10755,11 @@ var UpdateManager = class {
   }
   async checkAndNotify() {
     const result = await this.check();
+    if (this.disposed) return;
     if (!result.hasUpdate || !result.info) return;
     if (this.hasNotified) return;
     this.hasNotified = true;
-    this.mainWindow.webContents.send(UpdateChannel.Available, result.info);
+    this.showUpdatePanel(result.info);
   }
 };
 
@@ -10564,7 +11201,7 @@ function enableDevRendererAutoReload(rendererDir2) {
   const watcher = fs10.watch(rendererDir2, { recursive: true }, () => {
     if (reloadTimer) clearTimeout(reloadTimer);
     reloadTimer = setTimeout(() => {
-      for (const win of BrowserWindow6.getAllWindows()) {
+      for (const win of BrowserWindow5.getAllWindows()) {
         win.webContents.reload();
       }
     }, 300);
@@ -10604,6 +11241,8 @@ async function createDevtoolsRuntime(config = {}, onInstanceCreated) {
   context.registry.add(toDisposable5(() => context.internalDevtoolsWindow?.dispose()));
   context.registry.add(registerInternalDevtoolsIpc(context));
   context.registry.add(registerTooltipIpc(context));
+  context.registry.add(registerProjectCreateIpc(context));
+  context.registry.add(registerViewsIpc(context));
   context.registry.add((0, simulator_session_policy_exports.setupSimulatorSessionPolicy)());
   context.registry.add(installThemeBackgroundSync());
   if (!config.adapter) context.registry.add(setupCompileWorkerStandby(context));
@@ -10656,13 +11295,27 @@ async function createDevtoolsRuntime(config = {}, onInstanceCreated) {
   instance.registerSimulatorApi("login", async () => {
     return "hello";
   });
+  context.registry.add(
+    context.views.hostSidebar.onMessage("project-category-selected", (payload) => {
+      const category = payload?.category;
+      if (category !== "miniprogram" && category !== "minigame") return;
+      context.notify.hostSidebarCategorySelected(category);
+    })
+  );
+  context.views.hostSidebar.loadFile(path19.join(rendererDir2, "entries/host-sidebar-default/index.html")).catch((err2) => {
+    console.warn("[workbench] failed to load host-sidebar default content:", err2);
+  });
+  context.views.hostSidebar.setWidthMode({ fixed: HOST_SIDEBAR_DEFAULT_WIDTH });
+  context.views.hostSidebar.setWidthMode("auto");
   if (config.onSetup) {
     await config.onSetup(instance);
   }
   if (config.updateChecker) {
     instance.updateManager = new UpdateManager({
       checker: config.updateChecker,
-      mainWindow,
+      showUpdatePanel: (info) => context.views.showUpdateDialog(info),
+      notifyDownloadProgress: (percent) => context.views.notifyUpdateDownloadProgress(percent),
+      hideUpdatePanel: () => context.views.hideUpdateDialog(),
       senderPolicy: context.senderPolicy,
       checkInterval: config.updateOptions?.checkInterval,
       initialDelay: config.updateOptions?.initialDelay,