@dimina-kit/devtools 0.4.0-dev.20260831134112 → 0.4.0-dev.20260907055341

package/dist/main/app/ui-extension-targets.js

@@ -0,0 +1,101 @@
+/**
+ * The ledger of host-registered simulator UI extensions.
+ *
+ * A registration is app-level — the host makes it once — but an extension can
+ * only exist inside a PROJECT window: it mounts into that window's device
+ * frame and talks to its simulator renderer. So one registration becomes one
+ * live extension per project window, and the ledger is what keeps those copies
+ * in step with the windows: every project window that opens gets its own copy,
+ * and a copy exists exactly as long as the window that owns it.
+ *
+ * The project list is deliberately not a target. It runs no bridge router and
+ * no simulator, so an extension registered into it could never mount, and
+ * `invoke` — which follows the window the user works in — would be answered by
+ * that dead copy every time the list window has focus.
+ */
+import { toDisposable } from '@dimina-kit/electron-deck/main';
+import { assertSimulatorUiExtensionShape } from '../services/simulator/ui-extensions.js';
+export function createUiExtensionTargets(deps) {
+    /** Per registration, one target per project window that currently holds it. */
+    const ledger = new Map();
+    /** Ids currently spoken for app-wide, so a clash is caught where it happens. */
+    const ids = new Set();
+    function attach(window, targets, registration) {
+        const extension = window.simulatorUiExtensions.register(registration);
+        // Owned by the window: its registry drives this on close, which both tears
+        // the extension down and drops the record. A record left behind would keep
+        // a disposed extension reachable as an `invoke` target and would make the
+        // ledger grow with every window ever opened.
+        const owned = window.registry.add(toDisposable(async () => {
+            const index = targets.findIndex((t) => t.extension === extension);
+            if (index >= 0)
+                targets.splice(index, 1);
+            await extension.dispose();
+        }));
+        targets.push({ window, extension, owned });
+    }
+    /**
+     * A window refusing an extension is a fact about that window: the project
+     * still opens, the other windows keep their copies, and windows opened later
+     * still get theirs. Letting it escape would turn one bad extension into "no
+     * project can be opened any more".
+     */
+    function tryAttach(window, targets, registration) {
+        try {
+            attach(window, targets, registration);
+        }
+        catch (error) {
+            console.warn(`[simulator-ui] project window did not take extension "${registration.id}":`, error instanceof Error ? error.message : String(error));
+        }
+    }
+    return {
+        attachTo: (window) => {
+            for (const [registration, targets] of ledger)
+                tryAttach(window, targets, registration);
+        },
+        register: (registration) => {
+            // Checked here, before anything is recorded: the ledger owns the
+            // app-level set of registrations, and hosts register in `onSetup` where
+            // there is no project window to do the checking. A rejected registration
+            // must leave no record — otherwise it is handed to every project window
+            // opened afterwards and takes each of them down as it is built.
+            // Snapshotted before anything reads it: the ledger outlives this call and
+            // hands the registration to every project window opened later, so a host
+            // that reuses its object to describe the next extension would otherwise
+            // rewrite what an already-registered one means — the id it releases, and
+            // the extension future windows are given.
+            const snapshot = { ...registration };
+            assertSimulatorUiExtensionShape(snapshot);
+            const id = snapshot.id;
+            if (ids.has(id)) {
+                throw new Error(`Simulator UI extension "${id}" is already registered`);
+            }
+            const targets = [];
+            ids.add(id);
+            ledger.set(snapshot, targets);
+            for (const window of deps.projectWindows())
+                tryAttach(window, targets, snapshot);
+            return {
+                dispose: () => {
+                    // Only while this registration is the one holding the id: a second
+                    // dispose must not free an id a later registration now owns.
+                    if (!ledger.delete(snapshot))
+                        return;
+                    ids.delete(id);
+                    // Copied: disposing a window-owned record splices it out of `targets`.
+                    for (const target of [...targets])
+                        void target.owned.dispose();
+                    targets.length = 0;
+                },
+                invoke: (method, params) => {
+                    const active = deps.activeWindow();
+                    const target = targets.find((t) => t.window === active) ?? targets[targets.length - 1];
+                    if (!target)
+                        throw new Error('simulator UI extension has no live window');
+                    return target.extension.invoke(method, params);
+                },
+            };
+        },
+    };
+}
+//# sourceMappingURL=ui-extension-targets.js.map

package/dist/main/app/window-close-reveal.harness.d.ts

@@ -0,0 +1,34 @@
+export { stubs, devkitStubs } from '../runtime/devtools-runtime-mock.harness.js';
+/**
+ * Shared per-test setup: reset modules (fresh module-level state each test),
+ * reset the mock harness above, and dynamically re-import `electron` +
+ * `createDevtoolsRuntime` + the lifecycle flag — dynamic, not a static
+ * top-level import, because it must happen AFTER `vi.resetModules()` picks
+ * up a fresh module instance each test. Registers its own `beforeEach`; call
+ * once per describing test file.
+ */
+export interface RuntimeTestState {
+    createDevtoolsRuntime: typeof import('./app.js').createDevtoolsRuntime;
+    registerAppLifecycle: typeof import('./lifecycle.js').registerAppLifecycle;
+    isAppQuitting: typeof import('./lifecycle.js').isAppQuitting;
+    electron: typeof import('electron');
+}
+export declare function registerRuntimeTestLifecycle(): RuntimeTestState;
+/**
+ * Registers `projectDir` as an openable project (app.json present, empty
+ * projects list) and opens it in its own window via the real
+ * `openProjectWindow`. Does NOT open a devkit session — the close guards
+ * under test branch on window-list membership, not session state (teardown
+ * is unconditional; see workbench-window.ts's `wireWorkbenchWindowEvents`
+ * doc comment), so a session adds cost without adding coverage here.
+ */
+export declare function openProjectWindow(instance: Awaited<ReturnType<typeof import('./app.js').createDevtoolsRuntime>>, projectDir: string): Promise<ReturnType<Awaited<ReturnType<typeof import('./app.js').createDevtoolsRuntime>>['projectWindows']>[number]>;
+/** A fresh Electron-shaped close event, plus a getter for whether it was prevented. */
+export declare function makeCloseEvent(): {
+    event: {
+        preventDefault: () => void;
+    };
+    prevented: () => boolean;
+};
+export declare function emitClose(win: unknown, event: unknown): void;
+//# sourceMappingURL=window-close-reveal.harness.d.ts.map

package/dist/main/app/window-close-reveal.harness.js

@@ -0,0 +1,65 @@
+/**
+ * Shared vitest mock harness for the list/workbench-window close-guard test
+ * files (`main-window-close-guard.test.ts`, `workbench-window-reveal-on-
+ * close.test.ts`, and siblings) — all drive the REAL `createDevtoolsRuntime`
+ * against the electron/fs/`@dimina-kit/devkit` mock set defined in
+ * `../runtime/devtools-runtime-mock.harness.ts`, plus the runtime-lifecycle
+ * and window-opening helpers below that those tests need in common.
+ *
+ * `vi.mock(...)` calls in the imported core module run once per importing
+ * test file's own isolated module graph (vitest scopes mocking per test
+ * file); chaining through this module has the same effect as if they were
+ * written directly in the importing file.
+ */
+import { beforeEach, vi } from 'vitest';
+import { stubs, devkitStubs } from '../runtime/devtools-runtime-mock.harness.js';
+export { stubs, devkitStubs } from '../runtime/devtools-runtime-mock.harness.js';
+export function registerRuntimeTestLifecycle() {
+    const state = {};
+    beforeEach(async () => {
+        vi.resetModules();
+        stubs.reset();
+        devkitStubs.sessionClose.mockClear();
+        state.electron = await import('electron');
+        ({ createDevtoolsRuntime: state.createDevtoolsRuntime } = await import('./app.js'));
+        ({ registerAppLifecycle: state.registerAppLifecycle, isAppQuitting: state.isAppQuitting } =
+            await import('./lifecycle.js'));
+    });
+    return state;
+}
+/**
+ * Registers `projectDir` as an openable project (app.json present, empty
+ * projects list) and opens it in its own window via the real
+ * `openProjectWindow`. Does NOT open a devkit session — the close guards
+ * under test branch on window-list membership, not session state (teardown
+ * is unconditional; see workbench-window.ts's `wireWorkbenchWindowEvents`
+ * doc comment), so a session adds cost without adding coverage here.
+ */
+export async function openProjectWindow(instance, projectDir) {
+    stubs.projectsWithAppJson.add(projectDir);
+    if (stubs.getProjectsJson() === null)
+        stubs.setProjectsJson(JSON.stringify([]));
+    await instance.openProjectWindow({ path: projectDir });
+    // The manager keys its window map by project path and this helper always
+    // opens a path it just registered, so the newest entry is the one that was
+    // asked for. Matching on anything weaker (e.g. "the first window that isn't
+    // the list window") hands back the PREVIOUSLY opened project once a second
+    // one is open, which is exactly the multi-window case these tests exist for.
+    const found = instance.projectWindows().at(-1);
+    if (!found)
+        throw new Error(`openProjectWindow(${projectDir}) did not publish a window`);
+    return found;
+}
+/** A fresh Electron-shaped close event, plus a getter for whether it was prevented. */
+export function makeCloseEvent() {
+    let count = 0;
+    return {
+        event: { preventDefault: () => { count += 1; } },
+        prevented: () => count > 0,
+    };
+}
+export function emitClose(win, event) {
+    ;
+    win.emit('close', event);
+}
+//# sourceMappingURL=window-close-reveal.harness.js.map

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

@@ -0,0 +1,15 @@
+import { BrowserWindow } from 'electron';
+import { type Disposable } from '@dimina-kit/electron-deck/main';
+/**
+ * Bring `win` back in front of the user from any hidden or minimized state.
+ *
+ * The project-list window hides instead of closing while projects are open —
+ * it owns app-level IPC that cannot be registered a second time, so it must
+ * outlive its own close button — which makes "show the project list" a real
+ * operation with several entry points (the menu, a macOS dock activate, the
+ * last project window closing). They all go through here so none of them can
+ * drift into handling only some of the hidden states.
+ */
+export declare function revealWindow(win: BrowserWindow): void;
+export declare function enableDevRendererAutoReload(rendererDir: string): Disposable;
+//# sourceMappingURL=window-events.d.ts.map

package/dist/main/app/window-events.js

@@ -0,0 +1,45 @@
+import { app, BrowserWindow } from 'electron';
+import fs from 'fs';
+import { toDisposable } from '@dimina-kit/electron-deck/main';
+/**
+ * Bring `win` back in front of the user from any hidden or minimized state.
+ *
+ * The project-list window hides instead of closing while projects are open —
+ * it owns app-level IPC that cannot be registered a second time, so it must
+ * outlive its own close button — which makes "show the project list" a real
+ * operation with several entry points (the menu, a macOS dock activate, the
+ * last project window closing). They all go through here so none of them can
+ * drift into handling only some of the hidden states.
+ */
+export function revealWindow(win) {
+    if (win.isDestroyed())
+        return;
+    if (win.isMinimized())
+        win.restore();
+    win.show();
+    win.focus();
+}
+export function enableDevRendererAutoReload(rendererDir) {
+    // Auto-reload renderer windows when dist files change during development
+    if (app.isPackaged) {
+        return toDisposable(() => { });
+    }
+    let reloadTimer = null;
+    const watcher = fs.watch(rendererDir, { recursive: true }, () => {
+        if (reloadTimer)
+            clearTimeout(reloadTimer);
+        reloadTimer = setTimeout(() => {
+            for (const win of BrowserWindow.getAllWindows()) {
+                win.webContents.reload();
+            }
+        }, 300);
+    });
+    return toDisposable(() => {
+        if (reloadTimer) {
+            clearTimeout(reloadTimer);
+            reloadTimer = null;
+        }
+        watcher.close();
+    });
+}
+//# sourceMappingURL=window-events.js.map

package/dist/main/app/window-runtime-services.d.ts

@@ -0,0 +1,41 @@
+import type { BrowserWindow } from 'electron';
+import type { ConnectionRegistry, DisposableRegistry } from '@dimina-kit/electron-deck/main';
+import type { SyncStorageChange } from '../../shared/ipc-channels.js';
+import type { SenderPolicy } from '../utils/ipc-registry.js';
+import type { BridgeRouterHandle } from '../ipc/bridge-router.js';
+import type { CdpSessionBroker } from '../services/cdp-session/index.js';
+import type { InternalDevtoolsWindow } from '../windows/internal-devtools-window/index.js';
+import type { NetworkForwarder } from '../services/network-forward/index.js';
+import type { AppDataTap } from '../services/simulator-appdata/index.js';
+import type { StorageApi } from '../services/simulator-storage/index.js';
+import type { WorkspaceService } from '../services/workspace/workspace-service.js';
+/**
+ * Narrow view of the context fields these services read, plus the four fields
+ * they publish back onto it for bridge-router to consume.
+ */
+export interface WindowRuntimeContext {
+    registry: DisposableRegistry;
+    connections: ConnectionRegistry;
+    cdpSessionBroker: CdpSessionBroker;
+    senderPolicy: SenderPolicy;
+    workspace: WorkspaceService;
+    bridge?: BridgeRouterHandle;
+    internalDevtoolsWindow?: InternalDevtoolsWindow;
+    storageApi?: StorageApi;
+    onServiceStorageChanged?: (appId: string, change: SyncStorageChange) => void;
+    networkForward?: NetworkForwarder;
+    appData?: AppDataTap;
+}
+/**
+ * Resolve the active project's appId. Shared by the storage panel filter, the
+ * native-host WXML/element-inspect services (which scope the active render
+ * guest by appId) and the editor's per-project workspace identity.
+ */
+export declare function createActiveAppIdResolver(context: Pick<WindowRuntimeContext, 'workspace'>): () => string | null;
+/**
+ * Panel-backing services that push into one window's renderer: storage, and
+ * under native-host the MCP target tracking plus the WXML / AppData /
+ * current-page streams.
+ */
+export declare function setupWindowRuntimeServices(context: WindowRuntimeContext, mainWindow: BrowserWindow, getActiveAppId: () => string | null, projectPath: string): void;
+//# sourceMappingURL=window-runtime-services.d.ts.map

package/dist/main/app/window-runtime-services.js

@@ -0,0 +1,178 @@
+import { resolveNativeAppDataKeys, resolveNativeStorageOverview } from './native-overview.js';
+import { registerMcpWindow, noteActiveBridgeId } from '../services/mcp/index.js';
+import { createRenderInspector } from '../services/render-inspect/index.js';
+import { setupSimulatorStorage } from '../services/simulator-storage/index.js';
+import { createNetworkForwarder } from '../services/network-forward/index.js';
+import { setupSimulatorWxml } from '../services/simulator-wxml/index.js';
+import { setupSimulatorAppData } from '../services/simulator-appdata/index.js';
+import { setupSimulatorCurrentPage } from '../services/simulator-current-page/index.js';
+import { toDisposable } from '@dimina-kit/electron-deck/main';
+/**
+ * Resolve the active project's appId. Shared by the storage panel filter, the
+ * native-host WXML/element-inspect services (which scope the active render
+ * guest by appId) and the editor's per-project workspace identity.
+ */
+export function createActiveAppIdResolver(context) {
+    return () => {
+        const session = context.workspace.getSession();
+        const appInfo = session?.appInfo;
+        return appInfo?.appId ?? null;
+    };
+}
+/**
+ * Panel-backing services that push into one window's renderer: storage, and
+ * under native-host the MCP target tracking plus the WXML / AppData /
+ * current-page streams.
+ */
+export function setupWindowRuntimeServices(context, mainWindow, getActiveAppId, projectPath) {
+    // MCP drives whichever project window the user is in, so each window records
+    // its own facts and this record dies with the window — other project windows
+    // keep theirs. The project path is the window's identity, taken from the
+    // project it opened with rather than read back off session state that does
+    // not exist until the first compile.
+    const mcpWindow = registerMcpWindow(context, {
+        nativeHost: false,
+        activeBridgeId: null,
+        nativeOverviewProvider: null,
+        projectPath,
+        getAppId: getActiveAppId,
+    });
+    context.registry.add(mcpWindow.dispose);
+    // Native-host: the real mini-app page runs in a nested render-host
+    // <webview> guest, not the localhost:7788 shell. Point the MCP
+    // `simulator` CDP target at the active render guest and keep it following
+    // the visible page across navigation/tab switches. Only wired under
+    // native-host so the default path stays byte-identical.
+    if (context.bridge?.isNativeHost()) {
+        mcpWindow.facts.nativeHost = true;
+        mcpWindow.facts.nativeOverviewProvider = async () => {
+            const appId = getActiveAppId();
+            const stack = context.bridge?.getPageStack?.(appId ?? undefined) ?? [];
+            const top = stack[stack.length - 1];
+            const overview = {
+                currentRoute: top?.pagePath ?? null,
+                pageStackDepth: stack.length,
+                storageKeys: [],
+                storageCount: 0,
+                appDataKeys: [],
+            };
+            if (appId) {
+                const storage = await resolveNativeStorageOverview(context, appId);
+                overview.storageKeys = storage.storageKeys;
+                overview.storageCount = storage.storageCount;
+                overview.appDataKeys = resolveNativeAppDataKeys(context, appId);
+            }
+            return overview;
+        };
+        const off = context.bridge.onRenderEvent((ev) => noteActiveBridgeId(context, ev.bridgeId));
+        context.registry.add(off);
+    }
+    // Native-host inspector: injects the render-guest IIFE and drives WXML /
+    // element-highlight against the active render-host <webview>. Reused by
+    // the storage panel (element inspect) and the WXML panel service.
+    const renderInspector = createRenderInspector({ connections: context.connections, broker: context.cdpSessionBroker });
+    const storage = setupSimulatorStorage(mainWindow.webContents, {
+        senderPolicy: context.senderPolicy,
+        connections: context.connections,
+        broker: context.cdpSessionBroker,
+        // Scopes simulator-webview discovery to THIS window — otherwise a second
+        // project window can steal the first window's already-attached simulator
+        // (see setupSimulatorStorage's `window` option doc).
+        window: mainWindow,
+        // Per-project filter for the simulator-storage panel: the simulator
+        // uses a fixed `persist:simulator` partition + a fixed simulator.html
+        // origin, so localStorage is shared across every project that has
+        // ever opened. The dimina runtime isolates writes with `${appId}_`
+        // prefixes; this callback lets the storage panel filter the CDP
+        // snapshot/event stream to the active appId.
+        getActiveAppId,
+        // Native-host: route element inspection to the active render guest, and
+        // read/write storage from the service-host window's file:// store.
+        bridge: context.bridge,
+        renderInspector,
+    });
+    context.registry.add(storage);
+    // Native-host: expose the async-storage runtime hook so bridge-router
+    // routes async wx.setStorage/etc. to the unified service-host store.
+    if (storage.storageApi) {
+        context.storageApi = storage.storageApi;
+        context.registry.add(() => { context.storageApi = undefined; });
+        // SYNC wx storage writes bypass main (they hit the service-host localStorage
+        // directly); the service-host posts `storageChanged` and bridge-router routes
+        // it here so the Storage panel stays live without a manual reload.
+        context.onServiceStorageChanged = storage.onSyncStorageChange;
+        context.registry.add(() => { context.onServiceStorageChanged = undefined; });
+    }
+    // Native-host WXML + AppData panels: main sources the data (WXML pulled
+    // from the active render guest; AppData tapped from the service→render
+    // setData stream in bridge-router) and pushes it to the renderer. Inert on
+    // the default dimina-fe path (which sources both from the simulator
+    // miniappSnapshot transport), so only wire them when native-host is on.
+    if (context.bridge?.isNativeHost()) {
+        // Native-host: surface the simulator WCV's network (wx.request/download/
+        // upload run there, not in the service host) in the embedded DevTools by
+        // injecting its raw Network.* CDP events into the DevTools front-end so the
+        // native Network tab renders them (service-host console line is the
+        // fallback). The ViewManager calls the forwarder's attachSimulator +
+        // setDevtoolsHost from attachNativeSimulator once the simulator WCV +
+        // DevTools host exist; getServiceWc here is the fallback sink target.
+        const networkForward = createNetworkForwarder({
+            getServiceWc: (appId) => context.bridge?.getServiceWc(appId) ?? null,
+            getResourceServerBaseUrl: () => context.bridge?.getResourceBaseUrl?.() ?? null,
+            // The simulator shell's own static-asset server (serves simulator.html
+            // + its JS/CSS, independent from the resource server above — see
+            // NetworkForwarderBridge.getSimulatorServerBaseUrl's doc). Host is
+            // always 'localhost' — see shared/simulator-route.ts's
+            // buildSimulatorUrlFromSpec default. Absent (null port) when no
+            // project is open.
+            getSimulatorServerBaseUrl: () => {
+                const port = context.workspace?.getSession()?.port;
+                return typeof port === 'number' ? `http://localhost:${port}/` : null;
+            },
+            connections: context.connections,
+            broker: context.cdpSessionBroker,
+        });
+        context.networkForward = networkForward;
+        context.registry.add(networkForward);
+        context.registry.add(() => { context.networkForward = undefined; });
+        // Global mirror: once the standalone internal
+        // DevTools window builds its own front-end host, mirror the full
+        // unfiltered Network stream into it. Attached AFTER context.networkForward
+        // is assigned above — the callback re-reads the mutable field on every
+        // fire, so ordering only matters for readability here, not correctness.
+        context.registry.add(toDisposable(context.internalDevtoolsWindow?.onHostChanged((hostWc) => {
+            context.networkForward?.setGlobalDevtoolsHost(hostWc);
+        }) ?? (() => { })));
+        // Main-process WebSocket traffic (wx.connectSocket runs on the Node `ws`
+        // transport, invisible to any webContents debugger): bridge-router fans
+        // the trace stream out here, and the forwarder synthesizes it into
+        // Network.webSocket* CDP events for the same Network panel sinks.
+        context.registry.add(toDisposable(context.bridge?.onNativeWebSocketTrace?.((ownerId, event) => {
+            context.networkForward?.reportWebSocketTrace(ownerId, event);
+        }) ?? (() => { })));
+        context.registry.add(setupSimulatorWxml(mainWindow.webContents, {
+            senderPolicy: context.senderPolicy,
+            bridge: context.bridge,
+            inspector: renderInspector,
+            getActiveAppId,
+        }));
+        const appDataService = setupSimulatorAppData(mainWindow.webContents, {
+            senderPolicy: context.senderPolicy,
+            getActiveAppId,
+            // AppData-panel edit write-back target: the service-host window owning
+            // the edited page bridge.
+            bridge: context.bridge,
+        });
+        // bridge-router feeds this via ctx.appData (service→render tap + evict).
+        context.appData = appDataService;
+        context.registry.add(appDataService);
+        context.registry.add(() => { context.appData = undefined; });
+        // Push the visible page route to the toolbar on every navigation (the
+        // page stack lives in the DeviceShell WCV, invisible to renderer
+        // <webview> nav events).
+        context.registry.add(setupSimulatorCurrentPage(mainWindow.webContents, {
+            bridge: context.bridge,
+        }));
+    }
+}
+//# sourceMappingURL=window-runtime-services.js.map

package/dist/main/app/workbench-modules.d.ts

@@ -0,0 +1,24 @@
+import type { DisposableRegistry } from '@dimina-kit/electron-deck/main';
+import type { WorkbenchAppConfig } from '../../shared/types.js';
+import type { WindowContextRouter } from '../services/window-contexts/context-router.js';
+import type { ProjectWindow } from './project-window.js';
+/**
+ * The window context type, taken from `ProjectWindow` so this module doesn't
+ * import `WorkbenchContext` directly (see eslint-workbench-context-gate).
+ */
+type WindowContext = ProjectWindow['context'];
+/**
+ * The IPC half of the built-in modules: registered ONCE for the application.
+ * Each handler answers whichever window a message came from (it takes the
+ * router), so a second window needs no second registration — and must not make
+ * one, since `ipcMain.handle` is a process-wide singleton per channel.
+ */
+export declare function registerModuleIpc(config: WorkbenchAppConfig, router: WindowContextRouter<WindowContext>, appRegistry: DisposableRegistry): void;
+/**
+ * The per-window half: wiring that mutates one concrete context (the
+ * simulator's bridge router assigning `ctx.bridge` / `ctx.consoleForwarder`).
+ * Runs once per window and is parked on that window's own registry.
+ */
+export declare function setupWindowModules(config: WorkbenchAppConfig, context: WindowContext): void;
+export {};
+//# sourceMappingURL=workbench-modules.d.ts.map

package/dist/main/app/workbench-modules.js

@@ -0,0 +1,51 @@
+import { popoverModule, projectsModule, sessionModule, settingsModule, simulatorModule, } from '../ipc/index.js';
+const DEFAULT_MODULES = {
+    projects: true,
+    session: true,
+    simulator: true,
+    popover: true,
+    settings: true,
+};
+const BUILTIN_MODULES = {
+    projects: projectsModule,
+    session: sessionModule,
+    simulator: simulatorModule,
+    popover: popoverModule,
+    settings: settingsModule,
+};
+function resolveModules(config) {
+    return {
+        ...DEFAULT_MODULES,
+        ...config.modules,
+    };
+}
+/**
+ * The IPC half of the built-in modules: registered ONCE for the application.
+ * Each handler answers whichever window a message came from (it takes the
+ * router), so a second window needs no second registration — and must not make
+ * one, since `ipcMain.handle` is a process-wide singleton per channel.
+ */
+export function registerModuleIpc(config, router, appRegistry) {
+    const modules = resolveModules(config);
+    Object.keys(modules).forEach((moduleId) => {
+        if (!modules[moduleId])
+            return;
+        appRegistry.add(BUILTIN_MODULES[moduleId].setup(router));
+    });
+}
+/**
+ * The per-window half: wiring that mutates one concrete context (the
+ * simulator's bridge router assigning `ctx.bridge` / `ctx.consoleForwarder`).
+ * Runs once per window and is parked on that window's own registry.
+ */
+export function setupWindowModules(config, context) {
+    const modules = resolveModules(config);
+    Object.keys(modules).forEach((moduleId) => {
+        if (!modules[moduleId])
+            return;
+        const module = BUILTIN_MODULES[moduleId];
+        if (module.setupWindow)
+            context.registry.add(module.setupWindow(context));
+    });
+}
+//# sourceMappingURL=workbench-modules.js.map

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

@@ -0,0 +1,85 @@
+import type { BrowserWindow } from 'electron';
+import type { WorkbenchAppConfig } from '../../shared/types.js';
+import type { AppServices } from '../services/app-services.js';
+import type { WindowContextRouter } from '../services/window-contexts/context-router.js';
+import { type ProjectRef, type ProjectWindow } from './project-window.js';
+/**
+ * The window context type, taken from `ProjectWindow` so this module doesn't
+ * import `WorkbenchContext` directly (see eslint-workbench-context-gate).
+ */
+type WindowContext = ProjectWindow['context'];
+export interface WorkbenchWindowDeps {
+    config: WorkbenchAppConfig;
+    rendererDir: string;
+    appServices: AppServices;
+    router: WindowContextRouter<WindowContext>;
+    /**
+     * Per-window module wiring — the `setupWindow` half of the built-in modules
+     * (notably the simulator's `installBridgeRouter`, which assigns `ctx.bridge`
+     * / `ctx.consoleForwarder` / `ctx.diagnostics`). The IPC half is registered
+     * once against the router and is NOT repeated here.
+     */
+    setupWindowModules: (ctx: WindowContext) => void;
+    /**
+     * Told whenever `activeContext()` can have changed — a window opened, took
+     * focus, or was torn down. App-level services that hold something aimed at
+     * the active project window (the MCP CDP connections) re-aim on it.
+     */
+    onActiveContextChanged?: () => void;
+    /**
+     * Host hook, awaited before a window tears its project down, and told which
+     * project that is. A rejection is logged and swallowed: the hook runs on the
+     * way out, so it can react but never cancel the teardown behind it.
+     */
+    onBeforeClose?: (win: ProjectWindow, project: ProjectRef) => Promise<void> | void;
+    /**
+     * Host hook, awaited once the window is fully wired and before `open()`
+     * reports success, and told which project it belongs to. Unlike
+     * `onBeforeClose` it CAN fail the open: there is no usable window to react
+     * in yet, so a rejection tears the half-built window down and travels back
+     * to the caller unchanged.
+     */
+    setupProjectWindow?: (win: ProjectWindow, project: ProjectRef) => Promise<void> | void;
+    /**
+     * Gate every open waits on before it builds anything. The app registers the
+     * open-project IPC before it awaits the host's own setup hook, so a renderer
+     * that races ahead must be parked rather than handed a window the host has
+     * not finished extending. Omitted means there is nothing to wait for.
+     */
+    ready?: Promise<void>;
+}
+export interface WorkbenchWindowManager {
+    /**
+     * Open `project` in its own window, or focus the window already showing it.
+     * Resolves once the window exists and its per-window services are wired.
+     * Opens and closes of the same project are serialized, so a call arriving
+     * while that project's window is still closing waits it out and then opens a
+     * fresh window — never a second one alongside it. Rejects if the window
+     * cannot be brought up, leaving nothing behind.
+     *
+     * `awaitReady: false` skips parking on `deps.ready` (still queued behind
+     * other opens/closes of the same path). Only the host's own
+     * `instance.openProjectWindow` uses it — see `app.ts`'s call site for why.
+     * The renderer-facing IPC path always uses the default.
+     */
+    open: (project: ProjectRef, options?: {
+        awaitReady?: boolean;
+    }) => Promise<BrowserWindow>;
+    list: () => ProjectWindow[];
+    /**
+     * The workbench context the user is working in — the focused one, or the
+     * most recently opened when focus sits on the project list. Null until the
+     * first project window opens.
+     */
+    activeContext: () => WindowContext | null;
+    /**
+     * Tear every workbench window down (app quit / runtime disposal). Terminal
+     * and idempotent: once it starts, no `open()` — pending, queued or already
+     * in flight — leaves a live window behind, and it does not resolve until
+     * every in-flight open or close has settled.
+     */
+    disposeAll: () => Promise<void>;
+}
+export declare function createWorkbenchWindowManager(deps: WorkbenchWindowDeps): WorkbenchWindowManager;
+export {};
+//# sourceMappingURL=workbench-window.d.ts.map