@dimina-kit/devtools 0.3.2-dev.20260601115343 → 0.3.2-dev.20260610114009

package/dist/main/app/app.js

@@ -1,22 +1,28 @@
-import { setupCdpPort, registerDifileScheme } from './bootstrap.js';
+import { setupCdpPort, registerDifileScheme, suppressInsecureCspWarnings } from './bootstrap.js';
 import { registerProjectFsIpc } from '../ipc/project-fs.js';
 import { app, BrowserWindow, nativeImage, session } from 'electron';
 import fs from 'fs';
 import path from 'path';
 import { rendererDir as defaultRendererDir, defaultPreloadPath } from '../utils/paths.js';
 import { installThemeBackgroundSync } from '../utils/theme.js';
-import { registerAppLifecycle } from './lifecycle.js';
 import { createMainWindow, wireMainWindowEvents } from '../windows/main-window/index.js';
 import { createWorkbenchContext } from '../services/workbench-context.js';
 import { loadWorkbenchSettings, applyTheme } from '../services/settings/index.js';
 import { installAppMenu } from '../menu/index.js';
 import { registerAppIpc, popoverModule, projectsModule, sessionModule, settingsModule, simulatorModule, } from '../ipc/index.js';
 import { startAutomationServer } from '../services/automation/index.js';
-import { startMcpServer } from '../services/mcp/index.js';
+import { startMcpServer, setNativeHost, setActiveBridgeId, setNativeOverviewProvider, } from '../services/mcp/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 { createRenderInspector } from '../services/render-inspect/index.js';
 import { setupSimulatorTempFiles } from '../services/simulator-temp-files/index.js';
+import { SHARED_MINIAPP_PARTITION } from '../services/views/miniapp-partition.js';
+import { setupSimulatorSessionPolicy } from '../services/views/simulator-session-policy.js';
 import { UpdateManager } from '../services/update/index.js';
-import { toDisposable } from '../utils/disposable.js';
+import { toDisposable } from '@dimina-kit/electron-deck/main';
 import { IpcRegistry } from '../utils/ipc-registry.js';
 const DEFAULT_MODULES = {
     projects: true,
@@ -124,11 +130,6 @@ function createConfiguredMainWindow(config, rendererDir) {
         height: config.window?.height,
         minWidth: config.window?.minWidth,
         minHeight: config.window?.minHeight,
-        // P1: pass the same preload path the workbench context stores on
-        // ctx.preloadPath so hosts that ship a custom simulator preload are the
-        // ones registered on the persist:simulator session — otherwise the
-        // backstop wouldn't be the host's script.
-        simulatorPreloadPath: config.preloadPath ?? defaultPreloadPath,
     });
     // Set window/taskbar icon if provided (Linux/Windows; macOS uses app bundle icon)
     if (config.icon) {
@@ -213,6 +214,10 @@ function setupMcp() {
 }
 function wireAppWindowEvents(config, instance) {
     const { mainWindow, context } = instance;
+    // In-flight guard: `closeProject()` is async, and the window stays open
+    // (preventDefault'd) while it runs — a second close click during that window
+    // would re-enter and tear the same session down twice. Swallow re-entrancy.
+    let closing = false;
     return wireMainWindowEvents(mainWindow, {
         context,
         onResize: () => context.views.repositionAll(),
@@ -226,11 +231,19 @@ function wireAppWindowEvents(config, instance) {
             // unable to invoke anything, so subsequent clicks on Import/etc. would
             // raise `No handler registered for ...`.
             e.preventDefault();
-            if (config.onBeforeClose) {
-                await config.onBeforeClose(instance);
+            if (closing)
+                return;
+            closing = true;
+            try {
+                if (config.onBeforeClose) {
+                    await config.onBeforeClose(instance);
+                }
+                await context.workspace.closeProject();
+                context.notify.windowNavigateBack();
+            }
+            finally {
+                closing = false;
             }
-            await context.workspace.closeProject();
-            context.notify.windowNavigateBack();
         },
     });
 }
@@ -257,125 +270,239 @@ function enableDevRendererAutoReload(rendererDir) {
         watcher.close();
     });
 }
-export function createWorkbenchApp(config = {}) {
-    let setupPromise = null;
-    let appEventsRegistered = false;
-    // Lock the visible app name BEFORE app.whenReady so the dock label,
-    // ⌘-Tab card and macOS app-menu first item all read "Dimina DevTools"
-    // in both dev (unpackaged Electron) and packaged builds. `app.setName`
-    // overrides the unpackaged process name ("Electron") and is harmless
-    // when the packaged Info.plist already says the same thing.
-    // Host integrators that brand the app differently can still override
-    // `config.appName`; we keep our default consistent with `electron-builder.yml#productName`.
+/**
+ * Pre-ready bootstrap side effects (app name, CDP port, CSP suppression,
+ * privileged scheme). MUST run before `app.whenReady()`. Extracted so the `RuntimeBackend.beforeReady` hook (which launch()
+ * routes through) runs it before the framework awaits app.whenReady().
+ */
+export function runDevtoolsBootstrap(config = {}) {
+    // Lock the visible app name BEFORE app.whenReady so the dock label, ⌘-Tab
+    // card and macOS app-menu first item read the brand in dev + packaged.
     try {
         app.setName(config.appName ?? 'Dimina DevTools');
     }
     catch { /* electron stub in tests */ }
     setupCdpPort();
-    // Privileged scheme registration must run before `app.whenReady` —
-    // registering it later throws.
+    // Dev-only: silence Electron Insecure-CSP warning; no-op when packaged.
+    suppressInsecureCspWarnings();
+    // Privileged scheme registration must run before app.whenReady (else throws).
     registerDifileScheme();
-    async function setup() {
-        if (setupPromise)
-            return setupPromise;
-        setupPromise = app.whenReady().then(async () => {
-            applyTheme(loadWorkbenchSettings().theme);
-            const rendererDir = config.rendererDir ?? defaultRendererDir;
-            const mainWindow = createConfiguredMainWindow(config, rendererDir);
-            const context = createContext(config, mainWindow, rendererDir);
-            context.registry.add(registerAppIpc(context));
-            // Sandboxed project file-system IPC for the in-renderer Monaco editor.
-            context.registry.add(registerProjectFsIpc(context));
-            // One process-wide listener that re-syncs every window's native
-            // backgroundColor on theme change — windows otherwise keep the stale
-            // creation-time color (see installThemeBackgroundSync).
-            context.registry.add(installThemeBackgroundSync());
-            registerBuiltinModules(config, context);
-            // Wire the simulator-side difile:// protocol handler + temp-file IPC
-            // before host onSetup so any host-driven simulator boot sees the
-            // protocol live. The module installs its own narrow sender-policy
-            // (simulator-session-only) — see file header — because the default
-            // workbench policy intentionally rejects the simulator <webview>.
-            const simSession = session.fromPartition('persist:simulator');
-            context.registry.add(setupSimulatorTempFiles(simSession));
-            installMenu(config, mainWindow, context);
-            // Gated custom-IPC surface for the host. Bound to ctx.senderPolicy so
-            // host channels go through the same gateway as built-in IPC, and
-            // registered into ctx.registry so its handlers are torn down with the
-            // context.
-            const hostIpc = new IpcRegistry(context.senderPolicy);
-            context.registry.add(hostIpc);
-            const instance = {
-                mainWindow,
-                context,
-                ipc: hostIpc,
-                // Return the registry wrapper, not the raw disposable: disposing the
-                // wrapper splices the registry entry out AND drives the underlying
-                // teardown, so a single dispose leaves no dead entry behind.
-                registerTrustedWindow: (win) => context.registry.add(registerTrustedWindow(context, win)),
-                registerSimulatorApi: (name, handler) => context.registry.add(toDisposable(context.simulatorApis.register(name, handler))),
-                toolbar: {
-                    set: (actions) => {
-                        // `context.toolbar.set` validates id-uniqueness and throws on a
-                        // duplicate BEFORE mutating, so a rejected batch never reaches
-                        // the notify below — no phantom ActionsChanged.
-                        context.toolbar.set(actions);
-                        context.notify.toolbarActionsChanged();
-                    },
-                },
-                dispose: () => disposeContext(context),
+}
+/**
+ * Domain runtime assembly — the post-whenReady body. Builds the main window +
+ * context, registers IPC modules, stands up simulator/storage/CDP/native-host
+ * services, and returns the fat {@link WorkbenchAppInstance}. Extracted so the
+ * v2 `RuntimeBackend.assemble` reuses the exact same body (parity by shared
+ * implementation, not behavioural re-creation).
+ */
+export async function createDevtoolsRuntime(config = {}) {
+    // Self-gate on Electron readiness: this builds a BrowserWindow immediately, so
+    // it must run after `app.whenReady()`. The framework backend path already
+    // awaited it (idempotent no-op here); this guards any direct caller against
+    // constructing Electron resources before ready.
+    await app.whenReady();
+    applyTheme(loadWorkbenchSettings().theme);
+    const rendererDir = config.rendererDir ?? defaultRendererDir;
+    const mainWindow = createConfiguredMainWindow(config, rendererDir);
+    const context = createContext(config, mainWindow, rendererDir);
+    // Anchor the main window's renderer as the first Connection. Resources
+    // scoped to the main webContents (acquired by later wiring) tear down with
+    // it; see packages/electron-deck/docs/foundation.md §4.
+    context.connections.acquire(mainWindow.webContents);
+    context.registry.add(registerAppIpc(context));
+    // Sandboxed project file-system IPC for the in-renderer Monaco editor.
+    context.registry.add(registerProjectFsIpc(context));
+    // Referer/CORS webRequest policy for the simulator runtime's sessions (shared
+    // fallback + every per-project partition). Registered into the context
+    // registry so its configurator + per-session listeners are torn down with the
+    // context — re-creating the app never leaks a duplicate configurator.
+    context.registry.add(setupSimulatorSessionPolicy());
+    // One process-wide listener that re-syncs every window's native
+    // backgroundColor on theme change — windows otherwise keep the stale
+    // creation-time color (see installThemeBackgroundSync).
+    context.registry.add(installThemeBackgroundSync());
+    registerBuiltinModules(config, context);
+    // Wire the simulator-side difile:// protocol handler + temp-file IPC
+    // before host onSetup so any host-driven simulator boot sees the
+    // protocol live. The module installs its own narrow sender-policy
+    // (simulator-session-only) — see file header — because the default
+    // workbench policy intentionally rejects the simulator <webview>.
+    const simSession = session.fromPartition(SHARED_MINIAPP_PARTITION);
+    context.registry.add(setupSimulatorTempFiles(simSession));
+    installMenu(config, mainWindow, context);
+    // Gated custom-IPC surface for the host. Bound to ctx.senderPolicy so
+    // host channels go through the same gateway as built-in IPC, and
+    // registered into ctx.registry so its handlers are torn down with the
+    // context.
+    const hostIpc = new IpcRegistry(context.senderPolicy);
+    context.registry.add(hostIpc);
+    const instance = {
+        mainWindow,
+        context,
+        ipc: hostIpc,
+        // Return the registry wrapper, not the raw disposable: disposing the
+        // wrapper splices the registry entry out AND drives the underlying
+        // teardown, so a single dispose leaves no dead entry behind.
+        registerTrustedWindow: (win) => context.registry.add(registerTrustedWindow(context, win)),
+        registerSimulatorApi: (name, handler) => context.registry.add(toDisposable(context.simulatorApis.register(name, handler))),
+        toolbar: {
+            set: (actions) => {
+                // `context.toolbar.set` validates id-uniqueness and throws on a
+                // duplicate BEFORE mutating, so a rejected batch never reaches
+                // the notify below — no phantom ActionsChanged.
+                context.toolbar.set(actions);
+                context.notify.toolbarActionsChanged();
+            },
+        },
+        dispose: () => disposeContext(context),
+    };
+    if (config.onSetup) {
+        await config.onSetup(instance);
+    }
+    if (config.updateChecker) {
+        instance.updateManager = new UpdateManager({
+            checker: config.updateChecker,
+            mainWindow,
+            senderPolicy: context.senderPolicy,
+            checkInterval: config.updateOptions?.checkInterval,
+            initialDelay: config.updateOptions?.initialDelay,
+            getCurrentVersion: config.updateOptions?.getCurrentVersion,
+        });
+        context.registry.add(() => instance.updateManager.dispose());
+    }
+    await setupAutomation(instance);
+    const mcp = setupMcp();
+    if (mcp)
+        context.registry.add(mcp);
+    // Resolve the active project's appId. Shared by the storage panel filter
+    // and the native-host WXML/element-inspect services (which scope the
+    // active render guest by appId).
+    const getActiveAppId = () => {
+        const session = context.workspace.getSession();
+        const appInfo = session?.appInfo;
+        return appInfo?.appId ?? null;
+    };
+    // 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()) {
+        setNativeHost(true);
+        setNativeOverviewProvider(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 (config.onBeforeOpenProject) {
-                context.beforeOpenProject = (projectPath) => config.onBeforeOpenProject({ projectPath, instance });
+            if (appId) {
+                try {
+                    const info = await context.storageApi?.invoke(appId, 'getStorageInfo', {});
+                    if (info && typeof info === 'object') {
+                        const keys = info.keys;
+                        if (Array.isArray(keys)) {
+                            overview.storageKeys = keys.filter((key) => typeof key === 'string');
+                            overview.storageCount = keys.length;
+                        }
+                    }
+                }
+                catch {
+                    // Leave native storage empty when it is temporarily unavailable.
+                }
+                try {
+                    const snapshot = context.appData?.snapshot?.(appId);
+                    if (snapshot && typeof snapshot === 'object') {
+                        const entries = snapshot.entries;
+                        if (entries && typeof entries === 'object') {
+                            overview.appDataKeys = Object.keys(entries);
+                        }
+                    }
+                }
+                catch {
+                    // Leave native appdata empty when it has not been initialized yet.
+                }
             }
-            if (config.onSetup) {
-                await config.onSetup(instance);
-            }
-            if (config.updateChecker) {
-                instance.updateManager = new UpdateManager({
-                    checker: config.updateChecker,
-                    mainWindow,
-                    senderPolicy: context.senderPolicy,
-                    checkInterval: config.updateOptions?.checkInterval,
-                    initialDelay: config.updateOptions?.initialDelay,
-                    getCurrentVersion: config.updateOptions?.getCurrentVersion,
-                });
-                context.registry.add(() => instance.updateManager.dispose());
-            }
-            await setupAutomation(instance);
-            const mcp = setupMcp();
-            if (mcp)
-                context.registry.add(mcp);
-            context.registry.add(setupSimulatorStorage(mainWindow.webContents, {
-                senderPolicy: context.senderPolicy,
-                // 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: () => {
-                    const session = context.workspace.getSession();
-                    const appInfo = session?.appInfo;
-                    return appInfo?.appId ?? null;
-                },
-            }));
-            context.registry.add(wireAppWindowEvents(config, instance));
-            context.registry.add(enableDevRendererAutoReload(rendererDir));
-            return instance;
+            return overview;
         });
-        return setupPromise;
+        const off = context.bridge.onRenderEvent((ev) => setActiveBridgeId(ev.bridgeId));
+        context.registry.add(off);
+        context.registry.add(() => setNativeHost(false));
+        context.registry.add(() => setNativeOverviewProvider(null));
     }
-    function start() {
-        if (!appEventsRegistered) {
-            appEventsRegistered = true;
-            registerAppLifecycle();
-        }
-        return setup().then(() => undefined);
+    // 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 });
+    const storage = setupSimulatorStorage(mainWindow.webContents, {
+        senderPolicy: context.senderPolicy,
+        connections: context.connections,
+        // 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; });
     }
-    return {
-        setup,
-        start,
-    };
+    // 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 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,
+            connections: context.connections,
+        });
+        context.networkForward = networkForward;
+        context.registry.add(networkForward);
+        context.registry.add(() => { context.networkForward = undefined; });
+        context.registry.add(setupSimulatorWxml(mainWindow.webContents, {
+            senderPolicy: context.senderPolicy,
+            bridge: context.bridge,
+            inspector: renderInspector,
+            getActiveAppId,
+        }));
+        const appDataService = setupSimulatorAppData(mainWindow.webContents, {
+            senderPolicy: context.senderPolicy,
+            getActiveAppId,
+        });
+        // 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,
+        }));
+    }
+    context.registry.add(wireAppWindowEvents(config, instance));
+    context.registry.add(enableDevRendererAutoReload(rendererDir));
+    return instance;
 }
 //# sourceMappingURL=app.js.map

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

@@ -12,6 +12,22 @@ export declare function registerDifileScheme(): void;
  * Call at the very top of your entry file, before any imports that may write.
  */
 export declare function suppressEpipe(): void;
+/**
+ * Silence Electron's built-in "Insecure Content-Security-Policy" dev warning.
+ *
+ * In dev (unpackaged) the renderer is served from the Vite dev server, which
+ * does not ship a strict CSP header, so Electron prints its `Electron Security
+ * Warning (Insecure Content-Security-Policy)` notice in every frame's console.
+ * It is pure dev noise — Electron already suppresses it automatically once the
+ * app is packaged (`app.isPackaged`).
+ *
+ * This sets ONLY the log-suppression env var, and ONLY when unpackaged. It does
+ * not touch contextIsolation / sandbox / webSecurity or any other CSP-relevant
+ * window setting — the actual security posture is unchanged; we only stop the
+ * console from re-printing the warning. Must run before any window is created
+ * (Electron reads the env var when it emits the warning).
+ */
+export declare function suppressInsecureCspWarnings(): void;
 /**
  * Configure Chrome DevTools Protocol remote-debugging-port.
  * Must be called before `app.whenReady()`.

package/dist/main/app/bootstrap.js

@@ -43,6 +43,26 @@ export function suppressEpipe() {
     ignore(process.stdout);
     ignore(process.stderr);
 }
+/**
+ * Silence Electron's built-in "Insecure Content-Security-Policy" dev warning.
+ *
+ * In dev (unpackaged) the renderer is served from the Vite dev server, which
+ * does not ship a strict CSP header, so Electron prints its `Electron Security
+ * Warning (Insecure Content-Security-Policy)` notice in every frame's console.
+ * It is pure dev noise — Electron already suppresses it automatically once the
+ * app is packaged (`app.isPackaged`).
+ *
+ * This sets ONLY the log-suppression env var, and ONLY when unpackaged. It does
+ * not touch contextIsolation / sandbox / webSecurity or any other CSP-relevant
+ * window setting — the actual security posture is unchanged; we only stop the
+ * console from re-printing the warning. Must run before any window is created
+ * (Electron reads the env var when it emits the warning).
+ */
+export function suppressInsecureCspWarnings() {
+    if (app.isPackaged)
+        return;
+    process.env.ELECTRON_DISABLE_SECURITY_WARNINGS = 'true';
+}
 /**
  * Configure Chrome DevTools Protocol remote-debugging-port.
  * Must be called before `app.whenReady()`.

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

@@ -1,10 +1,14 @@
-import type { WorkbenchConfig } from '../../shared/types.js';
+import type { WorkbenchAppConfig } from '../../shared/types.js';
 import type { WorkbenchContext } from '../services/workbench-context.js';
 /**
- * Convenience launcher for the default full-featured app.
- * Use createWorkbenchApp() when you want to customize modules or window setup.
+ * Host-shell entry for the devtools app. Boots through the
+ * `@dimina-kit/electron-deck` framework orchestrator (process lifecycle gate +
+ * wire/trust) with the devtools {@link createDevtoolsBackend} supplying the full
+ * runtime — the framework is the single entry. The instance builder
+ * (`createDevtoolsRuntime`) is internal; hosts integrate via `launch(config)`,
+ * passing `WorkbenchAppConfig` (incl. `onSetup`, `apiNamespaces`, `menuBuilder`, …).
  */
-export declare function launch(config?: WorkbenchConfig): Promise<void>;
+export declare function launch(config?: WorkbenchAppConfig): Promise<void>;
 export declare function buildDefaultMenu(ctx: WorkbenchContext): void;
 export declare function openSettingsWindow(ctx: Pick<WorkbenchContext, 'rendererDir' | 'notify' | 'windows'>): Promise<void>;
 //# sourceMappingURL=launch.d.ts.map

package/dist/main/app/launch.js

@@ -1,13 +1,18 @@
-import { createWorkbenchApp } from './app.js';
+import { electronDeck as frameworkElectronDeck } from '@dimina-kit/electron-deck';
+import { createDevtoolsBackend } from '../runtime/devtools-backend.js';
 import { installAppMenu } from '../menu/index.js';
 import { createSettingsWindow, wireSettingsWindowEvents } from '../windows/settings-window/index.js';
 import { loadWorkbenchSettings } from '../services/settings/index.js';
 /**
- * Convenience launcher for the default full-featured app.
- * Use createWorkbenchApp() when you want to customize modules or window setup.
+ * Host-shell entry for the devtools app. Boots through the
+ * `@dimina-kit/electron-deck` framework orchestrator (process lifecycle gate +
+ * wire/trust) with the devtools {@link createDevtoolsBackend} supplying the full
+ * runtime — the framework is the single entry. The instance builder
+ * (`createDevtoolsRuntime`) is internal; hosts integrate via `launch(config)`,
+ * passing `WorkbenchAppConfig` (incl. `onSetup`, `apiNamespaces`, `menuBuilder`, …).
  */
 export function launch(config = {}) {
-    return createWorkbenchApp(config).start();
+    return frameworkElectronDeck({ backend: createDevtoolsBackend(config) });
 }
 export function buildDefaultMenu(ctx) {
     installAppMenu(ctx);