@dimina-kit/devtools 0.4.0 → 0.5.0-dev.20260908120530

package/dist/shared/ipc-schemas.js

@@ -22,10 +22,9 @@ export const ProjectsAddSchema = z.tuple([AbsolutePath]);
 /** project:open — absolute project path. */
 export const ProjectOpenSchema = z.tuple([AbsolutePath]);
 /**
- * Shared shape for CompileConfig payloads (used by saveCompileConfig,
- * settings:configChanged, and popover:relaunch). Permissive on the outer
- * object so we stay forward-compatible with new fields; the known top-level
- * keys are validated to catch wrong types early.
+ * Shared shape for CompileConfig payloads. Permissive on the outer object so
+ * we stay forward-compatible with new fields; the known top-level keys are
+ * validated to catch wrong types early.
  */
 const CompileConfigShape = z.looseObject({
     startPage: z.string().optional(),
@@ -41,8 +40,100 @@ export const ProjectSaveCompileConfigSchema = z.tuple([
     AbsolutePath,
     CompileConfigShape,
 ]);
+/**
+ * Shared shape for the stored compile-mode list (`condition.miniprogram` in
+ * project.config.json). Loose because WeChat writes fields we carry through
+ * untouched; `normalizeCompileModes` does the semantic coercion after this
+ * structural check.
+ */
+// `.default('')` (not `.optional()`) so the parsed type matches CompileMode's
+// required `name`/`query` strings — a command's mode is always a complete
+// CompileMode, never a partial patch.
+const CompileModeShape = z.looseObject({
+    name: z.string().default(''),
+    pathName: z.string(),
+    query: z.string().default(''),
+    scene: z.number().nullable().default(null),
+});
+/** project:getCompileModeState — absolute project path. */
+export const ProjectGetCompileModeStateSchema = z.tuple([AbsolutePath]);
+/**
+ * A compile-mode id: minted by the store, never empty. `select` alone also
+ * allows `null` (普通编译), so it is not part of this shape.
+ */
+const CompileModeId = z.string().min(1);
+/**
+ * The single command shape the popover sends instead of a whole new list —
+ * main is the only thing that interprets it against the live store. Mirrors
+ * `CompileModeCommand` in `compile-mode-state.ts`.
+ */
+export const CompileModeCommandSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('select'), id: CompileModeId.nullable() }),
+    z.object({ type: z.literal('add'), mode: CompileModeShape }),
+    z.object({ type: z.literal('update'), id: CompileModeId, mode: CompileModeShape }),
+    z.object({ type: z.literal('remove'), id: CompileModeId }),
+]);
+/** popover:apply — the command to interpret against the open project's store. */
+export const PopoverApplySchema = z.tuple([
+    z.object({
+        command: CompileModeCommandSchema,
+    }),
+]);
 /** popover:show — must be an object (not undefined/null/string). */
 export const PopoverShowSchema = z.tuple([z.looseObject({})]);
+/**
+ * tooltip:show — the trigger's own bounding rect (CSS px, main-window content
+ * coordinates — same space `getBoundingClientRect()` reports, no conversion,
+ * mirrors the base-view placement snapshot's Bounds) plus the label text.
+ */
+export const TooltipShowSchema = z.tuple([
+    z.object({
+        anchor: z.object({
+            x: z.number().finite(),
+            y: z.number().finite(),
+            width: z.number().finite().nonnegative(),
+            height: z.number().finite().nonnegative(),
+        }),
+        text: z.string().min(1).max(200),
+    }),
+]);
+export const TooltipMeasuredSchema = z.tuple([
+    z.object({
+        requestId: z.number().int().positive(),
+        width: z.number().finite().positive(),
+        height: z.number().finite().positive(),
+    }),
+]);
+/**
+ * projectCreate:show — the merged template catalog + suggested base dir
+ * main.tsx already resolved before asking main to show the overlay panel.
+ * Templates are re-validated loosely (they only round-trip back into the
+ * panel's own render, never interpreted main-side).
+ */
+export const ProjectCreateShowSchema = z.tuple([
+    z.object({
+        templates: z.array(z.looseObject({})),
+        defaultBaseDir: z.string(),
+    }),
+]);
+/** projectCreate:submit — the collected create-project form. */
+export const ProjectCreateSubmitSchema = z.tuple([
+    z.object({
+        name: z.string().min(1),
+        path: AbsolutePath,
+        templateId: z.string().min(1),
+    }),
+]);
+/**
+ * devicePicker:show / devicePicker:select — the device name only. The panel
+ * reads the device table from `@devicekit/devices` itself, the same source the
+ * toolbar reads, so the catalog never crosses IPC.
+ */
+export const DevicePickerDeviceSchema = z.tuple([
+    z.object({
+        deviceName: z.string().min(1),
+    }),
+]);
 /**
  * Reasonable simulator width range. Window width is clamped UI-side, but
  * we still reject obvious garbage (negative, zero, absurdly large).
@@ -79,15 +170,16 @@ export const SimulatorSoftReloadSchema = z.tuple([
  */
 export const SimulatorSetDeviceInfoSchema = z.tuple([
     z.object({
+        device: z.string().max(64).optional(),
         brand: z.string().max(64),
         model: z.string().max(64),
         system: z.string().max(64),
-        platform: z.string().max(32),
+        platform: z.enum(['ios', 'android', 'harmony']),
+        orientation: z.enum(['portrait', 'landscape']),
         pixelRatio: z.number().finite().positive(),
         screenWidth: z.number().int().min(100).max(4000),
         screenHeight: z.number().int().min(100).max(4000),
         statusBarHeight: z.number().finite().min(0).max(400),
-        notchType: z.enum(['none', 'notch', 'dynamic-island']),
         safeAreaInsets: z.object({
             top: z.number().finite().min(0).max(400),
             right: z.number().finite().min(0).max(400),
@@ -144,6 +236,27 @@ export const HostToolbarAdvertiseHeightSchema = z.tuple([
         extent: NonNegInt,
     }),
 ]);
+/**
+ * host-sidebar reverse size-advertiser payload — mirrors
+ * `HostToolbarAdvertiseHeightSchema` on the inline (width) axis.
+ */
+export const HostSidebarAdvertiseWidthSchema = z.tuple([
+    z.object({
+        axis: z.literal('inline'),
+        extent: NonNegInt,
+    }),
+]);
+/**
+ * host-dialog reverse size-advertiser payload. Unlike the single-axis
+ * toolbar/sidebar, the dialog's content advertises BOTH axes over the same
+ * channel — `axis` distinguishes which report this is.
+ */
+export const HostDialogAdvertiseSizeSchema = z.tuple([
+    z.object({
+        axis: z.union([z.literal('block'), z.literal('inline')]),
+        extent: NonNegInt,
+    }),
+]);
 /**
  * simulator:custom-apis:invoke — API name + arbitrary JSON-serialisable params.
  *
@@ -158,8 +271,22 @@ export const SimulatorCustomApiInvokeSchema = z.tuple([
 export const ProjectGetPagesSchema = z.tuple([AbsolutePath]);
 /** project:getCompileConfig — absolute project path. */
 export const ProjectGetCompileConfigSchema = z.tuple([AbsolutePath]);
+/**
+ * projects:update — absolute project directory path + the editable subset of
+ * its record. The path is the identity of the record being edited, never a
+ * field of the patch.
+ */
+export const ProjectsUpdateSchema = z.tuple([
+    AbsolutePath,
+    z.object({
+        name: z.string().min(1).max(200).optional(),
+        iconUrl: z.string().max(2048).optional(),
+    }),
+]);
 /** projects:remove — absolute project directory path. */
 export const ProjectsRemoveSchema = z.tuple([AbsolutePath]);
+/** projects:openEditDialog — absolute project directory path. */
+export const ProjectsOpenEditDialogSchema = z.tuple([AbsolutePath]);
 /**
  * workbenchSettings:save — full WorkbenchSettings object.
  *
@@ -179,7 +306,10 @@ export const WorkbenchSettingsSaveSchema = z.tuple([
             port: z.number().int().min(0).max(65535),
         }),
         compile: z.looseObject({
-            watch: z.boolean(),
+            autoBuild: z.boolean(),
+        }),
+        preview: z.looseObject({
+            autoReload: z.boolean(),
         }),
         theme: z.enum(['system', 'light', 'dark']),
         lastCreateBaseDir: z.union([z.string(), z.null()]),
@@ -191,10 +321,6 @@ export const WorkbenchSettingsSetThemeSchema = z.tuple([
 ]);
 /** settings:setVisible — boolean. */
 export const SettingsSetVisibleSchema = z.tuple([z.boolean()]);
-/** settings:configChanged — full CompileConfig object (see shared/types.ts). */
-export const SettingsConfigChangedSchema = z.tuple([CompileConfigShape]);
-/** popover:relaunch — full CompileConfig object pushed back to main on relaunch. */
-export const PopoverRelaunchSchema = z.tuple([CompileConfigShape]);
 /**
  * settings:projectSettingsChanged — Partial<ProjectSettings>.
  *
@@ -211,38 +337,4 @@ export const SettingsProjectSettingsChangedSchema = z.tuple([
 export const ProjectCaptureThumbnailSchema = z.tuple([AbsolutePath]);
 /** project:getThumbnail — absolute project path. */
 export const ProjectGetThumbnailSchema = z.tuple([AbsolutePath]);
-/** project:getLaunchConfigs — absolute project path. */
-export const ProjectGetLaunchConfigsSchema = z.tuple([AbsolutePath]);
-/**
- * project:saveLaunchConfigs — absolute path + array of launch configs.
- * Each config extends CompileConfig with `id` and `name`.
- */
-const LaunchConfigShape = z.looseObject({
-    id: z.string().min(1),
-    name: z.string(),
-    startPage: z.string().optional(),
-    scene: z.number().optional(),
-    queryParams: z
-        .array(z.looseObject({ key: z.string(), value: z.string() }))
-        .optional(),
-});
-export const ProjectSaveLaunchConfigsSchema = z.tuple([
-    AbsolutePath,
-    z.array(LaunchConfigShape),
-]);
-/** project:getActiveLaunchConfigId — absolute project path. */
-export const ProjectGetActiveLaunchConfigIdSchema = z.tuple([AbsolutePath]);
-/** project:saveActiveLaunchConfigId — absolute path + id (string or null). */
-export const ProjectSaveActiveLaunchConfigIdSchema = z.tuple([
-    AbsolutePath,
-    z.union([z.string(), z.null()]),
-]);
-/** popover:switchLaunchConfig — id (string) or null for normal mode. */
-export const PopoverSwitchLaunchConfigSchema = z.tuple([
-    z.union([z.string(), z.null()]),
-]);
-/** popover:updateLaunchConfigs — full launch config array. */
-export const PopoverUpdateLaunchConfigsSchema = z.tuple([
-    z.array(LaunchConfigShape),
-]);
 //# sourceMappingURL=ipc-schemas.js.map

package/dist/shared/node-bindings.d.ts

@@ -0,0 +1,2 @@
+export * from '@dimina-kit/electron-runtime/shared/node-bindings';
+//# sourceMappingURL=node-bindings.d.ts.map

package/dist/shared/node-bindings.js

@@ -0,0 +1,2 @@
+export * from '@dimina-kit/electron-runtime/shared/node-bindings';
+//# sourceMappingURL=node-bindings.js.map

package/dist/shared/project-window-types.d.ts

@@ -0,0 +1,42 @@
+import type { WorkbenchHostInstance } from './types.js';
+/**
+ * One project window, handed to the host hooks that act on a single project:
+ * `setupProjectWindow` on the way in and `onBeforeClose` on the way out.
+ */
+export interface ProjectWindowRef {
+    /** Absolute path of the project this window was opened for. */
+    path: string;
+    /** Display name the open supplied, when it supplied one. */
+    name?: string;
+    /** The window itself. */
+    window: import('electron').BrowserWindow;
+    /**
+     * This window's own context — the one holding its session and views. Same
+     * type as {@link WorkbenchHostInstance.context}, borrowed from there rather
+     * than named again so this file keeps its single WorkbenchContext reference.
+     */
+    context: WorkbenchHostInstance['context'];
+}
+/**
+ * The project window being closed. Named separately from
+ * {@link ProjectWindowRef} because `onBeforeClose` documents it under this
+ * name; the shape is the same.
+ */
+export type ClosingProjectWindow = ProjectWindowRef;
+/** Overrides for the windows opened projects get, not for the project list. */
+export interface ProjectWindowConfig {
+    /**
+     * Whether the framework shows a project window on its own. Defaults to
+     * `true`: once `setupProjectWindow` has resolved AND the window's own
+     * `ready-to-show` has fired (whichever finishes second), the framework
+     * reveals it. `false` is a permanent opt-out — the framework never shows
+     * that window on its own, no matter what the hook does or how many times
+     * `ready-to-show` fires; the host must call `show()` itself.
+     *
+     * Independent of `window.autoShow`, which governs only the project-list
+     * window: a host that keeps the list hidden behind its own startup flow
+     * still wants the project windows opened afterwards to appear on screen.
+     */
+    autoShow?: boolean;
+}
+//# sourceMappingURL=project-window-types.d.ts.map

package/dist/shared/project-window-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=project-window-types.js.map

package/dist/shared/simulator-route.d.ts

@@ -63,6 +63,14 @@ export declare function parseLocationRoute(search: string): SimulatorRoute | nul
 export declare function parseRoute(url: string): SimulatorRoute | null;
 /** Return the current page path (no query) from a URL, or `''` if unparseable. */
 export declare function getCurrentPagePath(url: string): string;
+/**
+ * Return the current page as a `pagePath?k=v&…` route string (WeChat DevTools
+ * page-path format), with the internal `scene` bookkeeping param stripped so
+ * the displayed route matches what the page actually received in `onLoad`.
+ * Returns `''` if unparseable. Symmetric with `encodePageSpec`/`decodePageSpec`
+ * and with the `SimulatorChannel.CurrentPage` payload.
+ */
+export declare function getCurrentPageRoute(url: string): string;
 /**
  * Rewrite the URL so `entry === current`. Used before a hot-reload so the
  * container boots at just the top page — avoids merged-bundle requests for a

package/dist/shared/simulator-route.js

@@ -133,6 +133,21 @@ export function getCurrentPagePath(url) {
     const route = parseRoute(url);
     return route?.current.pagePath ?? '';
 }
+/**
+ * Return the current page as a `pagePath?k=v&…` route string (WeChat DevTools
+ * page-path format), with the internal `scene` bookkeeping param stripped so
+ * the displayed route matches what the page actually received in `onLoad`.
+ * Returns `''` if unparseable. Symmetric with `encodePageSpec`/`decodePageSpec`
+ * and with the `SimulatorChannel.CurrentPage` payload.
+ */
+export function getCurrentPageRoute(url) {
+    const route = parseRoute(url);
+    if (!route)
+        return '';
+    const query = { ...route.current.query };
+    delete query['scene'];
+    return encodePageSpec({ pagePath: route.current.pagePath, query });
+}
 /**
  * Rewrite the URL so `entry === current`. Used before a hot-reload so the
  * container boots at just the top page — avoids merged-bundle requests for a

package/dist/shared/simulator-ui.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Main-process registration supplied by a downstream host. The script must be
+ * a built renderer bundle that calls {@link registerSimulatorUiExtension}.
+ */
+export interface SimulatorUiExtensionRegistration {
+    /** Stable, context-unique extension identifier. */
+    id: string;
+    /** Absolute path to a trusted renderer JavaScript bundle. */
+    rendererScriptPath: string;
+}
+/**
+ * Handle returned to the host that registered an extension. `invoke` crosses
+ * into the live simulator renderer and calls the extension's renderer-side
+ * method.
+ */
+export interface SimulatorUiExtensionHandle {
+    dispose(): void | Promise<void>;
+    invoke<T = unknown>(method: string, params?: unknown): Promise<T>;
+}
+export interface SimulatorUiMountContext {
+    /** Stable host-owned layer inside the active device frame. */
+    overlayRoot: HTMLElement;
+    /** App currently represented by this DeviceShell. */
+    appId: string;
+    /** Aborted before the mount is disposed or moved to another shell. */
+    signal: AbortSignal;
+}
+export interface SimulatorChromeAction {
+    name: 'capsule.more';
+    appId: string;
+    appName: string;
+    pagePath: string;
+}
+/**
+ * Renderer-side half of a simulator UI extension.
+ *
+ * The extension owns its DOM and business semantics. Dimina owns the device
+ * layer, active-shell selection, reload lifecycle, and chrome-action delivery.
+ */
+export interface SimulatorUiRendererExtension {
+    id: string;
+    mount?(context: SimulatorUiMountContext): void | (() => void);
+    invoke?(method: string, params: unknown): unknown | Promise<unknown>;
+    /**
+     * Return `false` to let another extension handle the action. Any other
+     * resolved value marks it handled.
+     */
+    onChromeAction?(action: SimulatorChromeAction): boolean | void | Promise<boolean | void>;
+}
+export interface SimulatorUiRuntimeBridge {
+    register(extension: SimulatorUiRendererExtension): () => void;
+    unregister(id: string): void;
+    has(id: string): boolean;
+    invoke(id: string, method: string, params: unknown): Promise<unknown>;
+}
+/**
+ * Register the renderer-side implementation from a host bundle loaded through
+ * `instance.registerSimulatorUiExtension`.
+ */
+export declare function registerSimulatorUiExtension(extension: SimulatorUiRendererExtension): () => void;
+//# sourceMappingURL=simulator-ui.d.ts.map

package/dist/shared/simulator-ui.js

@@ -0,0 +1,12 @@
+/**
+ * Register the renderer-side implementation from a host bundle loaded through
+ * `instance.registerSimulatorUiExtension`.
+ */
+export function registerSimulatorUiExtension(extension) {
+    const bridge = globalThis.__diminaSimulatorUi;
+    if (!bridge) {
+        throw new Error('Dimina simulator UI runtime is not available');
+    }
+    return bridge.register(extension);
+}
+//# sourceMappingURL=simulator-ui.js.map

package/dist/shared/types.d.ts

@@ -1,6 +1,15 @@
 import type { OpenProjectOptions } from '@dimina-kit/devkit';
 import type { SimulatorApiHandler } from '../main/services/simulator/custom-apis.js';
 import type { MiniappSessionAppInfo } from '../main/runtime/miniapp-runtime.js';
+import type { ClosingProjectWindow, ProjectWindowConfig, ProjectWindowRef } from './project-window-types.js';
+import type { CompileConfig, CompileMode, CompileModes } from './compile-modes.js';
+export type { ClosingProjectWindow, ProjectWindowConfig, ProjectWindowRef };
+/**
+ * The compile-mode model lives next to its resolver in `compile-modes.ts` —
+ * the types and the rules that read them stay in one file. Re-exported here
+ * so the existing `shared/types.js` import sites keep working.
+ */
+export type { CompileConfig, CompileMode, CompileModes };
 /**
  * The HAND-WRITTEN narrow contract handed to a host `menuBuilder` — the
  * audited menu consumption surface only, same posture as `MiniappRuntime`.
@@ -38,7 +47,7 @@ export interface MenuContext {
             message: string;
             hotReload?: boolean;
         }) => void;
-        /** Ask the main renderer to navigate back to its landing screen (打开项目). */
+        /** Bring the project-list window forward and refresh it (打开项目). */
         windowNavigateBack: () => void;
     };
 }
@@ -54,9 +63,16 @@ export interface ProjectSession {
     close: () => Promise<void>;
     port: number;
     appInfo: AppInfo;
+    /**
+     * Run one real recompile of the session's project. Optional: a host
+     * CompilationAdapter predating this capability may omit it — the rebuild
+     * IPC then degrades to `{ supported: false }` and the renderer falls back
+     * to its reattach-only relaunch.
+     */
+    rebuild?: () => Promise<void>;
 }
 export interface CompilationAdapter {
-    openProject(opts: Omit<OpenProjectOptions, 'containerDir' | 'outputDir'>): Promise<ProjectSession>;
+    openProject(opts: Omit<OpenProjectOptions, 'containerDir' | 'outputDir' | 'outputRoot'>): Promise<ProjectSession>;
 }
 export type BuiltinPanelId = 'wxml' | 'console' | 'appdata' | 'storage';
 export type BuiltinModuleId = 'projects' | 'session' | 'simulator' | 'popover' | 'settings';
@@ -108,24 +124,16 @@ export interface WorkbenchConfig {
      */
     headerHeight?: number;
 }
-export interface CompileConfig {
-    startPage: string;
-    scene: number;
-    queryParams: {
-        key: string;
-        value: string;
-    }[];
-}
 /**
- * Named launch configuration — a saved compile config with an identity.
- * Users create these from the compile-mode popover to persist frequently
- * used start-page / scene / query-param combinations and switch between
- * them without recompilation.
+ * A project's runtime kind, detected from its source layout (see
+ * `detectRuntimeType` in main's `project-repository.ts`). Lives here because
+ * the value crosses the process boundary — main detects it and pushes it to
+ * the renderer over `ViewChannel.HostSidebarCategorySelected`, and the
+ * renderer's `Project.type` carries it back in the project list. Two
+ * structurally identical unions declared on either side would type-check
+ * against each other today and silently diverge the moment one gains a member.
  */
-export interface LaunchConfig extends CompileConfig {
-    id: string;
-    name: string;
-}
+export type ProjectType = 'miniprogram' | 'minigame';
 export interface IpcResult<T = unknown> {
     success: boolean;
     data?: T;
@@ -187,26 +195,22 @@ export interface WorkbenchHostInstance {
      */
     registerTrustedWindow(win: import('electron').BrowserWindow): import('@dimina-kit/electron-deck/main').Disposable;
     /**
-     * Registers a simulator custom API into THIS context's registry, callable
-     * from mini-program code as `wx.<name>(params)`. The registration joins
-     * `context.registry`, so it is released when the context is disposed.
-     * The returned Disposable removes only the registration it created.
+     * Registers a simulator custom API, callable from mini-program code as
+     * `wx.<name>(params)`. The registry is app-level: one registration serves
+     * every project window, including windows opened afterwards, and no window
+     * closing revokes it. It lives until the app is disposed or the returned
+     * Disposable revokes it — which removes only the registration it created.
+     * The handler's optional second argument identifies the calling window's
+     * project; it is supplied by the main process, separately from miniapp params.
      */
     registerSimulatorApi(name: string, handler: SimulatorApiHandler): import('@dimina-kit/electron-deck/main').Disposable;
     /**
-     * Read all saved launch configs for the active project.
-     * Returns an empty array when no project is open or no configs exist.
+     * Installs a trusted downstream renderer bundle into this context's
+     * simulator UI runtime. Dimina owns the active DeviceShell mount point and
+     * reload/dispose lifecycle; the host owns the rendered DOM and business
+     * semantics.
      */
-    getLaunchConfigs(): Promise<LaunchConfig[]>;
-    /**
-     * Persist the full list of launch configs for the active project.
-     */
-    setLaunchConfigs(configs: LaunchConfig[]): Promise<void>;
-    /**
-     * Activate a named launch config (by id) or revert to normal mode (null).
-     * Persists the selection and notifies the renderer to relaunch.
-     */
-    setActiveLaunchConfig(id: string | null): Promise<void>;
+    registerSimulatorUiExtension(registration: import('./simulator-ui.js').SimulatorUiExtensionRegistration): import('./simulator-ui.js').SimulatorUiExtensionHandle;
 }
 /**
  * Pluggable backend for the project-list panel. Hosts may supply this to
@@ -222,13 +226,12 @@ export interface ProjectsProvider {
     validateProjectDir?(dirPath: string): string | null;
     addProject(dirPath: string): unknown;
     removeProject(dirPath: string): void | Promise<void>;
+    updateProject?(dirPath: string, patch: unknown): unknown;
     updateLastOpened?(dirPath: string): void | Promise<void>;
     getCompileConfig?(dirPath: string): unknown;
     saveCompileConfig?(dirPath: string, cfg: unknown): void | Promise<void>;
-    getLaunchConfigs?(dirPath: string): unknown[] | Promise<unknown[]>;
-    saveLaunchConfigs?(dirPath: string, configs: unknown[]): void | Promise<void>;
-    getActiveLaunchConfigId?(dirPath: string): string | null | Promise<string | null>;
-    saveActiveLaunchConfigId?(dirPath: string, id: string | null): void | Promise<void>;
+    getCompileModes?(dirPath: string): CompileModes | Promise<CompileModes>;
+    saveCompileModes?(dirPath: string, modes: CompileModes): void | Promise<void>;
 }
 /**
  * A template the user can pick from in the "新建项目" dialog. Exactly one of
@@ -288,16 +291,38 @@ export interface WorkbenchAppConfig extends WorkbenchConfig {
     rendererDir?: string;
     /** Enable or disable built-in IPC module groups. Defaults to all enabled. */
     modules?: Partial<Record<BuiltinModuleId, boolean>>;
-    /** Window sizing overrides for the main devtools window. */
+    /** Window sizing overrides for the project-list window. */
     window?: WorkbenchWindowConfig;
+    /** Overrides for the windows opened projects get. */
+    projectWindow?: ProjectWindowConfig;
     /** Absolute path to a window/taskbar icon (png or ico). macOS uses the app bundle icon. */
     icon?: string;
     /** Custom menu builder. Should call Menu.setApplicationMenu(). If omitted, the default dimina-devtools menu is installed. */
     menuBuilder?: (mainWindow: import('electron').BrowserWindow, menuContext: MenuContext) => void;
     /** Called after window and context are created but before start() resolves. Use to register custom IPC handlers. */
     onSetup?: (instance: WorkbenchHostInstance) => void | Promise<void>;
-    /** Called before window close when a session is active. Session disposal happens automatically after this hook. */
-    onBeforeClose?: (instance: WorkbenchHostInstance) => void | Promise<void>;
+    /**
+     * Called once per project window, after the framework has wired that window
+     * up and before the open resolves. `opened.context` is THAT window's own
+     * context, which is why per-project registration belongs here: `onSetup`
+     * only ever sees `instance.context`, the project list's, so a registration
+     * made there reaches no project window.
+     *
+     * Awaited, and unlike `onBeforeClose` it can fail the open: a rejection
+     * tears the half-built window down and reaches whoever asked for it.
+     */
+    setupProjectWindow?: (instance: WorkbenchHostInstance, opened: ProjectWindowRef) => void | Promise<void>;
+    /**
+     * Called when a project window is closing, before the framework disposes it.
+     * `closing` says WHICH project is going away and carries that window's own
+     * context — `instance.context` is always the project list's, which owns no
+     * session, so with several windows open it cannot tell them apart. A hook
+     * that only declares `instance` still type-checks.
+     *
+     * Awaited, but not a veto: a rejection is logged and the window is disposed
+     * regardless.
+     */
+    onBeforeClose?: (instance: WorkbenchHostInstance, closing: ClosingProjectWindow) => void | Promise<void>;
     /**
      * Called before a project is opened, BEFORE any side effect (session
      * teardown, compile, dev-server). Use to gate the open on login/permission
@@ -359,6 +384,32 @@ export interface WorkbenchAppConfig extends WorkbenchConfig {
         parentWindow: import('electron').BrowserWindow;
         templates: ProjectTemplate[];
     }) => Promise<CustomCreateProjectDialogResult>;
+    /**
+     * Host-supplied "编辑项目" dialog. When provided, the renderer routes the
+     * project card's edit action through IPC into this main-process hook
+     * instead of showing the built-in dialog. `project` is read from the
+     * current project-list record (not whatever the renderer happened to have
+     * in state), so the host always sees devtools' own authoritative record.
+     *
+     * Return either:
+     *  - `null` — user cancelled; devtools does nothing.
+     *  - `{ name?, iconUrl? }` — the host collected an edit; devtools applies
+     *    it via `workspace.updateProject`, the same path the built-in dialog's
+     *    submit uses.
+     *  - `{ updated: EditableProject }` — the host has ALREADY persisted the
+     *    change itself; devtools just refreshes the list.
+     *
+     * Unlike `customCreateProjectDialog`, "no hook configured" and "user
+     * cancelled" are NOT both collapsed to `null` on the wire: the create flow
+     * does that and it means a cancelled host dialog falls through into the
+     * built-in one right after. The `projects:openEditDialog` IPC instead
+     * returns `null` only when no hook is configured, and wraps the hook's
+     * result as `{ result }` otherwise — see `OpenEditProjectDialogReply`.
+     */
+    customEditProjectDialog?: (ctx: {
+        parentWindow: import('electron').BrowserWindow;
+        project: EditableProject;
+    }) => Promise<CustomEditProjectDialogResult>;
 }
 /**
  * Discriminated return of `customCreateProjectDialog`. `null` = cancelled.
@@ -376,4 +427,38 @@ export type CustomCreateProjectDialogResult = null | {
         lastOpened?: string | null;
     };
 } | CreateProjectInput;
+/**
+ * Structural minimum devtools needs to render a project-list card, passed to
+ * `customEditProjectDialog` and returned as its `updated` variant. Mirrors
+ * `Project` in `./projects-provider`.
+ */
+export interface EditableProject {
+    name: string;
+    path: string;
+    iconUrl?: string;
+    lastOpened?: string | null;
+}
+/**
+ * Discriminated return of `customEditProjectDialog`. `null` = cancelled.
+ * `{ updated }` = the host already persisted the edit; devtools just
+ * refreshes. Otherwise a `{ name?, iconUrl? }` patch devtools applies via
+ * `workspace.updateProject`.
+ */
+export type CustomEditProjectDialogResult = null | {
+    updated: EditableProject;
+} | {
+    name?: string;
+    iconUrl?: string;
+};
+/**
+ * Wire reply for `projects:openEditDialog`. `null` means the host configured
+ * no `customEditProjectDialog` hook at all — the renderer should show the
+ * built-in dialog. When a hook IS configured, the IPC always resolves
+ * `{ result }` even if `result` is `null` (user cancelled the host dialog),
+ * so the renderer can tell "no hook" apart from "hook ran, user cancelled"
+ * and skip the built-in fallback in the latter case.
+ */
+export type OpenEditProjectDialogReply = null | {
+    result: CustomEditProjectDialogResult;
+};
 //# sourceMappingURL=types.d.ts.map