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

package/dist/main/app/bootstrap.d.ts

@@ -1,10 +1,13 @@
 /**
- * Register `difile://` as a privileged scheme so `simSession.protocol.handle`
- * can serve `difile://devtools/{uuid}` URLs from the simulator webview without
- * tripping CSP / fetch-API restrictions. Must be called before `app.whenReady`.
+ * Register privileged custom schemes before `app.whenReady`.
  *
- * Idempotent — subsequent calls are no-ops because Electron throws if the same
- * scheme is registered twice.
+ * Electron allows only one process-global `registerSchemesAsPrivileged` call, so
+ * this merges the runtime's `difile` + `dmb-resource` descriptors (required for
+ * render-host documents / ES module fetches on `dmb-resource://`) and keeps
+ * `bypassCSP` on `difile` for the simulator temp-file path.
+ *
+ * Idempotent — subsequent calls are no-ops because Electron throws if schemes
+ * are registered twice.
  */
 export declare function registerDifileScheme(): void;
 /**

package/dist/main/app/bootstrap.js

@@ -1,32 +1,32 @@
 import { app, protocol } from 'electron';
+import { ELECTRON_RUNTIME_SCHEMES } from '@dimina-kit/electron-runtime';
 import { DEFAULT_CDP_PORT } from '../../shared/constants.js';
 import { loadWorkbenchSettings } from '../services/settings/index.js';
 let difileSchemeRegistered = false;
 /**
- * Register `difile://` as a privileged scheme so `simSession.protocol.handle`
- * can serve `difile://devtools/{uuid}` URLs from the simulator webview without
- * tripping CSP / fetch-API restrictions. Must be called before `app.whenReady`.
+ * Register privileged custom schemes before `app.whenReady`.
  *
- * Idempotent — subsequent calls are no-ops because Electron throws if the same
- * scheme is registered twice.
+ * Electron allows only one process-global `registerSchemesAsPrivileged` call, so
+ * this merges the runtime's `difile` + `dmb-resource` descriptors (required for
+ * render-host documents / ES module fetches on `dmb-resource://`) and keeps
+ * `bypassCSP` on `difile` for the simulator temp-file path.
+ *
+ * Idempotent — subsequent calls are no-ops because Electron throws if schemes
+ * are registered twice.
  */
 export function registerDifileScheme() {
     if (difileSchemeRegistered)
         return;
     difileSchemeRegistered = true;
-    protocol.registerSchemesAsPrivileged([
-        {
-            scheme: 'difile',
+    protocol.registerSchemesAsPrivileged(ELECTRON_RUNTIME_SCHEMES.map((entry) => (entry.scheme === 'difile'
+        ? {
+            scheme: entry.scheme,
             privileges: {
-                standard: true,
-                secure: true,
-                supportFetchAPI: true,
-                stream: true,
+                ...entry.privileges,
                 bypassCSP: true,
-                corsEnabled: true,
             },
-        },
-    ]);
+        }
+        : { scheme: entry.scheme, privileges: { ...entry.privileges } })));
 }
 /**
  * Suppress EPIPE errors on stdout/stderr.

package/dist/main/app/editor-view.d.ts

@@ -0,0 +1,21 @@
+import type { CustomFileTypes, WorkbenchAppConfig } from '../../shared/types.js';
+import type { ViewManager } from '../services/views/view-manager.js';
+import type { WorkspaceService } from '../services/workspace/workspace-service.js';
+import type { DisposableRegistry } from '@dimina-kit/electron-deck/main';
+/** Narrow view of the context fields the embedded editor depends on. */
+export interface EditorViewContext {
+    workspace: WorkspaceService;
+    fileTypes: CustomFileTypes;
+    views: ViewManager;
+    registry: DisposableRegistry;
+}
+/**
+ * Embedded workbench editor — the sole devtools editor. Stands up the COI http
+ * server that serves the workbench bundle with the SharedArrayBuffer isolation
+ * headers and bridges `/__fs/*` onto the active project, then hands its base URL
+ * to the view manager so the 'editor' dock slot mounts the workbench
+ * WebContentsView. Both the server and the WCV tear down with the context
+ * registry.
+ */
+export declare function setupEditorView(config: WorkbenchAppConfig, context: EditorViewContext, getActiveAppId: () => string | null): Promise<void>;
+//# sourceMappingURL=editor-view.d.ts.map

package/dist/main/app/editor-view.js

@@ -0,0 +1,71 @@
+import fs from 'fs';
+import path from 'path';
+import { devtoolsPackageRoot } from '../utils/paths.js';
+import { startWorkbenchCoiServer } from '../services/workbench-coi-server.js';
+/**
+ * Embedded workbench editor — the sole devtools editor. Stands up the COI http
+ * server that serves the workbench bundle with the SharedArrayBuffer isolation
+ * headers and bridges `/__fs/*` onto the active project, then hands its base URL
+ * to the view manager so the 'editor' dock slot mounts the workbench
+ * WebContentsView. Both the server and the WCV tear down with the context
+ * registry.
+ */
+export async function setupEditorView(config, context, getActiveAppId) {
+    // Default the bundle dir to the devtools package's OWN `dist/vscode-workbench`
+    // (resolved from the package root), NOT relative to the caller's rendererDir:
+    // a host that overrides `rendererDir` but omits `editorViewConfig.bundleDir`
+    // would otherwise compute a path next to ITS renderer, where no workbench
+    // bundle exists → 404 / blank editor.
+    const bundleDir = config.editorViewConfig?.bundleDir ?? path.join(devtoolsPackageRoot, 'dist/vscode-workbench');
+    // Skip the entire editor assembly when the bundle is missing. Starting the COI
+    // server and attaching the WCV against a non-existent bundle yields a silent
+    // blank editor (the WCV loads index.html → 404); a launchable app with no
+    // editor is strictly better. The view manager never gets a source, so the
+    // 'editor' slot's lazy attach is a no-op.
+    if (!fs.existsSync(path.join(bundleDir, 'index.html'))) {
+        console.warn(`[workbench] editor bundle not found at ${bundleDir} — skipping embedded editor assembly`);
+        return;
+    }
+    const coiServer = await startWorkbenchCoiServer({
+        rootDir: bundleDir,
+        getProjectRoot: () => context.workspace.getProjectPath(),
+        extensionsDir: config.editorViewConfig?.extensionsDir,
+        getFileTypes: () => context.fileTypes,
+        // Names the editor's VS Code workspace after the active miniapp, so each
+        // project gets its own open-editors/view-state bucket instead of all of
+        // them sharing the one derived from the constant mirror root.
+        getProjectIdentity: () => ({
+            appId: getActiveAppId(),
+            projectPath: context.workspace.getProjectPath(),
+        }),
+    });
+    try {
+        // Return the close promise so the registry awaits server shutdown on dispose
+        // instead of fire-and-forgetting it (a dangling http server would keep the
+        // port + event loop alive past teardown).
+        context.registry.add(() => coiServer.close());
+        // The registry disposes LIFO, so this runs BEFORE the context-level
+        // disposeAll: void any in-flight open's attach hold here too, or a stale
+        // release / cap firing could rebuild the workbench during the awaited
+        // coiServer.close() above, before disposeAll's own cancel runs.
+        context.registry.add(() => {
+            context.views.cancelWorkbenchAttachHold();
+            context.views.detachWorkbench();
+        });
+    }
+    catch (err) {
+        // The window was torn down while the bridge was still binding, so the
+        // registry that would have closed it is already disposed and refuses new
+        // entries. Close it here instead: an orphaned route keeps the shared COI
+        // listener (and its port) alive for the rest of the process.
+        await coiServer.close().catch(() => { });
+        throw err;
+    }
+    // Only HAND the view manager the COI URL — do NOT load yet. The heavy
+    // WebContentsView load (10MB bundle + ext-host) is deferred to the first time
+    // the 'editor' dock slot becomes visible (first non-zero bounds), so it never
+    // sits on the app boot critical path. Loading it eagerly here delayed
+    // preload/window-ready enough to trip the e2e launch health check.
+    context.views.setWorkbenchSource(coiServer.baseUrl);
+}
+//# sourceMappingURL=editor-view.js.map

package/dist/main/app/global-mirrors.d.ts

@@ -0,0 +1,23 @@
+import type { BrowserWindow } from 'electron';
+import type { ConsoleForwarder } from '../services/console-forward/index.js';
+import type { DiagnosticsBus } from '../services/diagnostics/index.js';
+import type { CdpSessionBroker } from '../services/cdp-session/index.js';
+import type { InternalDevtoolsWindow } from '../windows/internal-devtools-window/index.js';
+import { type DisposableRegistry } from '@dimina-kit/electron-deck/main';
+/** Narrow view of the context fields the two global mirrors depend on. */
+export interface GlobalMirrorContext {
+    consoleForwarder?: ConsoleForwarder;
+    diagnostics?: DiagnosticsBus;
+    internalDevtoolsWindow?: InternalDevtoolsWindow;
+    cdpSessionBroker: CdpSessionBroker;
+    registry: DisposableRegistry;
+}
+/**
+ * Console + diagnostics mirrors into the standalone internal DevTools window.
+ *
+ * Both mirrors target the INSPECTED side — `mainWindow.webContents`, per
+ * internal-devtools-window.ts's setDevToolsWebContents relationship — and NOT
+ * the front-end host page the `onHostChanged` callback hands them.
+ */
+export declare function installGlobalMirrors(context: GlobalMirrorContext, mainWindow: BrowserWindow): void;
+//# sourceMappingURL=global-mirrors.d.ts.map

package/dist/main/app/global-mirrors.js

@@ -0,0 +1,37 @@
+import { createGlobalConsoleMirror } from '../services/console-forward/global-console-mirror.js';
+import { createGlobalDiagnosticsMirror } from '../services/console-forward/global-diagnostics-mirror.js';
+import { toDisposable } from '@dimina-kit/electron-deck/main';
+/**
+ * Console + diagnostics mirrors into the standalone internal DevTools window.
+ *
+ * Both mirrors target the INSPECTED side — `mainWindow.webContents`, per
+ * internal-devtools-window.ts's setDevToolsWebContents relationship — and NOT
+ * the front-end host page the `onHostChanged` callback hands them.
+ */
+export function installGlobalMirrors(context, mainWindow) {
+    // While the standalone internal DevTools window is open, mirror every guest
+    // console entry (service + render, UNFILTERED — see global-console-mirror.ts)
+    // into it — each open replays the forwarder's current history buffer first
+    // (see that module's doc comment for why the subscribe lifecycle is gated on
+    // onHostChanged rather than subscribed once at construction time).
+    // `context.consoleForwarder` is assembled by the simulator module's
+    // installBridgeRouter; absent only when that builtin module was disabled via
+    // config.
+    if (context.consoleForwarder && context.internalDevtoolsWindow) {
+        const consoleMirror = createGlobalConsoleMirror(context.consoleForwarder, mainWindow.webContents, context.internalDevtoolsWindow.onHostChanged, 
+        // CDP transport (never executeJavaScript) — see the mirror's inject()
+        // doc for the setDevToolsWebContents + external-CDP double-attach hang.
+        { broker: context.cdpSessionBroker });
+        context.registry.add(toDisposable(() => consoleMirror.dispose()));
+    }
+    // Same wiring for diagnostics: every diagnostic — including
+    // `audience:'internal'` ones console-forward's own service-host injection
+    // now skips (see compile-standby.ts / index.ts's handleDiagnostic gate) —
+    // surfaces here instead of vanishing. `context.diagnostics` is assembled
+    // alongside `context.consoleForwarder` by the same installBridgeRouter call.
+    if (context.diagnostics && context.internalDevtoolsWindow) {
+        const diagnosticsMirror = createGlobalDiagnosticsMirror(context.diagnostics, mainWindow.webContents, context.internalDevtoolsWindow.onHostChanged, { broker: context.cdpSessionBroker });
+        context.registry.add(toDisposable(() => diagnosticsMirror.dispose()));
+    }
+}
+//# sourceMappingURL=global-mirrors.js.map

package/dist/main/app/host-sidebar-default.d.ts

@@ -0,0 +1,19 @@
+import type { ViewManager } from '../services/views/view-manager.js';
+import type { RendererNotifier } from '../services/notifications/renderer-notifier.js';
+import type { DisposableRegistry } from '@dimina-kit/electron-deck/main';
+/** Narrow view of the context fields the default sidebar content depends on. */
+export interface HostSidebarContext {
+    views: ViewManager;
+    notify: RendererNotifier;
+    registry: DisposableRegistry;
+}
+/**
+ * devtools' own default content for the host-sidebar slot: a narrow icon rail
+ * (logo + 小程序/小游戏 toggle) filtering the project-list grid by
+ * `Project.type`. Loaded BEFORE `config.onSetup` runs, so any downstream
+ * `loadURL`/`loadFile` call inside onSetup necessarily happens later and
+ * naturally supersedes this default via plain chronological ordering — no
+ * override flag needed.
+ */
+export declare function installHostSidebarDefault(context: HostSidebarContext, rendererDir: string): void;
+//# sourceMappingURL=host-sidebar-default.d.ts.map

package/dist/main/app/host-sidebar-default.js

@@ -0,0 +1,44 @@
+import path from 'path';
+import { HOST_SIDEBAR_DEFAULT_WIDTH } from '../../shared/constants.js';
+/**
+ * devtools' own default content for the host-sidebar slot: a narrow icon rail
+ * (logo + 小程序/小游戏 toggle) filtering the project-list grid by
+ * `Project.type`. Loaded BEFORE `config.onSetup` runs, so any downstream
+ * `loadURL`/`loadFile` call inside onSetup necessarily happens later and
+ * naturally supersedes this default via plain chronological ordering — no
+ * override flag needed.
+ */
+export function installHostSidebarDefault(context, rendererDir) {
+    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(path.join(rendererDir, 'entries/host-sidebar-default/index.html'))
+        .catch((err) => {
+        console.warn('[workbench] failed to load host-sidebar default content:', err);
+    });
+    // Seed the notified width with the rail's own known intrinsic width
+    // (`HOST_SIDEBAR_DEFAULT_WIDTH`) instead of leaving it at 0 until the
+    // rail's in-page advertiser reports back. That report can never arrive on
+    // its own: the placeholder above only becomes "desired visible" once a
+    // nonzero width is known (project-list-screen.tsx), attach only happens
+    // for a "desired visible" view (placement-reconciler.ts), and the rail's
+    // advertiser (view-anchor's measure-loop.ts) only ever fires via
+    // `requestAnimationFrame`, which Chromium never schedules for a
+    // WebContentsView that was never attached — a structural deadlock, not a
+    // slow-to-resolve race. `setWidthMode({fixed})` pushes the seed
+    // synchronously (no attach/rAF dependency) and, critically, retains it in
+    // `getHostSidebarWidth()` too, so a renderer that mounts and pulls before
+    // any push replays the real seed instead of a stale 0. Flipping back to
+    // 'auto' immediately after, before anything has attached or advertised, is
+    // a same-tick no-op past the seed (`setExtentMode`'s reapply branch only
+    // fires once something has actually been advertised) — it leaves the slot
+    // in 'auto' for whichever content ends up loaded (this rail's own later
+    // report, or a downstream replacement's), not pinned.
+    context.views.hostSidebar.setWidthMode({ fixed: HOST_SIDEBAR_DEFAULT_WIDTH });
+    context.views.hostSidebar.setWidthMode('auto');
+}
+//# sourceMappingURL=host-sidebar-default.js.map

package/dist/main/app/lifecycle.d.ts

@@ -1,3 +1,14 @@
 export declare function isAppQuitting(): boolean;
-export declare function registerAppLifecycle(): void;
+/**
+ * `onBeforeQuit`: invoked synchronously, once per `before-quit`, while
+ * Electron's main loop is still fully healthy — i.e. BEFORE `will-quit` and
+ * any window/WebContentsView destruction. Callers use this to tear down
+ * resources (child WebContentsViews, MessagePorts) that are unsafe to let
+ * survive into Chromium's native shutdown sequence, where a JS `'destroyed'`
+ * handler closing them can hit an already-torn-down native object. Isolated
+ * like `host-toolbar-port-channel.ts`'s `invokeReadyHandler`: a throwing
+ * callback must not stop `appIsQuitting` from flipping or escape as an
+ * uncaught exception out of Electron's event dispatch.
+ */
+export declare function registerAppLifecycle(onBeforeQuit?: () => void): void;
 //# sourceMappingURL=lifecycle.d.ts.map

package/dist/main/app/lifecycle.js

@@ -4,11 +4,31 @@ import { app, globalShortcut } from 'electron';
 // BEFORE each window's `close` event, so the main-window onClose handler can
 // read this to tell "the whole app is exiting" apart from "the user closed a
 // single project window" and avoid swallowing the quit.
+//
+// Deliberately a ONE-WAY latch: Electron emits no "quit was canceled" signal
+// to reset on, and any heuristic reset (timers, window-created probes) risks
+// flipping back to false DURING a real quit — which would re-arm the very
+// close-interception this flag exists to disable and abort the quit. The
+// cost of staying latched after a hypothetically-canceled quit (no in-repo
+// cancel path exists; a renderer `beforeunload` could in principle create
+// one) is a degraded-but-functional state, strictly cheaper than a broken
+// quit.
 let appIsQuitting = false;
 export function isAppQuitting() {
     return appIsQuitting;
 }
-export function registerAppLifecycle() {
+/**
+ * `onBeforeQuit`: invoked synchronously, once per `before-quit`, while
+ * Electron's main loop is still fully healthy — i.e. BEFORE `will-quit` and
+ * any window/WebContentsView destruction. Callers use this to tear down
+ * resources (child WebContentsViews, MessagePorts) that are unsafe to let
+ * survive into Chromium's native shutdown sequence, where a JS `'destroyed'`
+ * handler closing them can hit an already-torn-down native object. Isolated
+ * like `host-toolbar-port-channel.ts`'s `invokeReadyHandler`: a throwing
+ * callback must not stop `appIsQuitting` from flipping or escape as an
+ * uncaught exception out of Electron's event dispatch.
+ */
+export function registerAppLifecycle(onBeforeQuit) {
     app.on('window-all-closed', () => {
         globalShortcut.unregisterAll();
         app.quit();
@@ -16,6 +36,12 @@ export function registerAppLifecycle() {
     app.on('before-quit', () => {
         appIsQuitting = true;
         globalShortcut.unregisterAll();
+        try {
+            onBeforeQuit?.();
+        }
+        catch (err) {
+            console.error('[lifecycle] onBeforeQuit handler threw:', err);
+        }
     });
 }
 //# sourceMappingURL=lifecycle.js.map

package/dist/main/app/menu-setup.d.ts

@@ -0,0 +1,13 @@
+import type { BrowserWindow } from 'electron';
+import type { WorkbenchAppConfig } from '../../shared/types.js';
+import type { WorkspaceService } from '../services/workspace/workspace-service.js';
+import type { RendererNotifier } from '../services/notifications/renderer-notifier.js';
+/** Narrow view of the context fields the menu surface closes over. */
+export interface MenuHostContext {
+    appName: string;
+    workspace: WorkspaceService;
+    openSettings: () => Promise<void>;
+    notify: RendererNotifier;
+}
+export declare function installMenu(config: WorkbenchAppConfig, mainWindow: BrowserWindow, activeContext: () => MenuHostContext, revealProjectList: () => void): void;
+//# sourceMappingURL=menu-setup.d.ts.map

package/dist/main/app/menu-setup.js

@@ -0,0 +1,49 @@
+import { installAppMenu } from '../menu/index.js';
+/**
+ * Build the hand-written narrow `MenuContext` a host menu builder receives —
+ * explicit construction (not clone+delete), so the runtime object carries
+ * EXACTLY the contract members and nothing else. Every member is a lazy
+ * closure over the live context: a host monkey-patch of
+ * `context.workspace.openProject` (the documented permission-gate pattern)
+ * still intercepts calls made through this menu surface.
+ *
+ * The context is resolved per call, never captured: the menu is installed once
+ * before any project exists, and a project lives in its own window, so a menu
+ * item run later must reach the window the user is actually in.
+ */
+function toMenuContext(activeContext, revealProjectList) {
+    return {
+        get appName() { return activeContext().appName; },
+        workspace: {
+            hasActiveSession: () => activeContext().workspace.hasActiveSession(),
+            getProjectPath: () => activeContext().workspace.getProjectPath(),
+            openProject: (projectPath) => activeContext().workspace.openProject(projectPath),
+            closeProject: () => activeContext().workspace.closeProject(),
+            getSession: () => activeContext().workspace.getSession(),
+        },
+        openSettings: () => activeContext().openSettings(),
+        notify: {
+            projectStatus: (payload) => activeContext().notify.projectStatus(payload),
+            // A project opens in its own window, so "back to the project list" is
+            // no longer a screen change inside one window — it brings the list
+            // window forward. That window owns its own context, which may not be
+            // `activeContext()` (a project window can be the active one), so this
+            // routes through the injected surface instead of notifying whatever is
+            // currently active.
+            windowNavigateBack: () => revealProjectList(),
+        },
+    };
+}
+export function installMenu(config, mainWindow, activeContext, revealProjectList) {
+    // Menu: use host-provided builder or fall back to default. Both consume the
+    // same narrow MenuContext, so the built-in menu proves the hand-written
+    // contract covers the real internal consumption.
+    const menuContext = toMenuContext(activeContext, revealProjectList);
+    if (config.menuBuilder) {
+        config.menuBuilder(mainWindow, menuContext);
+    }
+    else {
+        installAppMenu(menuContext);
+    }
+}
+//# sourceMappingURL=menu-setup.js.map

package/dist/main/app/native-overview.d.ts

@@ -3,7 +3,7 @@ import type { StorageApi } from '../services/simulator-storage/index.js';
 /**
  * Narrow view of the fields the native overview provider reads. Depending on
  * this instead of the full `WorkbenchContext` grab-bag keeps this module out
- * of the workbench-context import ratchet.
+ * of the workbench-context import gate.
  */
 export interface NativeOverviewContext {
     storageApi?: StorageApi;

package/dist/main/app/open-project-ipc.d.ts

@@ -0,0 +1,13 @@
+import type { IpcContextSource } from '../utils/ipc-context-source.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
+import type { ProjectRef } from './project-window.js';
+/**
+ * Opening a project from the list — and from MCP's project_open, which the
+ * list renderer forwards here — always means "give it its own window", so the
+ * channel does nothing but hand the request to the workbench window manager.
+ *
+ * Generic over the context type: the handler never touches the context, and
+ * naming it would drag `WorkbenchContext` into this module.
+ */
+export declare function registerOpenProjectWindowIpc<TCtx>(router: IpcContextSource<TCtx>, open: (project: ProjectRef) => Promise<unknown>): IpcRegistry<TCtx>;
+//# sourceMappingURL=open-project-ipc.d.ts.map

package/dist/main/app/open-project-ipc.js

@@ -0,0 +1,21 @@
+import { WindowChannel } from '../../shared/ipc-channels.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
+/**
+ * Opening a project from the list — and from MCP's project_open, which the
+ * list renderer forwards here — always means "give it its own window", so the
+ * channel does nothing but hand the request to the workbench window manager.
+ *
+ * Generic over the context type: the handler never touches the context, and
+ * naming it would drag `WorkbenchContext` into this module.
+ */
+export function registerOpenProjectWindowIpc(router, open) {
+    const windowIpc = new IpcRegistry(router);
+    windowIpc.handleRouted(WindowChannel.OpenProjectWindow, async (_ctx, _event, ...args) => {
+        const project = args[0];
+        if (!project?.path)
+            throw new Error('openProjectWindow requires a project path');
+        await open({ path: project.path, name: project.name });
+    });
+    return windowIpc;
+}
+//# sourceMappingURL=open-project-ipc.js.map

package/dist/main/app/project-list-surface.d.ts

@@ -0,0 +1,31 @@
+import type { BrowserWindow } from 'electron';
+import type { UpdateInfo } from '../../shared/types.js';
+/**
+ * Narrow view of the context fields the project-list surface closes over —
+ * structural, not `WorkbenchContext` (see eslint-workbench-context-gate) —
+ * so the surface carries no dependency on the whole workbench.
+ */
+export interface ProjectListSurfaceContext {
+    notify: {
+        windowNavigateBack: () => void;
+    };
+    views: {
+        showUpdateDialog: (info: UpdateInfo) => void;
+    };
+}
+export interface ProjectListSurfaceDeps {
+    window: BrowserWindow;
+    context: ProjectListSurfaceContext;
+}
+export interface ProjectListSurface {
+    revealProjectList: () => void;
+    showUpdate: (info: UpdateInfo) => void;
+}
+/**
+ * "回到项目列表" 和更新弹窗都属于列表窗口本身，而不是当时 activeContext() 恰好
+ * 解析到的窗口——那个窗口可能是某个项目工作台。这里是两条路径共同的入口：
+ * revealProjectList 把列表窗口带到前台并通知它自己的 context 刷新；showUpdate
+ * 先做同一件事，再弹更新对话框，避免窗口还处于 hide() 状态时用户看不到弹窗。
+ */
+export declare function createProjectListSurface(deps: ProjectListSurfaceDeps): ProjectListSurface;
+//# sourceMappingURL=project-list-surface.d.ts.map

package/dist/main/app/project-list-surface.js

@@ -0,0 +1,20 @@
+import { revealWindow } from './window-events.js';
+/**
+ * "回到项目列表" 和更新弹窗都属于列表窗口本身，而不是当时 activeContext() 恰好
+ * 解析到的窗口——那个窗口可能是某个项目工作台。这里是两条路径共同的入口：
+ * revealProjectList 把列表窗口带到前台并通知它自己的 context 刷新；showUpdate
+ * 先做同一件事，再弹更新对话框，避免窗口还处于 hide() 状态时用户看不到弹窗。
+ */
+export function createProjectListSurface(deps) {
+    const { window, context } = deps;
+    const revealProjectList = () => {
+        revealWindow(window);
+        context.notify.windowNavigateBack();
+    };
+    const showUpdate = (info) => {
+        revealProjectList();
+        context.views.showUpdateDialog(info);
+    };
+    return { revealProjectList, showUpdate };
+}
+//# sourceMappingURL=project-list-surface.js.map

package/dist/main/app/project-window.d.ts

@@ -0,0 +1,36 @@
+import { BrowserWindow } from 'electron';
+import type { WorkbenchAppConfig } from '../../shared/types.js';
+import { type WorkbenchContext } from '../services/workbench-context.js';
+import type { AppServices } from '../services/app-services.js';
+import type { WindowContextRouter } from '../services/window-contexts/context-router.js';
+/** The project a workbench window is opened for. */
+export interface ProjectRef {
+    path: string;
+    name?: string;
+}
+/** A window and the context that answers IPC coming from it. */
+export interface ProjectWindow {
+    window: BrowserWindow;
+    context: WorkbenchContext;
+    dispose: () => Promise<void>;
+}
+export interface CreateProjectWindowOptions {
+    config: WorkbenchAppConfig;
+    rendererDir: string;
+    appServices: AppServices;
+    router: WindowContextRouter<WorkbenchContext>;
+}
+export declare function disposeContext(ctx: WorkbenchContext): Promise<void>;
+/**
+ * The project-list window. It is the application's root window: the app-level
+ * IPC surface is registered while it exists, and it stays open for the whole
+ * session so workbench windows can come and go around it.
+ */
+export declare function createLauncherWindow(opts: CreateProjectWindowOptions): ProjectWindow;
+/**
+ * A workbench window: one open mini-program project, with its own simulator,
+ * panels and editor. The project identity travels in the URL query so the
+ * renderer entry can mount straight into the project without asking main.
+ */
+export declare function createWorkbenchWindow(opts: CreateProjectWindowOptions, project: ProjectRef): ProjectWindow;
+//# sourceMappingURL=project-window.d.ts.map