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

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

@@ -0,0 +1,197 @@
+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);
+        }) ?? (() => { })));
+        // Main-process HTTP traffic (wx.request runs on Node http/https,
+        // invisible to any webContents debugger — that's the whole point of the
+        // migration off renderer `fetch()`, since Chromium's Fetch/CORS algorithm
+        // was attaching a spurious OPTIONS preflight to it): same trace-stream
+        // fan-out as the WebSocket case above.
+        context.registry.add(toDisposable(context.bridge?.onNativeRequestTrace?.((ownerId, event) => {
+            context.networkForward?.reportNativeRequestTrace(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

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

@@ -0,0 +1,310 @@
+import path from 'path';
+import { toDisposable } from '@dimina-kit/electron-deck/main';
+import { createInternalDevtoolsWindow } from '../windows/internal-devtools-window/index.js';
+import { revealMainWindow, wireMainWindowEvents } from '../windows/main-window/index.js';
+import { isAppQuitting } from './lifecycle.js';
+import { installGlobalMirrors } from './global-mirrors.js';
+import { setupEditorView } from './editor-view.js';
+import { createActiveAppIdResolver, setupWindowRuntimeServices } from './window-runtime-services.js';
+import { createWorkbenchWindow } from './project-window.js';
+/**
+ * Close semantics for a workbench window. Unlike the old single-window app —
+ * where closing meant "return this window to the project list" — closing a
+ * workbench window means the window itself goes away, so teardown must finish
+ * BEFORE the window is destroyed.
+ *
+ * Three guards, each covering a failure this app has actually shipped:
+ *
+ * 1. A real application quit (⌘Q / menu Quit / app.quit()) fires `before-quit`
+ *    first. Let it through: converting a quit into a project close swallows the
+ *    quit and the app can never exit with a project open.
+ * 2. A close arriving while teardown is already in flight (the user
+ *    rapid-double-clicked) MUST keep the window. This runs BEFORE any
+ *    session check on purpose: `closeProject()` → `disposeSession()`
+ *    synchronously nulls the active session before it finishes awaiting
+ *    `session.close()`, so a session-presence check would already read false
+ *    by the time the second close arrives, fall through with no
+ *    `preventDefault()`, and let Chromium destroy the window out from under a
+ *    live teardown.
+ * 3. Teardown is UNCONDITIONAL — deliberately not gated on
+ *    `hasActiveSession()`. A failed open (invalid/non-existent project) never
+ *    creates a session, yet the window still owns views, an editor server and
+ *    IPC registrations. Gating on session presence let that case skip teardown
+ *    entirely, which is how closing an invalid project used to take the whole
+ *    app down with it.
+ */
+function wireWorkbenchWindowEvents(win, ctx, teardown) {
+    let closing = false;
+    let torndown = false;
+    return wireMainWindowEvents(win, {
+        context: ctx,
+        onResize: () => ctx.views.repositionAll(),
+        onClose: async (e) => {
+            if (isAppQuitting())
+                return;
+            if (closing) {
+                e.preventDefault();
+                return;
+            }
+            // Safety net for a `close()` that arrives after teardown finished (this
+            // module destroys the window itself, which emits no `close`).
+            if (torndown)
+                return;
+            e.preventDefault();
+            closing = true;
+            try {
+                await teardown();
+            }
+            catch (err) {
+                console.error('[workbench] workbench window teardown failed:', err);
+            }
+            finally {
+                closing = false;
+                torndown = true;
+            }
+            if (!win.isDestroyed())
+                win.destroy();
+        },
+    });
+}
+export function createWorkbenchWindowManager(deps) {
+    const { config, rendererDir, appServices, router } = deps;
+    // Keyed by project path: one window per project, so a second open of the
+    // same project focuses the existing window instead of racing two sessions
+    // (and two compile workers) over the same directory.
+    const windows = new Map();
+    // Serializes every open and close of one project path. The map alone cannot
+    // carry "one window per project": an open has awaits in it, and a close
+    // awaits host code, so overlapping requests (a re-click on the project list,
+    // MCP's project_open) must queue rather than each find "no window" and build
+    // one. Entries are dropped once a path goes idle.
+    const pathQueues = new Map();
+    // Terminal state owned by this manager, deliberately not `isAppQuitting()`:
+    // a runtime can be disposed while the app keeps running, and a manager that
+    // has torn everything down must never build another window either way.
+    let disposed = false;
+    function disposedError() {
+        return new Error('workbench window manager is disposed');
+    }
+    function enqueue(path, task) {
+        const previous = pathQueues.get(path) ?? Promise.resolve();
+        // Same task on either outcome: a failed open or close must not wedge the
+        // queue for its path.
+        const result = previous.then(task, task);
+        const settled = result.then(() => { }, () => { });
+        pathQueues.set(path, settled);
+        void settled.then(() => {
+            if (pathQueues.get(path) === settled)
+                pathQueues.delete(path);
+        });
+        return result;
+    }
+    async function openWindow(project) {
+        // Checked where the queued task starts running, not where it was queued:
+        // an open sitting behind a close on the same path can be dequeued long
+        // after `disposeAll()` began, and must fail instead of resurrecting a
+        // project the app just tore down.
+        if (disposed)
+            throw disposedError();
+        const existing = windows.get(project.path);
+        if (existing && !existing.window.isDestroyed()) {
+            if (existing.window.isMinimized())
+                existing.window.restore();
+            existing.window.focus();
+            router.setActive(existing.context);
+            deps.onActiveContextChanged?.();
+            return existing.window;
+        }
+        const projectWindow = createWorkbenchWindow({ config, rendererDir, appServices, router }, project);
+        const { window, context } = projectWindow;
+        windows.set(project.path, projectWindow);
+        // Reveal gate: the window is created hidden (see `createWorkbenchWindow`)
+        // and must stay hidden until BOTH the renderer has painted its first
+        // frame (`ready-to-show`) and `setupProjectWindow` has resolved —
+        // whichever finishes second triggers the reveal, exactly once. Wired
+        // before any `await` below so a renderer that paints before the hook
+        // settles (the common case) is never missed.
+        let rendererReady = false;
+        let setupDone = false;
+        let revealed = false;
+        // Flipped the moment a close is requested, not when teardown runs: the
+        // close queues behind this open on the same path, so the hook can still
+        // resolve first and would otherwise show a window whose close was
+        // already asked for, only for the queued teardown to destroy it.
+        let closeRequested = false;
+        const revealIfReady = () => {
+            if (revealed || !rendererReady || !setupDone)
+                return;
+            if (window.isDestroyed())
+                return;
+            // Same for a manager already tearing everything down: `disposeAll()`
+            // waits for this open to settle, and the window must not flash on the
+            // way out.
+            if (closeRequested || disposed)
+                return;
+            // Permanent opt-out: the framework must never show this window, no
+            // matter how many times the two gates above are satisfied.
+            if (config.projectWindow?.autoShow === false)
+                return;
+            revealed = true;
+            revealMainWindow(window);
+        };
+        window.once('ready-to-show', () => {
+            rendererReady = true;
+            revealIfReady();
+        });
+        const teardown = async () => {
+            // A close queued behind an open that then failed (or lost to
+            // `disposeAll()`) finds the window already removed and torn down by
+            // that open's own undo path. Nothing is left to close, and the host
+            // hook must not be handed a disposed context and a destroyed window.
+            if (windows.get(project.path) !== projectWindow)
+                return;
+            try {
+                await deps.onBeforeClose?.(projectWindow, project);
+            }
+            catch (err) {
+                // The hook is the host's chance to react, not a veto: everything below
+                // (compile session, bridge router, editor server, IPC and app-level
+                // listeners) has to go, and the map entry with it, or the window's
+                // resources outlive a window nothing can reach any more.
+                console.error('[workbench] host onBeforeClose hook failed:', err);
+            }
+            try {
+                await projectWindow.dispose();
+            }
+            finally {
+                // Dropped LAST: while teardown is in flight this project still has a
+                // window, and an open arriving mid-close must queue behind it (see
+                // `enqueue`) instead of finding an empty map and building a second one.
+                if (windows.get(project.path) === projectWindow)
+                    windows.delete(project.path);
+            }
+            // After the map entry is gone, so listeners read the window that is left.
+            deps.onActiveContextChanged?.();
+        };
+        try {
+            // The standalone internal DevTools window debugs THIS window's renderer,
+            // so it is per-window wiring. `isAppQuitting` lets the controller stop
+            // intercepting 'close' during a real quit.
+            context.internalDevtoolsWindow = createInternalDevtoolsWindow(window, { isAppQuitting });
+            context.registry.add(toDisposable(() => context.internalDevtoolsWindow?.dispose()));
+            // Wired before the awaited steps below: the window is already closable
+            // even though it's still hidden behind the reveal gate above, so it
+            // must never exist without the close handling that disposes it.
+            context.registry.add(wireWorkbenchWindowEvents(window, context, () => {
+                closeRequested = true;
+                return enqueue(project.path, teardown);
+            }));
+            // Whichever workbench window the user is looking at answers the IPC that
+            // no single window owns (menus, app-level host windows).
+            const onFocus = () => {
+                router.setActive(context);
+                deps.onActiveContextChanged?.();
+            };
+            window.on('focus', onFocus);
+            context.registry.add(toDisposable(() => {
+                if (!window.isDestroyed())
+                    window.removeListener('focus', onFocus);
+            }));
+            // Order matters: the bridge router assigns ctx.bridge / ctx.consoleForwarder
+            // / ctx.diagnostics, which both the mirrors and the runtime services read.
+            deps.setupWindowModules(context);
+            installGlobalMirrors(context, window);
+            const getActiveAppId = createActiveAppIdResolver(context);
+            setupWindowRuntimeServices(context, window, getActiveAppId, project.path);
+            await setupEditorView(config, context, getActiveAppId);
+            // `disposeAll()` can land while this open is parked above. It waits for
+            // this task to settle rather than reaching into a half-built window, so
+            // the undo below is this open's own job.
+            if (disposed)
+                throw disposedError();
+            // Last, so the host configures a window whose own services are all up.
+            // It runs while the window is already in `windows`: a hook that opens
+            // views or drives the session needs the window reachable, and a failure
+            // path below removes the entry again.
+            await deps.setupProjectWindow?.(projectWindow, project);
+            // Re-checked after the hook for the same reason as before it: the hook
+            // is host code of unbounded duration, and an open that lost the race
+            // must reject rather than hand back a window `disposeAll()` is about
+            // to destroy.
+            if (disposed)
+                throw disposedError();
+            // Does not block `open()` returning: if `ready-to-show` already fired,
+            // this reveals now; otherwise it just marks the gate and the pending
+            // `ready-to-show` listener above reveals once Chromium paints.
+            setupDone = true;
+            revealIfReady();
+        }
+        catch (err) {
+            // A half-built window (the editor's http server can fail to bind) leaves
+            // live services behind and keeps the project counted as open — which is
+            // what the list window reads to decide whether to stay hidden. Undo the
+            // whole thing before handing the failure back.
+            windows.delete(project.path);
+            await projectWindow.dispose().catch((disposeErr) => {
+                console.warn('[workbench] failed to dispose a partially opened window:', disposeErr);
+            });
+            if (!window.isDestroyed())
+                window.destroy();
+            throw err;
+        }
+        deps.onActiveContextChanged?.();
+        return window;
+    }
+    return {
+        // One project window per RESOLVED absolute path: two differently-spelled
+        // strings pointing at the same directory ('/a/b' vs '/a/b/.') must not
+        // race two windows (and two compile workers) over one project. Resolving
+        // here, before the path reaches `windows`/`pathQueues`/`openWindow`,
+        // keeps every downstream lookup keyed on the one canonical spelling.
+        open: (project, options) => {
+            const normalized = { ...project, path: path.resolve(project.path) };
+            // The readiness gate is awaited inside the queued task, not before
+            // queuing: opens of one path must keep their arrival order, and a
+            // `disposeAll()` landing meanwhile still finds this open in the queue it
+            // drains rather than floating loose outside it.
+            const awaitReady = options?.awaitReady ?? true;
+            return enqueue(normalized.path, async () => {
+                if (awaitReady)
+                    await deps.ready;
+                return openWindow(normalized);
+            });
+        },
+        list: () => [...windows.values()],
+        activeContext: () => {
+            const active = router.active();
+            const all = [...windows.values()];
+            if (all.some((pw) => pw.context === active))
+                return active;
+            return all.length > 0 ? all[all.length - 1].context : null;
+        },
+        disposeAll: async () => {
+            // Set before waiting, never after: the in-flight opens and closes being
+            // waited on are exactly the code that has to observe the terminal state
+            // in order to finish instead of building on.
+            disposed = true;
+            // Drained repeatedly because settling one entry releases whatever was
+            // queued behind it on the same path; new opens reject at their task
+            // start, so the queues run dry.
+            while (pathQueues.size > 0) {
+                await Promise.allSettled([...pathQueues.values()]);
+            }
+            // Snapshotted only now: an open that lost the race above already removed
+            // and disposed itself, and a finished close already dropped its entry,
+            // so nothing here is disposed twice.
+            const all = [...windows.values()];
+            windows.clear();
+            // Serial: each teardown closes a devkit session and an http server, and
+            // a parallel storm during quit is exactly when those races bite.
+            for (const projectWindow of all) {
+                await projectWindow.dispose().catch((err) => {
+                    console.warn('[workbench] failed to tear down workbench window:', err);
+                });
+                if (!projectWindow.window.isDestroyed())
+                    projectWindow.window.destroy();
+            }
+        },
+    };
+}
+//# sourceMappingURL=workbench-window.js.map